From e464871b69a88089a02631702b78d11688c17f15 Mon Sep 17 00:00:00 2001 From: Eric Furst Date: Tue, 3 Nov 2026 07:25:51 -0500 Subject: [PATCH] Initial public release of pdf-tools Command-line tools for marked-up PDFs and scanned handwritten notes: pdf-scrub, pdf-notes-md, scan-notes-md (Ollama by default, Claude on request), scan-notes-index (per-page search metadata), and scan-notes-stats. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011ZSvbNaLhgFuTm7wmkgbWs --- .gitignore | 10 + CLAUDE.md | 95 +++ LICENSE | 21 + README.md | 293 +++++++++ docs/ollama-context-and-gpu.md | 142 +++++ pyproject.toml | 42 ++ scan-notes.example.toml | 133 ++++ scripts/batch-index.sh | 52 ++ scripts/batch-scan.sh | 56 ++ scripts/pdf-notes-to-md.sh | 18 + scripts/scan-to-md.sh | 19 + scripts/scrub-and-mail.sh | 49 ++ src/pdf_tools/__init__.py | 2 + src/pdf_tools/common.py | 21 + src/pdf_tools/companion.py | 327 ++++++++++ src/pdf_tools/extract_pdf.py | 126 ++++ src/pdf_tools/extract_scan.py | 439 +++++++++++++ src/pdf_tools/ollama.py | 319 ++++++++++ src/pdf_tools/scan_config.py | 254 ++++++++ src/pdf_tools/scan_index.py | 316 ++++++++++ src/pdf_tools/scan_stats.py | 146 +++++ src/pdf_tools/scrub.py | 120 ++++ tests/test_cli.py | 308 +++++++++ tests/test_companion.py | 291 +++++++++ tests/test_config.py | 103 +++ tests/test_index.py | 240 +++++++ tests/test_ollama_hosts.py | 247 ++++++++ tests/test_stats.py | 36 ++ uv.lock | 1071 ++++++++++++++++++++++++++++++++ 29 files changed, 5296 insertions(+) create mode 100644 .gitignore create mode 100644 CLAUDE.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 docs/ollama-context-and-gpu.md create mode 100644 pyproject.toml create mode 100644 scan-notes.example.toml create mode 100755 scripts/batch-index.sh create mode 100755 scripts/batch-scan.sh create mode 100755 scripts/pdf-notes-to-md.sh create mode 100755 scripts/scan-to-md.sh create mode 100755 scripts/scrub-and-mail.sh create mode 100644 src/pdf_tools/__init__.py create mode 100644 src/pdf_tools/common.py create mode 100644 src/pdf_tools/companion.py create mode 100644 src/pdf_tools/extract_pdf.py create mode 100644 src/pdf_tools/extract_scan.py create mode 100644 src/pdf_tools/ollama.py create mode 100644 src/pdf_tools/scan_config.py create mode 100644 src/pdf_tools/scan_index.py create mode 100644 src/pdf_tools/scan_stats.py create mode 100644 src/pdf_tools/scrub.py create mode 100644 tests/test_cli.py create mode 100644 tests/test_companion.py create mode 100644 tests/test_config.py create mode 100644 tests/test_index.py create mode 100644 tests/test_ollama_hosts.py create mode 100644 tests/test_stats.py create mode 100644 uv.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..824be4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +.venv/ +__pycache__/ +*.pyc +.pytest_cache/ +*.egg-info/ +build/ +dist/ +.DS_Store +# Scan outputs and progress files, in case a scan is processed in the repo. +.*.scan-partial.json diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..3594c23 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,95 @@ +# CLAUDE.md -- pdf-tools + +Small command-line utilities for marked-up PDFs and scanned handwritten +notes. Python 3.11+, managed with `uv`. User-facing documentation is in +`README.md`. + +## Layout + +``` +src/pdf_tools/ + scrub.py pdf-scrub + extract_pdf.py pdf-notes-md + extract_scan.py scan-notes-md: CLI, page rendering, Claude backend + ollama.py scan-notes-md Ollama backend: prompt, host selection + companion.py scan-notes-md companion writer, driven by CompanionSpec + scan_config.py scan-notes-md config file and defaults + scan_stats.py per-page stats log and scan-notes-stats summary + scan_index.py scan-notes-index: per-page metadata files from transcripts + common.py shared helpers +scripts/ shell wrappers (Quick Actions, batch-scan.sh, batch-index.sh) +docs/ findings, e.g. ollama-context-and-gpu.md +tests/ pytest; run with `uv run pytest` +``` + +## scan-notes-md rules + +- **No cloud fallback.** `--backend ollama` must never call Claude or any + other cloud service, and `ollama.py` must not import `anthropic`. If no + Ollama host is usable, exit with an error (status 3). The tests fail if + Claude is called on an Ollama run; keep them that way. +- **Nothing personal in the code.** The package is meant to be published. + Folder paths, host names, organization names, title tables, and name + lists belong in the user's config file, never in `src/` or the defaults. + `scan-notes.example.toml` uses placeholder names. +- **Confidential folders.** Anything under a `[[confidential]]` root + defaults to Ollama, and Claude is refused without `--allow-cloud`. This + check is based on location, not on `--companion`. Keep the backend + decision in Python, not in the shell wrappers. Reject unknown config keys, + so a typo cannot silently drop a protection. +- **No stray copies.** Page images are rendered in memory. Nothing is + written outside the scan's folder except to the system temp directory, and + temp files are removed. Do not log transcript text or images. +- **Companion edits are narrow.** In an existing companion, change only + the `### Draft transcript (unverified)` block and the `transcribed_by:` + field. Layouts come from `[confidential.companion]` tables; add new + layout features as `CompanionSpec` options, not as named special cases. +- **One prompt.** The Ollama instruction is `HANDWRITING_PROMPT` in + `ollama.py`. `build_prompt` appends configured `prompt_extra` text (top + level, then per folder) and the name list. Keep domain guidance, such as + the drawing and equation rules, in config, not in the base prompt. The + Claude backend keeps its own `TRANSCRIBE_PROMPT` in `extract_scan.py`. +- **Record what we learn.** Context size, GPU memory, speed, and model + failures go in `docs/ollama-context-and-gpu.md` with a date, model, + GPU, and Ollama version. The stats log holds numbers and page labels + only, never transcript text. +- **Looping pages.** A `RepetitionError` page is retried with + `REPEAT_RETRIES` and then replaced by `REPEAT_PLACEHOLDER`; first + attempts stay at temperature 0. +- **Batch runs.** `scripts/batch-scan.sh` skips PDFs that have a `.md`. + `extract_scan` checkpoints after every page to a hidden + `..scan-partial.json` next to the scan, keyed on inputs, model, + prompt, and dpi, and removes it once the output is written. +- **Config, not code.** Hosts, models, timeouts, folders, layouts, and + per-folder names live in `~/.config/pdf-tools/scan-notes.toml`; generic + defaults are in `scan_config.py`. Keep `scan-notes.example.toml` loading + (a test checks it). + Command-line flags override the file. +- **HTTP is standard library.** Ollama calls go through `ollama._http_json` + (`urllib`), which the tests replace. Do not add an HTTP or Ollama SDK. + +## scan-notes-index rules + +- **Ollama only.** It has no Claude backend and uses the same host + selection and no-fallback rule as `--backend ollama`. +- **Generated text is labeled.** Summaries and key points are interpretation, + unlike the transcript; page files mark them machine-generated and + unverified. The prompt tells the model never to add reference details + that are not on the page; keep that. +- **Prompt and schema.** `INDEX_PROMPT` and `schema()` in `scan_index.py` + are the base; names, `prompt_extra`, and `kinds` come from `[index]` in + the config. Answers are constrained with Ollama's `format` (JSON schema) + through `ollama.chat_json`, which retries loops, output cut off at the + cap, and invalid JSON. +- **Resume by file.** A page whose file exists is skipped unless `--force`. + A failed page is reported, the others are written, and the exit status is + 4. The stats log gets `"task": "index"` records with counts only. + +## Conventions + +- Add dependencies with `uv add` (or `uv add --dev`); keep them few. +- Status and progress go to stderr; document output goes to stdout or files. +- US English spelling. No emojis in code, output, or documentation. +- Tests must not touch the network or real confidential files: fake + `_http_json`, use `tmp_path`, and declare temporary confidential folders + in a config file passed through `PDF_TOOLS_SCAN_CONFIG`. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..dd1bc84 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Eric Furst + +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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..a315da7 --- /dev/null +++ b/README.md @@ -0,0 +1,293 @@ +# pdf-tools + +Three small command-line utilities for working with marked-up PDFs and +scanned notebook pages on macOS. + +1. **`pdf-scrub`** — strip annotations from a PDF (highlights, sticky + notes, freehand, text boxes) so you can send a clean copy. +2. **`pdf-notes-md`** — extract your notes plus the highlighted passages + they refer to, write as Markdown for downstream pipelines. +3. **`scan-notes-md`** — transcribe scanned handwritten notebook pages + to Markdown via a vision-language model: a local model through Ollama + by default, or Claude through the Anthropic API when asked. Scans in + confidential folders always stay on local machines. + +## Install + +```bash +git clone pdf-tools +cd pdf-tools +uv sync +uv pip install -e . +``` + +After this, `pdf-scrub`, `pdf-notes-md`, and `scan-notes-md` are on +your `PATH` inside the project's venv. To use them from anywhere, either +activate the venv or use the shell wrappers in `scripts/`. + +`scan-notes-md` needs `ANTHROPIC_API_KEY` in the environment for the +Claude backend only. The Ollama backend needs no key and no extra packages. + +## Usage + +```bash +# Tool 1 +pdf-scrub paper.pdf # -> paper_clean.pdf +pdf-scrub paper.pdf -o out.pdf +pdf-scrub paper.pdf --include-forms # also drop form widgets + +# Tool 2 +pdf-notes-md paper.pdf # -> paper.md +pdf-notes-md paper.pdf --stdout | less + +# Tool 3 +scan-notes-md page1.jpg page2.jpg # -> page1.md +scan-notes-md notebook.pdf -o out.md +scan-notes-md --backend ollama notebook.pdf # local model +scan-notes-md --backend ollama --host local scan.pdf # laptop only +scan-notes-md ~/confidential/.../2026-10-29-notes.pdf + # confidential folder: ollama + companion +``` + +## scan-notes-md backends + +**Claude** (`--backend claude`, or `backend = "claude"` in the config) calls +the Anthropic API, one request per page, with `ANTHROPIC_API_KEY` and model +`claude-opus-5-5` unless `--model` says otherwise. Output is Markdown with one +`##` section per page. It is never used for scans in confidential folders +unless `--allow-cloud` is given. + +**Ollama** (`--backend ollama`, the default) sends each page, rendered to PNG in memory, +to a vision model on a machine you own. Hosts are tried in the order listed +in the config file. Each is checked first with a 2.5 s request to +`/api/tags`. A host that is unreachable or lacks its model is skipped with +one line of output. `--host remote` or `--host local` uses only that host +and fails if it is unavailable. If no host works, the tool exits with +status 3. It never falls back to Claude or any other cloud service. + +Each request uses `stream: false`, `think: false`, and temperature 0. Any +thinking text that leaks through is stripped. The instruction is +`HANDWRITING_PROMPT` in `src/pdf_tools/ollama.py`. Pages are joined with +`` markers, each page in a `text` code fence so that line +breaks and indentation survive Markdown rendering. + +Hosts and models come from the config file. Without one, the only host is +`http://localhost:11434` with `gemma4:e4b`. In testing on handwritten board +notes, `gemma4:31b` on a GPU workstation gave the most reliable drafts; +`gemma4:e4b` on a laptop gives a rough draft to correct. + +A remote Ollama host must listen on a reachable interface (for example +`OLLAMA_HOST=0.0.0.0` in its service environment, reached over Tailscale), +or the health check fails and every run falls back to the next host. + +### Config file + +`~/.config/pdf-tools/scan-notes.toml` (or `$PDF_TOOLS_SCAN_CONFIG`, or +`--config`) sets the default backend, `dpi`, Ollama timeouts, the host list, +and the confidential folders. Flags override it. Start from +`scan-notes.example.toml`, which is commented throughout. Unknown keys are +reported as errors, so a typo cannot silently disable a setting. In TOML, a +key written after a `[table]` header belongs to that table, so top-level +keys must come before the first one; a misplaced key is reported. + +`prompt_extra` adds text to the Ollama prompt after the base instruction. +The example file uses it for notes with drawings, arrows, and equations: +drawings become one `[FIGURE: description]` line, arrows become `->` or an +`[ARROW: from -> to]` line, and equations are copied in plain text with +Unicode symbols. A confidential folder can add its own `prompt_extra`, +which follows the top-level one. Changing the prompt starts interrupted +runs over rather than resuming them, so pages are not mixed. + +### Confidential folders and companion files + +No folder is confidential unless the config file says so. Each folder gets +one `[[confidential]]` block: + +```toml +[[confidential]] +root = "~/Documents/personnel" +names = ["Pat Example", "Facilities Office"] +``` + +When folders are nested, the deepest one applies. For a scan inside any +confidential folder: + +- The backend defaults to `ollama`. `--backend claude` is refused unless + `--allow-cloud` is also given, even with `--no-companion`. +- The folder's `prompt_extra` text, if any, is added to the Ollama prompt. +- The folder's `names` are added to the Ollama prompt: if a word plausibly + matches one of them, the model uses that spelling, and otherwise writes + `[illegible]`. Names are per folder, so a long list for one folder does + not lengthen the prompt or steer the reading for others. A top-level + `names` list applies to every Ollama run. Names are never sent to Claude. +- Output goes to the companion `.md` next to the scan. + +**Companion layout.** Without a `[confidential.companion]` table, a new +companion has `date`, `type: notes`, `scan:`, `subjects: []`, and +`transcribed_by:` in its front matter, a title from the filename, and one +Notes section. A `[confidential.companion]` table describes any other +layout: + +| Key | Meaning | +|---|---| +| `type` | value of the `type:` field | +| `sections` | `##` sections, in order | +| `transcript_section` | section that holds the draft transcript (default: the first) | +| `section_text` | starting text for named sections | +| `fields` | front-matter fields read from the path, after `date` | +| `paths` | rules that read those fields from folder names (below) | +| `allowed` | permitted values for a captured field | +| `title` | title template: `{date}`, `{stem}`, `{field}`, `{field.short}` | +| `acronyms` | words kept in capitals when folder names become title words | + +Each `[[confidential.companion.paths]]` rule has a `match` pattern over the +folders below the root. A pattern segment is a literal folder name, +`{field}` to capture one folder, or a trailing `**` for any remaining +folders. Rules are tried in order, and the first match wins. A rule can add +fixed values with `set` and a different `title`. In titles, `{field}` is +replaced by the `[confidential.titles]` entry for the captured folder name, +or by the name turned into words. `{field.short}` uses the +`".short"` entry if there is one. `scan-notes.example.toml` shows a +complete meeting-notes layout for board-service folders laid out as +`/committees///`. + +**Transcript placement.** + +- The transcript goes in the transcript section under + `### Draft transcript (unverified)`, ending with + ``. It replaces `Transcript pending; see + scan.` if present. +- The date comes from the filename, or else from the nearest dated folder. +- In an existing companion, only that block and the `transcribed_by:` + front-matter field are changed. A rerun replaces the block, including any + edits made inside it, so move corrections out of the block first. +- `transcribed_by:` records the source, such as + `ollama/localhost/gemma4:e4b`. +- `--companion` or `--no-companion` overrides the automatic choice. + Companion mode takes one PDF and cannot be combined with `-o` or + `--stdout`. A run cannot mix confidential scans with other files. + +Page images and transcripts are never written anywhere except the +companion file. The companion is written through a temporary file in the +same folder, which is renamed into place. + +### Context size, GPU memory, and run statistics + +Each page transcribed through Ollama appends one line of statistics to +`~/.local/state/pdf-tools/scan-stats.jsonl` (config key `stats_log`; `""` +turns it off): page label, image size, prompt and output tokens, stop +reason, timings, and how much of the model sat in GPU memory. No transcript +text is logged. Page labels include file names, so turn the log off if file +names are themselves sensitive. `scan-notes-stats` summarizes the log, +including how many pages would exceed a given `num_ctx`. + +Some pages send a model into a loop. Ollama either aborts the request with +"token repeat limit reached" or the output runs on until +`max_output_tokens` (`[ollama]` table, default 2048). Either way the page is +retried twice with light sampling and a repeat penalty. A page that still +trips the repeat check is written as +`[page not transcribed: the model kept repeating itself; see scan]`; one +that still hits the output cap keeps its text, marked +`[transcript cut off at the output limit; see scan]`. + +What we have measured so far, and how to choose `num_ctx`, is in +`docs/ollama-context-and-gpu.md`. + +### Batch runs + +`scripts/batch-scan.sh ` transcribes every PDF in a folder with the +Ollama backend, skipping PDFs that already have a `.md`. Progress is saved +after each page, so rerunning the script resumes an interrupted PDF. + +## scan-notes-index: per-page search metadata + +A transcript is searchable for words you wrote, but not for what a page is +about: a derivation written mostly in symbols, a sketch, or a meeting page +whose topic is never named. `scan-notes-index` reads a transcribed scan and +writes one Markdown file per page with a machine-generated description: + +```bash +scan-notes-index "2009 notebook.pdf" # reads "2009 notebook.md" +# -> "2009 notebook pages/2009 notebook p001.md", p002.md, ... +scripts/batch-index.sh ~/notebooks # every transcribed PDF, newest first +``` + +Each page file has front matter (`kind`, `topics`, `references`, `event`, +`event_date`, `people`, `continues_from`, `continues_to`, `indexed_by`), a +summary paragraph and a list of key points marked as machine-generated and +unverified, the references written on the page, and the page's transcript. +One file per page means Spotlight or DEVONthink returns the page itself +rather than the whole notebook, and the files are ready to embed for vector +search later. + +The model sees the page image, its transcript, and the transcripts of the +previous and next pages, so calculations and notes that run across pages are +described as such. It runs only on the configured Ollama hosts, like +`--backend ollama`; there is no cloud option. Existing page files are kept, +so an interrupted run resumes; `--force` rewrites them. Settings are in the +`[index]` table of the config file: extra `names` for the prompt (added to +the transcription names), `prompt_extra`, the list of `kinds`, +`max_output_tokens` (default 1536), and `context_chars`, how much of each +neighboring page to include (default 2000). Statistics go to the same stats +log with `"task": "index"`, and `scan-notes-stats` reports them separately. + +On gemma4:31b with `num_ctx = 8192` on an RTX 4090, a page takes about 11 s +and uses at most about 3,800 tokens of context. + +### Tests + +```bash +uv run pytest +``` + +The tests fake all HTTP calls and fail if Claude is called. + +## macOS integration + +### "Scrub & Mail" Quick Action + +The `scripts/scrub-and-mail.sh` wrapper runs the scrubber, then opens a +new Mail.app compose window with the cleaned PDF attached. To wire it +up as a right-click Finder action: + +1. Open **Automator** → New Document → **Quick Action**. +2. "Workflow receives current" → **PDF files** in **Finder**. +3. Add a **Run Shell Script** action. +4. "Pass input:" **as arguments**. +5. Paste: + + ```bash + export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH" + /path/to/pdf-tools/scripts/scrub-and-mail.sh "$1" + ``` + +6. Save as "Scrub & Mail". + +It will appear under Finder right-click → Quick Actions. + +You can do the same for the other two tools (`pdf-notes-to-md.sh`, +`scan-to-md.sh`); they just save Markdown next to the input rather than +opening another app. For `scan-to-md.sh`, `scan-notes-md` chooses the +backend itself: Ollama for confidential folders, Claude elsewhere. + +### Shortcuts (alternative) + +If you prefer Shortcuts.app over Automator, create a new shortcut: +- Receive **PDF files** from **Quick Actions**. +- "Run Shell Script" with the same command. + +## Notes + +- The scrubber removes annotations from the `/Annots` arrays and clears + some metadata fields (`dc:creator`, `xmp:CreatorTool`, `pdf:Producer`) + that often leak the reviewing app or user identity. Form field + widgets are kept unless `--include-forms` is passed. +- The scrubber will not remove markings that have been *flattened* into + the page content stream by a previous export step. If your PDF + workflow ever does that, retain the unflattened original. +- The Claude call lives in `_transcribe_image` in `extract_scan.py`; the + Ollama call lives in `transcribe_png` in `ollama.py`. + +## License + +MIT; see `LICENSE`. diff --git a/docs/ollama-context-and-gpu.md b/docs/ollama-context-and-gpu.md new file mode 100644 index 0000000..011cd55 --- /dev/null +++ b/docs/ollama-context-and-gpu.md @@ -0,0 +1,142 @@ +# Ollama context size and GPU memory + +What we have learned about how much context a handwritten page needs, how +the context size decides whether a model fits in GPU memory, and how to +measure both. Update the findings below as new runs add data. + +## Why it matters + +Ollama reserves memory for the model's context window (the KV cache) when it +loads the model. A larger `num_ctx` reserves more memory. If weights plus +cache do not fit in VRAM, Ollama puts part of the model on the CPU, and every +token gets slower. Too small a context has the opposite risk: the prompt, +which includes the page image, is truncated, or the output stops early. + +One page uses: prompt text (about 300 tokens with `prompt_extra`) + image +tokens + output tokens. The context only needs to hold one page at a time, +because each page is a separate request. + +## How to measure + +Every page transcribed with the Ollama backend appends one line to the stats +log (`stats_log` in the config; default +`~/.local/state/pdf-tools/scan-stats.jsonl`). A line records the page label, +image size in pixels, prompt and output tokens, the stop reason, timings, +and how the model was loaded: total size, bytes in VRAM, and the context +length (from Ollama's `/api/ps`). It never records transcript text. + +```bash +scan-notes-stats # summary of everything logged +scan-notes-stats --run last # most recent run only +scan-notes-stats --threshold 6144 --threshold 8192 --top 10 +``` + +The summary reports, per model and loaded context size, token percentiles, +how many pages would need more than each threshold, pages whose output hit a +length limit, pages where the model looped, the share of the model in GPU +memory, and seconds per page. + +During a run, `scan-notes-md` warns when a page's output stops at a length +limit or uses more than 90% of the loaded context. + +To try a smaller context, set `num_ctx` on the host in the config: + +```toml +[[ollama.hosts]] +name = "local" +url = "http://localhost:11434" +model = "gemma4:31b" +num_ctx = 8192 +``` + +Changing `num_ctx` does not invalidate saved progress, so an interrupted +notebook resumes. Check `ollama ps` afterwards: the PROCESSOR column should +read `100% GPU`. + +## Findings + +### 2026-11-01: gemma4:31b on an RTX 4090 (24 GB), Ollama 0.40.13 + +- **Default context.** With no `num_ctx` set, Ollama loaded the model with a + 32,768-token context: 21.2 GB in all, 20.0 GB in VRAM, so `ollama ps` + showed 6%/94% CPU/GPU. The card was nearly full (23.4 of 24.6 GB). +- **First pages.** On the first 10 logged pages (2200 x 1700 to 2339 x 1653 + px at 200 dpi), prompts were 768 to 787 tokens (base prompt, + `prompt_extra`, and image) and outputs 351 to 462 tokens; the largest page + used 1,230 tokens, under 4% of the loaded context. The image accounts for + most of the prompt and varies little with page size. Pages averaged 15 s, + so a 2,562-page batch takes about 11 hours at this setting. +- **Looping.** Some pages make the model repeat itself until Ollama aborts + the request with `prediction aborted, token repeat limit reached`. At + temperature 0 the same page usually fails the same way: one page failed + in two separate runs, though it went through on a third, because GPU + inference at temperature 0 is not perfectly deterministic. It happened on + 2 of the first 70 pages. `scan-notes-md` now retries + such a page with a little sampling (temperature 0.3, then 0.6, with a + repeat penalty) and, if it still loops, writes a visible placeholder: + `[page not transcribed: the model kept repeating itself; see scan]`. + `scan-notes-stats` counts retried pages and placeholders. +- **Runaway output.** A model can also loop without tripping the repeat + check. Ollama's default output limit is unlimited, so such a page ran + past six minutes and would have failed at the 600 s timeout on every + rerun. `max_output_tokens` (default 2048, passed as `num_predict`) now + stops it early. A page that hits the cap is retried like a looping page; + if it hits the cap every time, its text is kept and marked + `[transcript cut off at the output limit; see scan]`. The output cap also + bounds the context a page can use: prompt plus at most 2,048 output + tokens. + +### 2026-11-02: full run, 40 notebooks, same setup + +The stats log covers 2,494 of the 2,562 pages; the first notebook (68 pages) +was transcribed before logging was added. + +| Measure | mean | p50 | p90 | p99 | max | +|---|---|---|---|---|---| +| Prompt tokens (incl. image) | 781 | 787 | 787 | 787 | 797 | +| Output tokens | 278 | 278 | 453 | 674 | 1,125 | +| Context used | 1,059 | 1,058 | 1,232 | 1,459 | 1,912 | + +- **Context.** No page needed more than 1,912 tokens, under 6% of the + loaded 32,768 and under half of 4,096. No page reached the 2,048-token + output cap on its final attempt. The prompt is nearly constant (768 to 797 + tokens), which suggests the model encodes each image into a fixed number of tokens; page size + and resolution barely matter; context use is set by how much is written + on the page. Even a page that hits the output cap needs only about 2,850 + tokens, so 4,096 would hold every page with this prompt. +- **GPU fit.** The model stayed at 94% GPU (21.2 GB loaded, 20.0 GB in VRAM) + for the whole run; the default context is what keeps it off the GPU + entirely. +- **Speed.** 11.1 s per page on average (p90 17.2 s, max 40.9 s), 7.7 h of + model time for the logged pages. Wall-clock time for the batch was about + 8 h. Blank and nearly blank pages take 2 to 4 s. +- **Retries.** 65 pages (2.6%) were retried: 53 after Ollama's repeat + limit, 7 after reaching the output cap, and 5 before reasons were logged. + Every one finished normally on its first retry (temperature 0.3, repeat + penalty 1.15), with 67 to 888 output tokens, so these were loops rather + than long pages. No page was left as a placeholder or marked cut off. The + repeat penalty can also discourage repetition that is really on the page + (the same value down a column), so retried pages are the ones most worth + checking against the scan; they are the log lines with `"retries": 1`. + +### 2026-11-02: 8192 context compared with 32768, one notebook + +The same 85-page notebook, same prompt and settings except +`num_ctx = 8192`: + +| | 32,768 (default) | 8,192 | +|---|---|---| +| Loaded size, GPU share | 21.2 GB, 94% GPU | 20 GB, 100% GPU | +| Seconds per page (mean) | 11.6 | 8.3 | +| Total for the notebook | 16.4 min | 11.8 min | +| Prompt time per page | 0.84 s | 0.69 s | +| Output speed | 28.9 tokens/s | 42.7 tokens/s | +| Output tokens (all pages) | 24,777 | 25,092 | +| Pages retried | 2 | 3 | + +At 8192 the whole model fits on the GPU, and output runs about 48% faster, +so pages take about 28% less time. The two runs wrote nearly the same amount +of text, so the gain is not from shorter output. The largest page in the full +run used 1,912 tokens, so 8192 leaves a wide margin. Recommendation: set +`num_ctx = 8192` for gemma4:31b on a 24 GB card. At this speed the 40-notebook +batch would take about 6 hours instead of 8. diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..6ab614a --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,42 @@ +[project] +name = "pdf-tools" +version = "0.1.0" +description = "Local PDF utilities: annotation scrubbing, note extraction, and handwritten-page OCR." +readme = "README.md" +requires-python = ">=3.11" +authors = [{ name = "Eric Furst" }] +license = { text = "MIT" } + +dependencies = [ + "pikepdf>=9.0", # robust PDF rewriting for scrubbing + "pypdf>=5.0", # text extraction under highlight rects + "pdfminer.six>=20240706", # used by pdfannots + "pdfannots>=0.4", # annotation extraction with underlying text + "Pillow>=10.4", # image handling for scan tool + "anthropic>=0.39", # Tool 3 OCR + "click>=8.1", # CLI ergonomics + "pypdfium2>=4.30", # PDF page rendering for scan tool +] + +[project.scripts] +pdf-scrub = "pdf_tools.scrub:main" +pdf-notes-md = "pdf_tools.extract_pdf:main" +scan-notes-md = "pdf_tools.extract_scan:main" +scan-notes-stats = "pdf_tools.scan_stats:main" +scan-notes-index = "pdf_tools.scan_index:main" + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = ["src/pdf_tools"] + +[dependency-groups] +dev = [ + "pytest>=9.2.0", +] + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "-p no:anyio" diff --git a/scan-notes.example.toml b/scan-notes.example.toml new file mode 100644 index 0000000..ed3b680 --- /dev/null +++ b/scan-notes.example.toml @@ -0,0 +1,133 @@ +# Example settings for scan-notes-md. Copy to +# ~/.config/pdf-tools/scan-notes.toml and edit. Command-line flags override +# these, and anything left out falls back to the built-in defaults. + +# Backend for scans outside confidential folders: "ollama" (default) or +# "claude" (the Anthropic API; needs ANTHROPIC_API_KEY). +backend = "ollama" + +# PDF render resolution. +dpi = 200 + +# Names added to the Ollama prompt for every scan. Prefer per-folder lists +# (below), which keep the prompt short and avoid steering unrelated scans. +names = [] + +# Added to the Ollama prompt after the base instruction, for every scan. +# Confidential folders can add their own prompt_extra as well. +prompt_extra = """ +The page may also contain drawings, arrows, and equations. Handle them this way: +- In place of a drawing, sketch, plot, or diagram, write one line: + [FIGURE: short description]. Name what is drawn, and include any axis + labels, units, and words written on it. Do not interpret what it shows. +- Write an arrow between words as -> (or <-, <->), keeping it on the line + where it appears. If an arrow links items on different lines or points to + something away from the text, write [ARROW: from -> to] on its own line. +- Copy equations exactly as written, in plain text. Use Unicode for Greek + letters and symbols (η, φ, ∂, ∝, ≈), ^ for superscripts, _ for + subscripts, and / for fractions. Do not solve, simplify, or complete them. +""" + +# Per-page token counts, timings, and GPU fit for Ollama runs (no transcript +# text). Summarize with scan-notes-stats. Set to "" to turn off. +stats_log = "~/.local/state/pdf-tools/scan-stats.jsonl" + +[ollama] +timeout_s = 300 # per page +probe_timeout_s = 2.5 # health check against /api/tags +max_output_tokens = 2048 # per page; stops a looping model early (0 = no cap) + +# Hosts are tried in this order. A host is skipped (with one line of output) +# if it is unreachable or does not have its model. +[[ollama.hosts]] +name = "remote" +url = "http://gpu-workstation:11434" +model = "gemma4:31b" +# num_ctx = 8192 # optional; set if the model needs it to fit on the GPU + +[[ollama.hosts]] +name = "local" +url = "http://localhost:11434" +model = "gemma4:e4b" + +# scan-notes-index: per-page search metadata (summary, key points, topics, +# references, event, people) written from a scan and its transcript. +[index] +names = [] # added to the names above, for indexing only +prompt_extra = "" +kinds = ["calculation", "idea", "sketch", "talk notes", "meeting notes", + "reading notes", "to-do", "other", "blank"] +max_output_tokens = 1536 +context_chars = 2000 # characters of the previous and next pages sent as context + +# --------------------------------------------------------------------------- +# Confidential folders. None are built in. Scans under a listed root stay on +# the Ollama hosts (Claude is refused without --allow-cloud) and are written +# to a companion .md next to the scan. When folders are nested, the +# deepest one applies. +# --------------------------------------------------------------------------- + +# Simplest form: the basic companion (date, scan, subjects, one Notes section). +[[confidential]] +root = "~/Documents/personnel" +names = [] + +# Full form: a board-service folder laid out as +# /committees/// +# /meetings// +# chair// +[[confidential]] +root = "~/Documents/board-service" +# Board members, staff, and organizations; used only for scans in this folder. +names = [] + +[confidential.companion] +type = "meeting-notes" +# Front-matter fields read from the path, in this order after `date`. +fields = ["body", "committee"] +sections = ["Attendees", "Discussion", "Decisions", "Action items"] +transcript_section = "Discussion" +# Title placeholders: {date} (long form), {stem} (filename without its date), +# {field} (display name from [confidential.titles], else the folder name in +# words), {field.short} (the ".short" title, if any). +title = "{body}, {date}" +# Words kept in capitals when a folder name is turned into words. +acronyms = ["ceo", "cfo", "llc"] + +[confidential.companion.section_text] +"Action items" = "- [ ] Owner: task (due date)" + +# Optional: values a captured field may take. A rule whose capture is not +# listed does not match, so the next rule is tried. +[confidential.companion.allowed] +body = ["BOD", "BOM"] + +# Rules are tried in order; the first match sets the fields. "{name}" captures +# one folder, a literal must match exactly, and a trailing "**" matches any +# remaining folders. `set` gives fixed values; `title` overrides the title. +[[confidential.companion.paths]] +match = "{body}/committees/{committee}/**" +title = "{body.short} {committee}, {date}" + +[[confidential.companion.paths]] +match = "{body}/meetings/**" +set = { committee = "board" } + +[[confidential.companion.paths]] +match = "chair/{committee}/**" +set = { body = "chair" } +title = "{committee}, {date}" + +[[confidential.companion.paths]] +match = "{body}/{committee}/**" +title = "{body.short} {committee}, {date}" + +[[confidential.companion.paths]] +match = "{body}/**" + +[confidential.titles] +"BOD" = "Board of Directors" +"BOD.short" = "Board" +"BOM" = "Board of Managers" +"BOM.short" = "Managers" +"finance-audit" = "Finance and Audit Committee" diff --git a/scripts/batch-index.sh b/scripts/batch-index.sh new file mode 100755 index 0000000..36ef6a7 --- /dev/null +++ b/scripts/batch-index.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +# batch-index.sh — run scan-notes-index on every transcribed PDF in a folder. +# +# usage: batch-index.sh [scan-notes-index options...] +# +# PDFs are taken newest first (reverse filename order, which is date order +# for date-prefixed names). A PDF without a .md transcript is skipped. +# Pages already indexed are kept, so the script can simply be rerun after an +# interruption. A failed PDF is reported and the batch moves on. +# +# Long runs belong in tmux: tmux new -s index 'batch-index.sh ~/notebooks' +set -uo pipefail + +if [[ $# -lt 1 || ! -d "$1" ]]; then + echo "usage: $0 [scan-notes-index options...]" >&2 + exit 64 +fi +dir="$1"; shift + +if command -v scan-notes-index >/dev/null 2>&1; then + run() { scan-notes-index "$@"; } +else + : "${PDF_TOOLS_DIR:?set PDF_TOOLS_DIR or install scan-notes-index}" + run() { (cd "$PDF_TOOLS_DIR" && uv run --quiet scan-notes-index "$@"); } +fi + +pdfs=() +while IFS= read -r -d '' f; do pdfs+=("$f"); done \ + < <(find "$dir" -type f -iname '*.pdf' -not -name '.*' -print0 | sort -rz) +total=${#pdfs[@]} +done_n=0; skipped=0; failed=() +start=$(date +%s) + +for i in "${!pdfs[@]}"; do + pdf="${pdfs[$i]}" + echo "=== [$((i + 1))/$total] ${pdf#"$dir"/} ($(date '+%H:%M'))" >&2 + if [[ ! -e "${pdf%.*}.md" ]]; then + echo "no transcript; skipping" >&2 + skipped=$((skipped + 1)) + continue + fi + if run "$@" "$pdf"; then + done_n=$((done_n + 1)) + else + failed+=("${pdf#"$dir"/}") + fi +done + +mins=$(( ($(date +%s) - start) / 60 )) +echo "=== finished in ${mins} min: $done_n indexed, $skipped skipped, ${#failed[@]} failed" >&2 +for f in ${failed[@]+"${failed[@]}"}; do echo "failed: $f" >&2; done +[[ ${#failed[@]} -eq 0 ]] diff --git a/scripts/batch-scan.sh b/scripts/batch-scan.sh new file mode 100755 index 0000000..ab52e75 --- /dev/null +++ b/scripts/batch-scan.sh @@ -0,0 +1,56 @@ +#!/usr/bin/env bash +# batch-scan.sh — transcribe every PDF in a folder with scan-notes-md. +# +# usage: batch-scan.sh [scan-notes-md options...] +# +# PDFs that already have a .md are skipped, and an interrupted PDF +# resumes from its last saved page, so the script can simply be rerun. A +# failed PDF is reported and the batch moves on to the next one. Extra +# options are passed to scan-notes-md; the default is --backend ollama, so +# nothing is sent to a cloud service unless you ask for it. +# +# Long runs belong in tmux: tmux new -s scan 'batch-scan.sh ~/notebooks' +set -uo pipefail + +if [[ $# -lt 1 || ! -d "$1" ]]; then + echo "usage: $0 [scan-notes-md options...]" >&2 + exit 64 +fi +dir="$1"; shift +opts=("$@") +[[ ${#opts[@]} -eq 0 ]] && opts=(--backend ollama) + +if command -v scan-notes-md >/dev/null 2>&1; then + run() { scan-notes-md "$@"; } +else + : "${PDF_TOOLS_DIR:?set PDF_TOOLS_DIR or install scan-notes-md}" + run() { (cd "$PDF_TOOLS_DIR" && uv run --quiet scan-notes-md "$@"); } +fi + +pdfs=() +while IFS= read -r -d '' f; do pdfs+=("$f"); done \ + < <(find "$dir" -type f -iname '*.pdf' -not -name '.*' -print0 | sort -z) +total=${#pdfs[@]} +done_n=0; skipped=0; failed=() +start=$(date +%s) + +for i in "${!pdfs[@]}"; do + pdf="${pdfs[$i]}" + md="${pdf%.*}.md" + echo "=== [$((i + 1))/$total] ${pdf#"$dir"/} ($(date '+%H:%M'))" >&2 + if [[ -e "$md" ]]; then + echo "already transcribed; skipping" >&2 + skipped=$((skipped + 1)) + continue + fi + if run "${opts[@]}" "$pdf"; then + done_n=$((done_n + 1)) + else + failed+=("${pdf#"$dir"/}") + fi +done + +mins=$(( ($(date +%s) - start) / 60 )) +echo "=== finished in ${mins} min: $done_n transcribed, $skipped skipped, ${#failed[@]} failed" >&2 +for f in ${failed[@]+"${failed[@]}"}; do echo "failed: $f" >&2; done +[[ ${#failed[@]} -eq 0 ]] diff --git a/scripts/pdf-notes-to-md.sh b/scripts/pdf-notes-to-md.sh new file mode 100755 index 0000000..5a9f2de --- /dev/null +++ b/scripts/pdf-notes-to-md.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +# pdf-notes-to-md.sh — extract PDF annotations to Markdown next to the PDF. +set -euo pipefail + +if [[ $# -lt 1 ]]; then + echo "usage: $0 [output.md]" >&2 + exit 64 +fi + +IN="$1" +OUT="${2:-${IN%.pdf}.md}" + +if command -v pdf-notes-md >/dev/null 2>&1; then + pdf-notes-md "$IN" -o "$OUT" +else + : "${PDF_TOOLS_DIR:?set PDF_TOOLS_DIR or install pdf-notes-md}" + (cd "$PDF_TOOLS_DIR" && uv run pdf-notes-md "$IN" -o "$OUT") +fi diff --git a/scripts/scan-to-md.sh b/scripts/scan-to-md.sh new file mode 100755 index 0000000..ebfd6d5 --- /dev/null +++ b/scripts/scan-to-md.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +# scan-to-md.sh — transcribe scanned pages to Markdown. +# +# scan-notes-md itself decides the backend: scans in the confidential +# folders listed in ~/.config/pdf-tools/scan-notes.toml go to Ollama and +# their companion .md; everything else uses Claude. +set -euo pipefail + +if [[ $# -lt 1 ]]; then + echo "usage: $0 [more inputs...]" >&2 + exit 64 +fi + +if command -v scan-notes-md >/dev/null 2>&1; then + scan-notes-md "$@" +else + : "${PDF_TOOLS_DIR:?set PDF_TOOLS_DIR or install scan-notes-md}" + (cd "$PDF_TOOLS_DIR" && uv run scan-notes-md "$@") +fi diff --git a/scripts/scrub-and-mail.sh b/scripts/scrub-and-mail.sh new file mode 100755 index 0000000..501acee --- /dev/null +++ b/scripts/scrub-and-mail.sh @@ -0,0 +1,49 @@ +#!/usr/bin/env bash +# scrub-and-mail.sh — scrub a PDF and open a new Mail.app message with it attached. +# +# Usage: +# scrub-and-mail.sh /path/to/file.pdf +# +# Designed to be called from a macOS Quick Action / Service / Shortcut +# with the selected PDF passed as $1. + +set -euo pipefail + +if [[ $# -lt 1 ]]; then + echo "usage: $0 " >&2 + exit 64 +fi + +IN="$1" +if [[ ! -f "$IN" ]]; then + echo "error: not a file: $IN" >&2 + exit 1 +fi + +# Write the scrubbed copy to a temp dir so we don't pollute Dropbox. +TMPDIR_OUT="$(mktemp -d -t pdfscrub)" +BASENAME="$(basename "$IN" .pdf)" +OUT="$TMPDIR_OUT/${BASENAME}_clean.pdf" + +# Resolve the CLI. Prefer the installed entry point; fall back to +# `uv run` from the project directory if you keep it ephemeral. +if command -v pdf-scrub >/dev/null 2>&1; then + pdf-scrub "$IN" -o "$OUT" >/dev/null +else + : "${PDF_TOOLS_DIR:?set PDF_TOOLS_DIR to the project path or install pdf-scrub}" + (cd "$PDF_TOOLS_DIR" && uv run pdf-scrub "$IN" -o "$OUT" >/dev/null) +fi + +# Hand off to Mail.app. POSIX path -> HFS path for AppleScript's `file`. +osascript <&2 diff --git a/src/pdf_tools/__init__.py b/src/pdf_tools/__init__.py new file mode 100644 index 0000000..ad2a6eb --- /dev/null +++ b/src/pdf_tools/__init__.py @@ -0,0 +1,2 @@ +"""pdf-tools: scrub, extract, and OCR utilities.""" +__version__ = "0.1.0" diff --git a/src/pdf_tools/common.py b/src/pdf_tools/common.py new file mode 100644 index 0000000..b63a5ec --- /dev/null +++ b/src/pdf_tools/common.py @@ -0,0 +1,21 @@ +"""Shared helpers across the three tools.""" +from __future__ import annotations + +import sys +from pathlib import Path + + +def err(msg: str) -> None: + print(msg, file=sys.stderr) + + +def must_exist(p: Path) -> Path: + if not p.exists(): + err(f"error: not found: {p}") + sys.exit(2) + return p + + +def with_suffix_before_ext(p: Path, marker: str) -> Path: + """foo.pdf + '_clean' -> foo_clean.pdf""" + return p.with_name(f"{p.stem}{marker}{p.suffix}") diff --git a/src/pdf_tools/companion.py b/src/pdf_tools/companion.py new file mode 100644 index 0000000..c470300 --- /dev/null +++ b/src/pdf_tools/companion.py @@ -0,0 +1,327 @@ +"""Companion mode: write the Markdown companion for a scan in a confidential folder. + +A scan `.pdf` is paired with `.md` in the same folder. This module +fills the front matter from the path and filename, and puts the transcript +under DRAFT_HEADING in the folder's transcript section. + +Nothing here is specific to any one organization. The shape of a companion +(front-matter fields read from the path, sections, title) comes from a +CompanionSpec, built from the folder's [confidential.companion] table in the +config file. BASIC is used when a folder does not define one. + +Existing companions are edited in two places only: the DRAFT_HEADING block +(replaced, or added if missing) and the transcribed_by: front-matter field. +Everything else in the file is kept as is. +""" +from __future__ import annotations + +import datetime as _dt +import os +import re +import tempfile +from dataclasses import dataclass, field +from pathlib import Path + +DRAFT_HEADING = "### Draft transcript (unverified)" +END_MARKER = "" +PENDING_LINE = "Transcript pending; see scan." +_DATE_PREFIX = re.compile(r"^(\d{4}-\d{2}-(?:\d{2}|xx))") +_PLACEHOLDER = re.compile(r"\{(\w+)(?:\.(short))?\}") + + +@dataclass +class PathRule: + """One way to read front-matter fields from the folders under the root. + + `match` is a "/"-separated pattern over folder names: a literal name, + "{field}" to capture one folder, or a trailing "**" for any remaining + folders. `set` gives fixed values; `title` overrides the spec's title. + """ + match: str + set: dict[str, str] = field(default_factory=dict) + title: str | None = None + + +@dataclass +class CompanionSpec: + type: str = "notes" + sections: list[str] = field(default_factory=lambda: ["Notes"]) + transcript_section: str = "Notes" + section_text: dict[str, str] = field(default_factory=dict) + title: str = "{stem}, {date}" + fields: list[str] = field(default_factory=list) + paths: list[PathRule] = field(default_factory=list) + allowed: dict[str, list[str]] = field(default_factory=dict) + acronyms: set[str] = field(default_factory=set) + + +BASIC = CompanionSpec() + + +@dataclass +class NoteMeta: + date: str # ISO date, YYYY-MM-xx, or "" if unknown + fields: dict[str, str] # spec.fields -> value ("" if unknown) + scan: str # PDF filename + title: str # title template chosen for this scan + warnings: list[str] + + +def _match(pattern: str, folders: tuple[str, ...], + allowed: dict[str, list[str]]) -> dict[str, str] | None: + segs = [s for s in pattern.strip("/").split("/") if s] + tail = bool(segs) and segs[-1] == "**" + if tail: + segs = segs[:-1] + if len(folders) < len(segs) or (not tail and len(folders) != len(segs)): + return None + got: dict[str, str] = {} + for seg, name in zip(segs, folders): + m = re.fullmatch(r"\{(\w+)\}", seg) + if m: + key = m.group(1) + if key in allowed and name not in allowed[key]: + return None + got[key] = name + elif seg != name: + return None + return got + + +def meta_from_path(pdf: Path, root: Path, spec: CompanionSpec = BASIC) -> NoteMeta: + """Derive the date and the spec's fields from where the scan sits.""" + rel = pdf.resolve().relative_to(root.resolve()) + folders = rel.parts[:-1] + warnings: list[str] = [] + + values = {f: "" for f in spec.fields} + title = spec.title + if spec.fields: + for rule in spec.paths: + got = _match(rule.match, folders, spec.allowed) + if got is not None: + values.update({k: v for k, v in {**got, **rule.set}.items() + if k in values}) + title = rule.title or title + break + missing = [f for f, v in values.items() if not v] + if missing: + warnings.append(f"cannot tell {', '.join(missing)} from the folder " + f"{'/'.join(folders) or '.'}; left empty") + + date = "" + m = _DATE_PREFIX.match(pdf.name) + if m: + date = m.group(1) + else: + for folder in reversed(folders): + m = _DATE_PREFIX.match(folder) + if m: + date = m.group(1) + break + if not date: + warnings.append("no date in the filename or folder; left date empty") + elif date.endswith("-xx"): + warnings.append(f"date {date} has no day; check it") + + return NoteMeta(date=date, fields=values, scan=pdf.name, title=title, + warnings=warnings) + + +def _words(slug: str, acronyms: set[str]) -> str: + return " ".join(w.upper() if w.lower() in acronyms else w.capitalize() + for w in re.split(r"[-_ ]+", slug) if w) + + +def title_for(meta: NoteMeta, spec: CompanionSpec = BASIC, + titles: dict[str, str] | None = None) -> str: + """Fill the title template. + + {date} is the long date; {stem} is the filename without its date prefix; + {field} is the field's display name from `titles` (or the folder name + turned into words); {field.short} uses the `.short` entry if any. + """ + titles = titles or {} + acr = {a.lower() for a in spec.acronyms} + + def display(value: str, short: bool) -> str: + if short and f"{value}.short" in titles: + return titles[f"{value}.short"] + return titles.get(value) or _words(value, acr) + + try: + d = _dt.date.fromisoformat(meta.date) + long_date = f"{d.strftime('%B')} {d.day}, {d.year}" + except ValueError: + long_date = "" + + def sub(m: re.Match) -> str: + key, short = m.group(1), bool(m.group(2)) + if key == "date": + return long_date + if key == "stem": + return _words(_DATE_PREFIX.sub("", Path(meta.scan).stem), acr) or "Notes" + return display(meta.fields.get(key, ""), short) if meta.fields.get(key) else "" + + out = _PLACEHOLDER.sub(sub, meta.title) + out = re.sub(r"\s{2,}", " ", out) + return out.strip(" ,") or Path(meta.scan).stem + + +def render_transcript(pages: list[str]) -> str: + """Page markers plus one fenced block per page. + + Fencing keeps line breaks and indentation exactly as transcribed, and + stops a line such as "# 3" on the page from turning into a heading. + """ + out = [] + for n, text in enumerate(pages, start=1): + fence = "```" + while fence in text: + fence += "`" + out += [f"", "", f"{fence}text", text, fence, ""] + return "\n".join(out).rstrip("\n") + + +def draft_block(pages: list[str]) -> str: + return f"{DRAFT_HEADING}\n\n{render_transcript(pages)}\n\n{END_MARKER}" + + +def new_companion(meta: NoteMeta, pages: list[str], transcribed_by: str, + spec: CompanionSpec = BASIC, + titles: dict[str, str] | None = None) -> str: + out = ["---", f"date: {meta.date}"] + out += [f"{k}: {v}" for k, v in meta.fields.items()] + out += [f"type: {spec.type}", f"scan: {meta.scan}", "subjects: []", + f"transcribed_by: {transcribed_by}", "---", "", + f"# {title_for(meta, spec, titles)}", ""] + sections = list(spec.sections) + if spec.transcript_section not in sections: + sections.append(spec.transcript_section) + for s in sections: + out += [f"## {s}", ""] + if s == spec.transcript_section: + out += [draft_block(pages), ""] + elif spec.section_text.get(s): + out += [spec.section_text[s].rstrip("\n"), ""] + return "\n".join(out) + + +def _set_transcribed_by(text: str, value: str) -> str: + line = f"transcribed_by: {value}" + if not text.startswith("---\n"): + return f"---\n{line}\n---\n\n{text}" + end = text.find("\n---", 4) + if end == -1: + return f"---\n{line}\n---\n\n{text}" + head, rest = text[:end], text[end:] + if re.search(r"^transcribed_by:.*$", head, flags=re.MULTILINE): + head = re.sub(r"^transcribed_by:.*$", line, head, count=1, flags=re.MULTILINE) + else: + head = f"{head}\n{line}" + return head + rest + + +_HEADING = re.compile(r"^(#{1,6})\s") +_FENCE = re.compile(r"^(`{3,}|~{3,})") + + +def _heading_level(line: str) -> int: + m = _HEADING.match(line) + return len(m.group(1)) if m else 0 + + +def _outside_fence_lines(lines: list[str]): + """Yield (index, line) for lines that are not inside a fenced code block.""" + fence = None + for i, line in enumerate(lines): + m = _FENCE.match(line) + if fence is None: + if m: + fence = m.group(1) + continue + yield i, line + elif (m and m.group(1)[0] == fence[0] and len(m.group(1)) >= len(fence) + and line.strip() == m.group(1)): + fence = None + + +def merge_companion(text: str, pages: list[str], transcribed_by: str, + section: str = "Notes") -> str: + """Put a fresh draft block into an existing companion, keeping all else.""" + text = _set_transcribed_by(text, transcribed_by) + lines = text.split("\n") + block = draft_block(pages).split("\n") + visible = list(_outside_fence_lines(lines)) + + # 1. Replace an existing draft block. + start = next((i for i, l in visible if l.rstrip() == DRAFT_HEADING), None) + if start is not None: + end = None + for i, l in visible: + if i <= start: + continue + if l.strip() == END_MARKER: + end = i + 1 + break + if 0 < _heading_level(l) <= 3: + end = i + # Keep the blank line that separated the block from the heading. + while end - 1 > start and lines[end - 1].strip() == "": + end -= 1 + break + if end is None: + end = len(lines) + while end - 1 > start and lines[end - 1].strip() == "": + end -= 1 + return "\n".join(lines[:start] + block + lines[end:]) + + # 2. Replace the pending line, wherever it is. + pending = next((i for i, l in visible if l.strip() == PENDING_LINE), None) + if pending is not None: + return "\n".join(lines[:pending] + block + lines[pending + 1:]) + + # 3. Append to the end of the transcript section. + disc = next((i for i, l in visible if l.rstrip() == f"## {section}"), None) + if disc is not None: + nxt = next((i for i, l in visible if i > disc and 0 < _heading_level(l) <= 2), + len(lines)) + ins = nxt + while ins - 1 > disc and lines[ins - 1].strip() == "": + ins -= 1 + rest = lines[nxt:] + new = lines[:ins] + [""] + block + [""] + return "\n".join(new + rest if rest else new) + + # 4. No transcript section: add the block at the end. + return f"{text.rstrip(chr(10))}\n\n{draft_block(pages)}\n" + + +def write_atomic(path: Path, text: str) -> None: + """Write via a temp file in the same folder, so a crash leaves no partial file.""" + fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=f".{path.stem}.", suffix=".tmp") + try: + with os.fdopen(fd, "w", encoding="utf-8") as f: + f.write(text) + os.replace(tmp, path) + except BaseException: + try: + os.unlink(tmp) + except FileNotFoundError: + pass + raise + + +def write_companion(pdf: Path, root: Path, pages: list[str], transcribed_by: str, + spec: CompanionSpec = BASIC, + titles: dict[str, str] | None = None) -> tuple[Path, bool, list[str]]: + """Create or update `.md`. Returns (path, created, warnings).""" + md = pdf.with_suffix(".md") + if md.exists(): + text = md.read_text(encoding="utf-8") + write_atomic(md, merge_companion(text, pages, transcribed_by, + spec.transcript_section)) + return md, False, [] + meta = meta_from_path(pdf, root, spec) + write_atomic(md, new_companion(meta, pages, transcribed_by, spec, titles)) + return md, True, meta.warnings diff --git a/src/pdf_tools/extract_pdf.py b/src/pdf_tools/extract_pdf.py new file mode 100644 index 0000000..a3da24c --- /dev/null +++ b/src/pdf_tools/extract_pdf.py @@ -0,0 +1,126 @@ +"""Tool 2: extract annotations + underlying highlighted text to Markdown. + +For each annotation: + - The note/popup text you wrote + - The text under the highlight rectangle (for Highlight / Underline / + Squiggly / StrikeOut) + - Page number + +Output is grouped by page. Each entry uses the highlighted passage as a +blockquote, followed by the note as ordinary prose. YAML frontmatter at +the top carries source filename and counts so downstream pipelines can +parse it cleanly. +""" +from __future__ import annotations + +import datetime as _dt +import sys +from dataclasses import dataclass +from pathlib import Path + +import click + +# pdfannots gives us highlight text + note text together, which is what +# we want. Its API has shifted across versions; we use the documented +# process_file entrypoint. +import pdfannots + + +@dataclass +class Note: + page: int # 1-indexed + kind: str # 'Highlight', 'Text', etc. + highlighted: str # underlying text (may be empty for sticky notes) + note: str # the comment the user typed (may be empty for bare highlights) + author: str | None + created: str | None + + +def extract(pdf_path: Path) -> list[Note]: + notes: list[Note] = [] + with pdf_path.open("rb") as fh: + doc = pdfannots.process_file(fh, emit_progress_to=None) + for annot in doc.iter_annots(): + page_num = annot.pos.page.pageno + 1 if annot.pos else 0 + notes.append(Note( + page=page_num, + kind=annot.subtype.name if hasattr(annot.subtype, "name") else str(annot.subtype), + highlighted=(annot.gettext() or "").strip(), + note=(annot.contents or "").strip(), + author=getattr(annot, "author", None), + created=str(annot.created) if getattr(annot, "created", None) else None, + )) + notes.sort(key=lambda n: (n.page, n.kind)) + return notes + + +def to_markdown(pdf_path: Path, notes: list[Note]) -> str: + today = _dt.date.today().isoformat() + lines: list[str] = [] + lines.append("---") + lines.append(f'source: "{pdf_path.name}"') + lines.append(f"extracted: {today}") + lines.append(f"annotations: {len(notes)}") + lines.append("---") + lines.append("") + lines.append(f"# Notes from {pdf_path.stem}") + lines.append("") + + if not notes: + lines.append("_No annotations found._") + return "\n".join(lines) + "\n" + + current_page = None + for n in notes: + if n.page != current_page: + lines.append(f"## Page {n.page}") + lines.append("") + current_page = n.page + + if n.highlighted: + # Blockquote the highlighted passage. Collapse internal newlines + # so the quote reads as one passage. + passage = " ".join(n.highlighted.split()) + lines.append(f"> {passage}") + lines.append("") + + if n.note: + # Sticky notes have no highlighted passage; tag them so the + # reader knows the note is freestanding, not a comment on + # the preceding quote. + if not n.highlighted: + lines.append(f"**Note ({n.kind}):** {n.note}") + else: + lines.append(n.note) + lines.append("") + elif not n.highlighted: + lines.append(f"_({n.kind} with no text)_") + lines.append("") + + return "\n".join(lines) + "\n" + + +@click.command() +@click.argument("pdf", type=click.Path(exists=True, dir_okay=False, path_type=Path)) +@click.option( + "-o", "--output", + type=click.Path(dir_okay=False, path_type=Path), + help="Output .md path. Default: .md next to the PDF.", +) +@click.option("--stdout", is_flag=True, help="Write markdown to stdout instead of a file.") +def main(pdf: Path, output: Path | None, stdout: bool) -> None: + """Extract PDF annotations to Markdown.""" + notes = extract(pdf) + md = to_markdown(pdf, notes) + + if stdout: + sys.stdout.write(md) + return + + out_path = output or pdf.with_suffix(".md") + out_path.write_text(md, encoding="utf-8") + print(f"wrote {len(notes)} annotations -> {out_path}", file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/src/pdf_tools/extract_scan.py b/src/pdf_tools/extract_scan.py new file mode 100644 index 0000000..008f2cd --- /dev/null +++ b/src/pdf_tools/extract_scan.py @@ -0,0 +1,439 @@ +"""Tool 3: extract notes from scanned notebook pages to Markdown. + +Accepts either: + - One or more image files (jpg/png/heic/tiff) + - A PDF (each page is rasterized and processed) + +Two backends: + - ollama (default): a vision model on a machine you own, through the Ollama HTTP + API (see ollama.py). Hosts are tried in the order given in the config + file (see scan_config.py). There is no fallback to any cloud service. + - claude: the Anthropic API, used only when asked for with --backend + claude or the config. Set ANTHROPIC_API_KEY. Model defaults to Claude + Opus; override with --model. + +Scans under a confidential folder (declared in the config file; none are +built in) default to the ollama backend, refuse the claude backend unless +--allow-cloud is given, and are written to a companion Markdown file shaped +by that folder's settings (see companion.py). +""" +from __future__ import annotations + +import base64 +import dataclasses +import hashlib +import io +import json +import os +import sys +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Callable +from urllib.parse import urlparse + +import click +from PIL import Image + +from . import companion +from .ollama import (REPEAT_PLACEHOLDER, REPEAT_RETRIES, NoHostAvailable, + OllamaError, PageOutput, RepetitionError, build_prompt, + loaded_model, provenance, select_host, transcribe_png) +from .scan_config import load_config +from .scan_stats import StatsLog + +# Anthropic is imported lazily inside _transcribe_image so the rest of +# the module is usable without the API key set (e.g. for --help), and so +# the ollama backend never loads it. + +# Reasonable defaults. The model is one of the few things you might +# want to tweak per-run as new versions ship. Opus is the default +# because handwriting transcription is the one place accuracy +# clearly justifies the cost. +DEFAULT_MODEL = "claude-opus-5-5" +SUPPORTED_IMAGE_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif", ".tif", ".tiff", ".heic"} + +# Exit codes beyond click's usual 1 and 2. +EXIT_NO_HOST = 3 +EXIT_TRANSCRIBE_FAILED = 4 + +TRANSCRIBE_PROMPT = """\ +You are transcribing a scanned page from a handwritten research notebook. + +Output requirements: +- Reproduce the page content as clean Markdown. +- Preserve structure: headings, bullet points, indentation, numbered lists. +- Render equations and chemical formulas in LaTeX. Inline math uses $...$, display math uses $$...$$. +- Preserve units, subscripts, and Greek letters faithfully. +- For figures, diagrams, or sketches, insert a single line like: + `[FIGURE: brief description of what is drawn]` +- For text you cannot read with confidence, use `[?]` for a single illegible word + or `[??: best guess]` if you have a tentative reading. +- Do NOT add commentary, summaries, or explanations. Transcribe only. +- Do NOT wrap your answer in code fences. Output raw Markdown directly. + +If the page is blank or contains no notebook content, output exactly: +[BLANK PAGE] +""" + + +@dataclass +class PageResult: + index: int # 1-indexed page/image number + source: str # filename or "page N of source.pdf" + markdown: str + + +def _image_to_jpeg_bytes(img: Image.Image, max_side: int = 2000, quality: int = 85) -> bytes: + """Downscale + re-encode to keep API payloads reasonable.""" + img = img.convert("RGB") + w, h = img.size + longest = max(w, h) + if longest > max_side: + scale = max_side / longest + img = img.resize((int(w * scale), int(h * scale)), Image.LANCZOS) + buf = io.BytesIO() + img.save(buf, format="JPEG", quality=quality, optimize=True) + return buf.getvalue() + + +def _image_to_png_bytes(img: Image.Image) -> bytes: + """Lossless, full resolution, in memory only (nothing is written to disk).""" + buf = io.BytesIO() + img.convert("RGB").save(buf, format="PNG") + return buf.getvalue() + + +def _transcribe_image(jpeg_bytes: bytes, model: str) -> str: + """One Claude call. The ollama backend lives in ollama.transcribe_png.""" + import anthropic # imported here so --help works without the SDK + + client = anthropic.Anthropic() # picks up ANTHROPIC_API_KEY + b64 = base64.standard_b64encode(jpeg_bytes).decode("ascii") + resp = client.messages.create( + model=model, + max_tokens=4096, + messages=[{ + "role": "user", + "content": [ + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/jpeg", + "data": b64, + }, + }, + {"type": "text", "text": TRANSCRIBE_PROMPT}, + ], + }], + ) + # Concatenate text blocks (usually just one). + return "".join(b.text for b in resp.content if getattr(b, "type", None) == "text").strip() + + +def _iter_pages(paths: list[Path], dpi: int = 200) -> list[tuple[str, Callable[[], Image.Image]]]: + """Return (label, loader) for every page across all inputs. + + Pages are rendered only when their loader is called, so a long notebook + never holds more than one page image in memory. + """ + out: list[tuple[str, Callable[[], Image.Image]]] = [] + for p in paths: + ext = p.suffix.lower() + if ext == ".pdf": + import pypdfium2 as pdfium + + doc = pdfium.PdfDocument(p) + for i in range(len(doc)): + # 200 DPI is plenty for handwriting OCR. + out.append((f"{p.name} p.{i + 1}", + lambda doc=doc, i=i: doc[i].render(scale=dpi / 72).to_pil())) + elif ext in SUPPORTED_IMAGE_EXT: + out.append((p.name, lambda p=p: Image.open(p))) + else: + print(f"warning: skipping unsupported file: {p}", file=sys.stderr) + return out + + +def _checkpoint_path(first_input: Path) -> Path: + """Progress file kept next to the scan while a run is incomplete.""" + return first_input.parent / f".{first_input.stem}.scan-partial.json" + + +def _checkpoint_key(paths: list[Path], transcribed_by: str, prompt: str, dpi: int) -> dict: + return { + "inputs": [[p.name, p.stat().st_size] for p in paths], + "transcribed_by": transcribed_by, + "prompt_sha1": hashlib.sha1(prompt.encode()).hexdigest(), + "dpi": dpi, + } + + +def _load_checkpoint(path: Path, key: dict) -> list[dict]: + """Pages saved by an earlier, interrupted run with the same settings.""" + try: + data = json.loads(path.read_text(encoding="utf-8")) + except (OSError, ValueError): + return [] + if data.get("key") != key: + print("note: ignoring saved progress from a run with different " + "inputs, model, prompt, or dpi", file=sys.stderr) + return [] + return list(data.get("pages", [])) + + +def _save_checkpoint(path: Path, key: dict, done: list[dict]) -> None: + companion.write_atomic(path, json.dumps({"key": key, "pages": done})) + + +def to_markdown(results: list[PageResult], title: str) -> str: + import datetime as _dt + lines = [ + "---", + f'title: "{title}"', + f"extracted: {_dt.date.today().isoformat()}", + f"pages: {len(results)}", + "---", + "", + f"# {title}", + "", + ] + for r in results: + lines.append(f"## {r.source}") + lines.append("") + lines.append(r.markdown if r.markdown else "_(empty)_") + lines.append("") + return "\n".join(lines) + "\n" + + +def to_plain_markdown(pages: list[str], title: str, transcribed_by: str) -> str: + """Output for ollama runs outside companion mode: markers.""" + import datetime as _dt + return "\n".join([ + "---", + f'title: "{title}"', + f"extracted: {_dt.date.today().isoformat()}", + f"pages: {len(pages)}", + f"transcribed_by: {transcribed_by}", + "---", + "", + f"# {title}", + "", + companion.render_transcript(pages), + "", + ]) + + +def _fail(msg: str, code: int = 2) -> None: + print(f"error: {msg}", file=sys.stderr) + sys.exit(code) + + +@click.command() +@click.argument( + "inputs", nargs=-1, required=True, + type=click.Path(exists=True, dir_okay=False, path_type=Path), +) +@click.option( + "-o", "--output", + type=click.Path(dir_okay=False, path_type=Path), + help="Output .md path. Default: .md", +) +@click.option( + "--backend", type=click.Choice(["claude", "ollama"]), default=None, + help="Transcription backend. Default: ollama for scans in confidential " + "folders, else the " + "config's backend (ollama unless set).", +) +@click.option( + "--host", default=None, + help="Ollama only: use just this host from the config (e.g. remote, local) " + "and fail if it is unavailable.", +) +@click.option("--model", default=None, + help=f"Model name. Default: {DEFAULT_MODEL} for claude, the " + "config's per-host model for ollama.") +@click.option("--companion/--no-companion", "companion_flag", default=None, + help="Write the companion .md next to the scan. Default: on " + "for scans in confidential folders.") +@click.option("--allow-cloud", is_flag=True, + help="Permit --backend claude for scans in confidential folders.") +@click.option("--config", "config_path", + type=click.Path(dir_okay=False, path_type=Path), default=None, + help="Config file. Default: ~/.config/pdf-tools/scan-notes.toml") +@click.option("--dpi", type=int, default=None, help="PDF render resolution (config default 200).") +@click.option("--timeout", type=float, default=None, + help="Ollama per-page timeout in seconds (config default 300).") +@click.option( + "--title", default=None, + help="Title for the markdown document. Default: first input stem.", +) +@click.option("--stdout", is_flag=True, help="Write markdown to stdout.") +def main(inputs: tuple[Path, ...], output: Path | None, backend: str | None, + host: str | None, model: str | None, companion_flag: bool | None, + allow_cloud: bool, config_path: Path | None, dpi: int | None, + timeout: float | None, title: str | None, stdout: bool) -> None: + """Transcribe scanned notebook pages to Markdown.""" + cfg = load_config(config_path) + paths = list(inputs) + + folders = [cfg.confidential_folder(p) for p in paths] + confidential = any(folders) + if confidential and not all(folders): + _fail("do not mix scans from confidential folders with other files in one run") + folder = folders[0] + companion_mode = confidential if companion_flag is None else companion_flag + if companion_mode and not confidential: + roots = ", ".join(str(c.root) for c in cfg.confidential) or "none configured" + _fail(f"--companion needs a scan in a confidential folder ({roots})") + if companion_mode: + if len(paths) != 1 or paths[0].suffix.lower() != ".pdf": + _fail("companion mode takes exactly one PDF") + if output or stdout: + _fail("companion mode writes .md next to the scan; " + "-o and --stdout need --no-companion") + + backend = backend or ("ollama" if confidential else cfg.backend) + if backend not in ("claude", "ollama"): + _fail(f"unknown backend '{backend}' in config") + if backend == "claude" and confidential and not allow_cloud: + _fail(f"scans under the confidential folder {folder.root} are not " + "sent to Claude unless " + "--allow-cloud is given; use --backend ollama") + if host and backend != "ollama": + _fail("--host applies only to --backend ollama") + + if backend == "claude": + if not os.environ.get("ANTHROPIC_API_KEY"): + _fail("ANTHROPIC_API_KEY not set") + claude_model = model or DEFAULT_MODEL + transcribed_by = f"claude/{claude_model}" + else: + hosts = cfg.hosts + if model: + hosts = [dataclasses.replace(h, model=model) for h in hosts] + try: + chosen = select_host(hosts, cfg.probe_timeout_s, forced=host) + except NoHostAvailable as e: + _fail(f"{e}. Not falling back to a cloud service.", EXIT_NO_HOST) + print(f"using Ollama host {chosen.name} " + f"({chosen.url}, {chosen.model})", file=sys.stderr) + transcribed_by = provenance(chosen) + # Global names and prompt_extra text, plus those of every folder + # the inputs come from. + names = dict.fromkeys(n for f in folders for n in cfg.names_for(f)) + extras = dict.fromkeys(e for f in folders for e in cfg.extras_for(f)) + prompt = build_prompt(list(names), list(extras)) + page_timeout = timeout or cfg.timeout_s + + dpi = dpi or cfg.dpi + pages = _iter_pages(paths, dpi=dpi) + if not pages: + _fail("no usable pages found", 1) + + # Progress is saved after every page, so an interrupted run resumes + # where it stopped. The file sits next to the scan and is removed once + # the output is written. + ckpt = _checkpoint_path(paths[0]) + key = _checkpoint_key(paths, transcribed_by, + TRANSCRIBE_PROMPT if backend == "claude" else prompt, dpi) + done = _load_checkpoint(ckpt, key)[:len(pages)] + if done: + print(f"resuming after page {len(done)} of {len(pages)}", file=sys.stderr) + + stats_log = StatsLog(cfg.stats_log if backend == "ollama" else None) + run_id = f"{time.strftime('%Y%m%dT%H%M%S')}-{os.getpid()}" + loaded: dict | None = None # /api/ps snapshot, taken once the model is loaded + + for i, (label, load) in enumerate(pages, start=1): + if i <= len(done): + continue + if backend == "claude": + print(f"[{i}/{len(pages)}] {label} ...", file=sys.stderr) + jpeg = _image_to_jpeg_bytes(load()) + md = _transcribe_image(jpeg, model=claude_model) + else: + print(f"[{i}/{len(pages)}] {label} on {chosen.name} ...", + end="", file=sys.stderr, flush=True) + t0 = time.monotonic() + img = load() + try: + page = transcribe_png(_image_to_png_bytes(img), chosen, prompt, + page_timeout, cfg.max_output_tokens) + except RepetitionError: + print("", file=sys.stderr) + print(f"warning: page {i} kept looping after {len(REPEAT_RETRIES)} " + "retries; writing a placeholder", file=sys.stderr) + page = PageOutput(REPEAT_PLACEHOLDER, { + "prompt_tokens": 0, "output_tokens": 0, "context_tokens": 0, + "done_reason": "repeat_abort", "retries": len(REPEAT_RETRIES), + "total_s": round(time.monotonic() - t0, 2)}) + except OllamaError as e: + print("", file=sys.stderr) + saved = (f"pages 1-{len(done)} are saved; rerun to resume" + if done else "nothing was saved") + _fail(f"page {i}: {e}. {saved}.", EXIT_TRANSCRIBE_FAILED) + md, st = page.text, page.stats + if loaded is None: + loaded = loaded_model(chosen, cfg.probe_timeout_s) + retried = f", {st['retries']} retries" if st.get("retries") else "" + print(f" {time.monotonic() - t0:.0f} s, {st['context_tokens']} tokens{retried}", + file=sys.stderr) + nctx = loaded.get("loaded_num_ctx") or chosen.num_ctx + if st["done_reason"] == "length": + print(f"warning: page {i} output stopped at {st['output_tokens']} " + "tokens after retries; marked as cut off", file=sys.stderr) + elif nctx and st["context_tokens"] >= 0.9 * nctx: + print(f"warning: page {i} used {st['context_tokens']} of " + f"{nctx} context tokens", file=sys.stderr) + stats_log.write({ + "time": time.strftime("%Y-%m-%dT%H:%M:%S"), + "run": run_id, + "host": urlparse(chosen.url).hostname, + "model": chosen.model, + "num_ctx_setting": chosen.num_ctx, + "dpi": dpi, + "label": label, + "page": i, + "image_px": list(img.size), + **st, + **loaded, + }) + done.append({"label": label, "text": md}) + _save_checkpoint(ckpt, key, done) + + texts = [d["text"] for d in done] + results = [PageResult(index=i, source=d["label"], markdown=d["text"]) + for i, d in enumerate(done, start=1)] + + if companion_mode: + path, created, warnings = companion.write_companion( + paths[0], folder.root, texts, transcribed_by, folder.companion, + folder.titles) + for w in warnings: + print(f"warning: {w}", file=sys.stderr) + verb = "created" if created else "updated draft transcript in" + print(f"{verb} {path}", file=sys.stderr) + ckpt.unlink(missing_ok=True) + return + + doc_title = title or paths[0].stem + if backend == "claude": + md_out = to_markdown(results, doc_title) + else: + md_out = to_plain_markdown(texts, doc_title, transcribed_by) + + if stdout: + sys.stdout.write(md_out) + ckpt.unlink(missing_ok=True) + return + + out_path = output or paths[0].with_suffix(".md") + companion.write_atomic(out_path, md_out) + ckpt.unlink(missing_ok=True) + print(f"wrote {len(results)} pages -> {out_path}", file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/src/pdf_tools/ollama.py b/src/pdf_tools/ollama.py new file mode 100644 index 0000000..a03d01b --- /dev/null +++ b/src/pdf_tools/ollama.py @@ -0,0 +1,319 @@ +"""Local transcription through the Ollama HTTP API. + +Nothing in this module talks to a cloud service, and it never imports the +Anthropic SDK. If no configured Ollama host is usable, select_host() raises +NoHostAvailable and the caller exits; there is deliberately no fallback to +Claude, because this backend exists for confidential material. + +HTTP goes through _http_json(), which tests replace with a fake. +""" +from __future__ import annotations + +import base64 +import json +import re +import socket +import sys +import urllib.error +import urllib.request +from dataclasses import dataclass, field +from urllib.parse import urlparse + +from .scan_config import OllamaHost + +# The instruction sent with every page. Edit here to change it. +HANDWRITING_PROMPT = """\ +Transcribe the handwriting in this image exactly as written. Preserve line +breaks, indentation, and bullets. Do not correct spelling, expand +abbreviations, or complete partial words. If you cannot read a word with +confidence, write [illegible] or [?word] instead of guessing; this applies +especially to names. Output only the transcript, in plain text, with no +commentary and no emojis. +""" + +# Added only when the config lists names. +NAMES_PROMPT = """\ +The notes may mention the following people and organizations. If a word +plausibly matches one of these names, use that spelling; otherwise write +[illegible]. +""" + + +@dataclass +class PageOutput: + text: str + # Counts and timings Ollama reports with each response (see page_stats). + stats: dict = field(default_factory=dict) + + +class OllamaError(RuntimeError): + pass + + +class NoHostAvailable(OllamaError): + pass + + +class RepetitionError(OllamaError): + """Ollama stopped the model because it kept repeating the same tokens.""" + + +# At temperature 0 a page that sends the model into a loop fails the same +# way every time. These retries add a little randomness and a repeat +# penalty; they are used only after that specific failure. +REPEAT_RETRIES = ( + {"temperature": 0.3, "repeat_penalty": 1.15}, + {"temperature": 0.6, "repeat_penalty": 1.3}, +) + +# Written in place of a page that still loops after the retries. +REPEAT_PLACEHOLDER = "[page not transcribed: the model kept repeating itself; see scan]" +# Appended to a page whose output still hits max_output_tokens after the retries. +CUT_OFF_MARKER = "[transcript cut off at the output limit; see scan]" + + +def build_prompt(names: list[str], extras: list[str] | None = None) -> str: + """HANDWRITING_PROMPT, then any configured prompt_extra text, then names.""" + parts = [HANDWRITING_PROMPT] + parts += [e.strip("\n") + "\n" for e in (extras or []) if e.strip()] + if names: + listed = "\n".join(f"- {n}" for n in names) + parts.append(f"{NAMES_PROMPT}{listed}\n") + return "\n".join(parts) + + +def provenance(host: OllamaHost) -> str: + """Value for the transcribed_by: field, e.g. ollama/localhost/gemma4:e4b.""" + return f"ollama/{urlparse(host.url).hostname}/{host.model}" + + +def _http_json(method: str, url: str, payload: dict | None, timeout: float) -> dict: + data = json.dumps(payload).encode() if payload is not None else None + req = urllib.request.Request( + url, data=data, method=method, + headers={"Content-Type": "application/json"} if data else {}, + ) + with urllib.request.urlopen(req, timeout=timeout) as resp: + return json.loads(resp.read().decode("utf-8")) + + +def _model_present(wanted: str, available: list[str]) -> bool: + # Ollama reports untagged models as "name:latest". + if ":" not in wanted: + wanted = f"{wanted}:latest" + return wanted in available + + +def check_host(host: OllamaHost, timeout: float) -> str | None: + """Return None if the host is up and has its model, else a short reason.""" + try: + tags = _http_json("GET", f"{host.url}/api/tags", None, timeout) + except (urllib.error.URLError, socket.timeout, TimeoutError, OSError, ValueError): + return "unreachable" + available = [m.get("name", "") for m in tags.get("models", [])] + if not _model_present(host.model, available): + return f"does not have {host.model}" + return None + + +def _describe(host: OllamaHost) -> str: + return f"{host.name} ({urlparse(host.url).hostname}, {host.model})" + + +def select_host(hosts: list[OllamaHost], timeout: float, + forced: str | None = None) -> OllamaHost: + """Return the first usable host, printing one line per host skipped. + + With forced set, only that host is considered and failure is an error. + """ + if forced is not None: + match = [h for h in hosts if h.name == forced] + if not match: + names = ", ".join(h.name for h in hosts) or "none" + raise NoHostAvailable(f"no Ollama host named '{forced}' in config (have: {names})") + reason = check_host(match[0], timeout) + if reason: + raise NoHostAvailable(f"Ollama host {_describe(match[0])} {reason}") + return match[0] + + for i, host in enumerate(hosts): + reason = check_host(host, timeout) + if reason is None: + return host + nxt = hosts[i + 1] if i + 1 < len(hosts) else None + tail = f"; falling back to {_describe(nxt)}" if nxt else "" + print(f"Ollama host {_describe(host)} {reason}{tail}", file=sys.stderr) + raise NoHostAvailable("no Ollama host is available") + + +_THINK_BLOCK = re.compile(r"<(think|thinking)>.*?", re.DOTALL | re.IGNORECASE) +_THINK_CLOSE = re.compile(r"^.*?", re.DOTALL | re.IGNORECASE) + + +def strip_thinking(text: str) -> str: + """Remove reasoning text that some models emit despite think: false.""" + text = _THINK_BLOCK.sub("", text) + # An unmatched closing tag means the opening tag was never sent. + text = _THINK_CLOSE.sub("", text, count=1) + return text.strip("\n").rstrip() + + +def page_stats(resp: dict) -> dict: + """Token counts, stop reason, and timings from an /api/chat response. + + prompt_tokens includes the image; context_tokens is what the request + occupied in the model's context window (prompt plus output). + """ + ns = 1e-9 + prompt = int(resp.get("prompt_eval_count") or 0) + output = int(resp.get("eval_count") or 0) + return { + "prompt_tokens": prompt, + "output_tokens": output, + "context_tokens": prompt + output, + "done_reason": resp.get("done_reason"), + "total_s": round((resp.get("total_duration") or 0) * ns, 2), + "load_s": round((resp.get("load_duration") or 0) * ns, 2), + "prompt_s": round((resp.get("prompt_eval_duration") or 0) * ns, 2), + "output_s": round((resp.get("eval_duration") or 0) * ns, 2), + } + + +def loaded_model(host: OllamaHost, timeout: float) -> dict: + """How the host has the model loaded, from /api/ps: total size, the part + in GPU memory, and the context length it was loaded with. Empty if the + host does not report it.""" + try: + ps = _http_json("GET", f"{host.url}/api/ps", None, timeout) + except (urllib.error.URLError, socket.timeout, TimeoutError, OSError, ValueError): + return {} + wanted = host.model if ":" in host.model else f"{host.model}:latest" + for m in ps.get("models", []): + if m.get("name") == wanted or m.get("model") == wanted: + size, vram = int(m.get("size") or 0), int(m.get("size_vram") or 0) + return { + "loaded_bytes": size, + "vram_bytes": vram, + "gpu_fraction": round(vram / size, 3) if size else None, + "loaded_num_ctx": m.get("context_length"), + } + return {} + + +def _chat(url: str, payload: dict, timeout: float) -> dict: + try: + return _http_json("POST", url, payload, timeout) + except urllib.error.HTTPError as e: + body = e.read().decode("utf-8", "replace") + if e.code == 400 and "think" in body.lower() and "think" in payload: + # Some models reject the think field outright; retry without it. + payload.pop("think") + return _chat(url, payload, timeout) + if "repeat limit" in body.lower(): + raise RepetitionError(f"{url}: {body[:200]}") from None + raise OllamaError(f"{url} returned HTTP {e.code}: {body[:200]}") from None + except (socket.timeout, TimeoutError): + raise OllamaError(f"no response from {url} within {timeout:.0f} s") from None + except (urllib.error.URLError, OSError) as e: + raise OllamaError(f"cannot reach {url}: {e}") from None + + +def _page_request(png_bytes: bytes, host: OllamaHost, prompt: str, + max_output: int | None) -> tuple[dict, dict]: + """First-attempt options and the /api/chat payload for one page image.""" + options: dict = {"temperature": 0} + if host.num_ctx: + options["num_ctx"] = host.num_ctx + if max_output: + options["num_predict"] = max_output + payload = { + "model": host.model, + "messages": [{ + "role": "user", + "content": prompt, + "images": [base64.b64encode(png_bytes).decode("ascii")], + }], + "stream": False, + "think": False, + "options": options, + } + return options, payload + + +def transcribe_png(png_bytes: bytes, host: OllamaHost, prompt: str, + timeout: float, max_output: int | None = None) -> PageOutput: + """One page, one request. Returns the transcript text and its stats. + + A model that loops either trips Ollama's repeat check (RepetitionError) + or runs on until max_output tokens (done_reason "length"). Either way the + page is retried with the REPEAT_RETRIES options; stats["retries"] records + how many were needed. If every retry loops, RepetitionError is raised + again, or the last output is returned with CUT_OFF_MARKER appended. + """ + options, payload = _page_request(png_bytes, host, prompt, max_output) + url = f"{host.url}/api/chat" + last = len(REPEAT_RETRIES) + reasons: list[str] = [] # why each earlier attempt was retried + for attempt, extra in enumerate(((), *REPEAT_RETRIES)): + payload["options"] = {**options, **dict(extra)} + try: + resp = _chat(url, payload, timeout) + except RepetitionError: + if attempt == last: + raise + reasons.append("repeat_limit") + continue + if resp.get("done_reason") == "length" and attempt < last: + reasons.append("output_cap") + continue + stats = page_stats(resp) + stats["retries"] = attempt + if attempt: + stats["retry_options"] = dict(extra) + stats["retry_reasons"] = reasons + text = strip_thinking((resp.get("message") or {}).get("content", "")) + if stats["done_reason"] == "length": + text = f"{text}\n{CUT_OFF_MARKER}" + return PageOutput(text, stats) + raise AssertionError("unreachable") + + +def chat_json(png_bytes: bytes, host: OllamaHost, prompt: str, schema: dict, + timeout: float, max_output: int | None = None) -> tuple[dict, dict]: + """One page, one request, with the answer constrained to a JSON schema. + + Returns (answer, stats). Retried with REPEAT_RETRIES when the model loops, + stops at max_output (the JSON would be incomplete), or returns something + that is not a JSON object with the schema's required keys. Raises + OllamaError if no attempt gives a usable answer. + """ + options, payload = _page_request(png_bytes, host, prompt, max_output) + payload["format"] = schema + url = f"{host.url}/api/chat" + required = schema.get("required", []) + reasons: list[str] = [] + for attempt, extra in enumerate(((), *REPEAT_RETRIES)): + payload["options"] = {**options, **dict(extra)} + try: + resp = _chat(url, payload, timeout) + except RepetitionError: + reasons.append("repeat_limit") + continue + if resp.get("done_reason") == "length": + reasons.append("output_cap") + continue + try: + answer = json.loads(strip_thinking((resp.get("message") or {}).get("content", ""))) + except ValueError: + answer = None + if not isinstance(answer, dict) or any(k not in answer for k in required): + reasons.append("bad_json") + continue + stats = page_stats(resp) + stats["retries"] = attempt + if attempt: + stats["retry_options"] = dict(extra) + stats["retry_reasons"] = reasons + return answer, stats + raise OllamaError(f"no usable answer after {len(REPEAT_RETRIES)} retries " + f"({', '.join(reasons)})") diff --git a/src/pdf_tools/scan_config.py b/src/pdf_tools/scan_config.py new file mode 100644 index 0000000..b1fc220 --- /dev/null +++ b/src/pdf_tools/scan_config.py @@ -0,0 +1,254 @@ +"""Configuration for scan-notes-md. + +Settings come from three layers, later ones winning: + 1. DEFAULTS below + 2. ~/.config/pdf-tools/scan-notes.toml (or $PDF_TOOLS_SCAN_CONFIG, or --config) + 3. command-line flags (applied in extract_scan.main) + +The file is optional. Only the keys you set are overridden; a [[ollama.hosts]] +list in the file replaces the default host list as a whole. + +Confidential folders exist only in the config file; none are built in. Scans +under any listed root stay on Ollama hosts (Claude is refused without +--allow-cloud) and go to a companion .md shaped by the folder's +[confidential.companion] table (see companion.CompanionSpec). Each folder can +also carry its own `names` list and `prompt_extra` text for the Ollama +prompt, added to the top-level ones. The [index] table holds the settings +for scan-notes-index (see scan_index.py). See +scan-notes.example.toml for a worked example. +""" +from __future__ import annotations + +import copy +import os +import sys +import tomllib +from dataclasses import dataclass, field, fields +from pathlib import Path + +from .companion import BASIC, CompanionSpec, PathRule +from .scan_stats import DEFAULT_STATS_LOG + +CONFIG_ENV = "PDF_TOOLS_SCAN_CONFIG" +DEFAULT_CONFIG_PATH = Path.home() / ".config" / "pdf-tools" / "scan-notes.toml" + +DEFAULTS: dict = { + "backend": "ollama", + "dpi": 200, + "names": [], + "prompt_extra": "", + # Per-page context and GPU statistics (no transcript text); "" disables. + "stats_log": DEFAULT_STATS_LOG, + "ollama": { + "timeout_s": 300, + "probe_timeout_s": 2.5, + # Output cap per page; a model that loops stops here instead of + # running until the timeout. 0 means no cap. + "max_output_tokens": 2048, + "hosts": [ + {"name": "local", "url": "http://localhost:11434", "model": "gemma4:e4b"}, + ], + }, + "confidential": [], + # scan-notes-index: per-page search metadata from transcripts. + "index": { + # Added to the index prompt, on top of the transcription names. + "names": [], + "prompt_extra": "", + "kinds": ["calculation", "idea", "sketch", "talk notes", "meeting notes", + "reading notes", "to-do", "other", "blank"], + "max_output_tokens": 1536, + # Characters of the previous and next page transcripts sent as context. + "context_chars": 2000, + }, +} +_FOLDER_KEYS = {"root", "names", "prompt_extra", "titles", "companion"} +_SPEC_KEYS = {f.name for f in fields(CompanionSpec)} +_RULE_KEYS = {"match", "set", "title"} +_HOST_KEYS = {"name", "url", "model", "num_ctx"} + + +@dataclass +class OllamaHost: + name: str + url: str + model: str + num_ctx: int | None = None + + +@dataclass +class ConfidentialFolder: + root: Path + companion: CompanionSpec = field(default_factory=lambda: BASIC) + # Display names for the "# Title" line of a new companion, keyed by + # folder name (or ".short"). Others are turned into words. + titles: dict[str, str] = field(default_factory=dict) + # Added to the Ollama prompt only for scans in this folder. + names: list[str] = field(default_factory=list) + prompt_extra: str = "" + + +@dataclass +class IndexSettings: + names: list[str] = field(default_factory=list) + prompt_extra: str = "" + kinds: list[str] = field(default_factory=list) + max_output_tokens: int = 1536 + context_chars: int = 2000 + + +@dataclass +class ScanConfig: + backend: str + dpi: int + names: list[str] + prompt_extra: str + timeout_s: float + probe_timeout_s: float + max_output_tokens: int + hosts: list[OllamaHost] + confidential: list[ConfidentialFolder] + stats_log: Path | None = None + index: IndexSettings = field(default_factory=IndexSettings) + source: Path | None = None # file the settings were read from, if any + + def confidential_folder(self, path: Path) -> ConfidentialFolder | None: + """The deepest confidential folder containing path, if any.""" + p = path.expanduser().resolve() + best = None + for c in self.confidential: + root = c.root.resolve() + if p == root or root in p.parents: + if best is None or len(root.parts) > len(best.root.resolve().parts): + best = c + return best + + def names_for(self, folder: ConfidentialFolder | None) -> list[str]: + """Global names plus the folder's own, without duplicates.""" + extra = folder.names if folder else [] + return list(dict.fromkeys([*self.names, *extra])) + + def extras_for(self, folder: ConfidentialFolder | None) -> list[str]: + """Top-level prompt_extra plus the folder's own, skipping empty ones.""" + texts = [self.prompt_extra, folder.prompt_extra if folder else ""] + return [t for t in dict.fromkeys(texts) if t.strip()] + + +def _merge(base: dict, over: dict) -> dict: + out = copy.deepcopy(base) + for k, v in over.items(): + if isinstance(v, dict) and isinstance(out.get(k), dict): + out[k] = _merge(out[k], v) + else: + out[k] = v + return out + + +def _die(path: Path, msg: str) -> None: + print(f"error: {path}: {msg}", file=sys.stderr) + sys.exit(2) + + +def _unknown(path: Path, where: str, keys, allowed: set[str]) -> None: + extra = sorted(set(keys) - allowed) + if extra: + _die(path, f"unknown key(s) in {where}: {', '.join(extra)}") + + +def _spec(path: Path, raw) -> CompanionSpec: + if raw is None: + return BASIC + if not isinstance(raw, dict): + _die(path, "companion must be a table ([confidential.companion]); " + "leave it out for the basic layout") + _unknown(path, "[confidential.companion]", raw, _SPEC_KEYS) + rules = [] + for r in raw.get("paths", []): + _unknown(path, "[[confidential.companion.paths]]", r, _RULE_KEYS) + if "match" not in r: + _die(path, "each [[confidential.companion.paths]] entry needs match") + rules.append(PathRule(match=str(r["match"]), + set={k: str(v) for k, v in r.get("set", {}).items()}, + title=r.get("title"))) + kw = {k: v for k, v in raw.items() if k != "paths"} + if "acronyms" in kw: + kw["acronyms"] = set(kw["acronyms"]) + spec = CompanionSpec(**{**BASIC.__dict__, **kw, "paths": rules}) + if "transcript_section" not in raw and spec.transcript_section not in spec.sections: + spec.transcript_section = spec.sections[0] if spec.sections else "Notes" + return spec + + +def load_config(path: Path | None = None) -> ScanConfig: + """Read the config file (if present) on top of DEFAULTS.""" + explicit = path is not None or bool(os.environ.get(CONFIG_ENV)) + path = path or Path(os.environ.get(CONFIG_ENV) or DEFAULT_CONFIG_PATH) + raw = DEFAULTS + source = None + if path.exists(): + try: + with path.open("rb") as f: + raw = _merge(DEFAULTS, tomllib.load(f)) + except tomllib.TOMLDecodeError as e: + _die(path, f"cannot parse: {e}") + source = path + elif explicit: + print(f"error: config file not found: {path}", file=sys.stderr) + sys.exit(2) + + _unknown(path, "the top level", raw, set(DEFAULTS)) + o = raw["ollama"] + _unknown(path, "[ollama] (top-level keys must come before the first " + "[table])", o, set(DEFAULTS["ollama"])) + hosts = [] + for h in o["hosts"]: + _unknown(path, "[[ollama.hosts]] (top-level keys must come before " + "the first [table])", h, _HOST_KEYS) + try: + hosts.append(OllamaHost( + name=str(h["name"]), url=str(h["url"]).rstrip("/"), + model=str(h["model"]), num_ctx=h.get("num_ctx"), + )) + except KeyError as e: + _die(path, f"each [[ollama.hosts]] entry needs {e}") + + confidential = [] + for c in raw["confidential"]: + _unknown(path, "[[confidential]]", c, _FOLDER_KEYS) + if "root" not in c: + _die(path, "each [[confidential]] entry needs a root") + confidential.append(ConfidentialFolder( + root=Path(c["root"]).expanduser(), + companion=_spec(path, c.get("companion")), + titles={str(k): str(v) for k, v in c.get("titles", {}).items()}, + names=[str(n) for n in c.get("names", [])], + prompt_extra=str(c.get("prompt_extra", "")), + )) + + ix = raw["index"] + _unknown(path, "[index]", ix, set(DEFAULTS["index"])) + kinds = [str(k) for k in ix["kinds"]] + if not kinds: + _die(path, "[index] kinds must not be empty") + index = IndexSettings( + names=[str(n) for n in ix["names"]], + prompt_extra=str(ix["prompt_extra"]), + kinds=kinds, + max_output_tokens=int(ix["max_output_tokens"]), + context_chars=int(ix["context_chars"]), + ) + + return ScanConfig( + backend=raw["backend"], + dpi=int(raw["dpi"]), + names=[str(n) for n in raw.get("names", [])], + prompt_extra=str(raw.get("prompt_extra", "")), + timeout_s=float(o["timeout_s"]), + probe_timeout_s=float(o["probe_timeout_s"]), + max_output_tokens=int(o["max_output_tokens"]), + hosts=hosts, + confidential=confidential, + stats_log=Path(raw["stats_log"]).expanduser() if raw.get("stats_log") else None, + index=index, + source=source, + ) diff --git a/src/pdf_tools/scan_index.py b/src/pdf_tools/scan_index.py new file mode 100644 index 0000000..4c71f5e --- /dev/null +++ b/src/pdf_tools/scan_index.py @@ -0,0 +1,316 @@ +"""scan-notes-index: per-page search metadata for a transcribed scan. + +Reads a scan (PDF) and its transcript (the .md written by +scan-notes-md, plain or companion; any file with markers and +fenced page text). For each page it sends the page image, the page's +transcript, and the neighboring pages' transcripts to an Ollama host and asks +for a summary, key points, a kind of page, topics, references, the event the +page records, and the people named. Each page becomes one Markdown file, +" pNNN.md", in " pages/" next to the transcript, so Spotlight, +DEVONthink, or a later vector index finds the page itself rather than the +whole notebook. + +Like the Ollama backend of scan-notes-md, this never calls a cloud service. +Existing page files are kept, so an interrupted run resumes where it stopped; +--force rewrites them. Per-page stats go to the stats log with task "index". +""" +from __future__ import annotations + +import dataclasses +import datetime as dt +import json +import os +import re +import sys +import time +from pathlib import Path +from urllib.parse import urlparse + +import click + +from .companion import write_atomic +from .extract_scan import EXIT_NO_HOST, EXIT_TRANSCRIBE_FAILED, _image_to_png_bytes, _iter_pages +from .ollama import (NAMES_PROMPT, NoHostAvailable, OllamaError, chat_json, + loaded_model, provenance, select_host) +from .scan_config import load_config +from .scan_stats import StatsLog + +INDEX_PROMPT = """\ +You are indexing one page of a handwritten notebook so that it can be found +later by text search. A notebook may mix calculations, research ideas, notes +taken during talks and seminars, reading notes, to-do lists, and notes from +meetings. + +You are given the page image and a draft transcript of it. The transcripts of +the previous and next pages are included only as context: describe THIS page +only. + +Fill in the fields as follows. +- summary: a short paragraph (three to six sentences) on what this page is + about, in plain words the writer would use when searching. Say what the + page is (a calculation, notes from a meeting or talk, an idea), what it + covers, and what it concludes, decides, or leaves open. For meeting notes, + name the discussion items; for a talk, the speaker's main points; for a + calculation, what is computed, from what, and the result if written. If + the page names a law, model, method, or quantity, use that name. If an + equation is unmistakably a standard one, you may name it; otherwise + describe what it relates. Do not guess at a purpose that is not on the + page. +- key_points: up to eight short items, each one specific thing on the page: + a discussion item, decision, action, result, number with units, idea, or + question. Use the page's own terms. Empty for a blank page. +- kind: the one word or phrase from the list that fits best.{kind_note} +- topics: three to eight short search phrases (subjects, methods, + materials, projects, organizations). Empty for a blank page. +- references: every citation, paper, book, DOI, arXiv number, or URL written + on the page, copied as written and tidied into one line (authors, journal or + book, volume, pages, year, as far as written). Never add a title, year, or + author that is not on the page. Empty if there are none. +- event: the talk, seminar, meeting, or call the page records, with speaker, + organization, board, or committee if written or shown in a page heading. + Empty if the page does not record an event. +- event_date: a date written on the page, as YYYY-MM-DD if complete, + otherwise as written. Empty if none. +- people: names of people written on the page, spelled as written. +- continues_from_previous / continues_to_next: true if this page plainly + continues a calculation, list, or set of notes from the previous page, or + onto the next. +""" + +SUMMARY_HEADING = "## Summary (machine-generated, unverified)" +_PAGE = re.compile(r"^\s*\n\s*(`{3,})text\n(.*?)\n?\2[ \t]*$", + re.MULTILINE | re.DOTALL) +_STR_FIELDS = ("summary", "event", "event_date") +_LIST_FIELDS = ("key_points", "topics", "references", "people") + + +def schema(kinds: list[str]) -> dict: + """JSON schema the model's answer must follow.""" + strings = {"type": "array", "items": {"type": "string"}} + props = { + "summary": {"type": "string"}, + "key_points": strings, + "kind": {"type": "string", "enum": kinds}, + "topics": strings, + "references": strings, + "event": {"type": "string"}, + "event_date": {"type": "string"}, + "people": strings, + "continues_from_previous": {"type": "boolean"}, + "continues_to_next": {"type": "boolean"}, + } + return {"type": "object", "properties": props, "required": list(props)} + + +def build_index_prompt(kinds: list[str], names: list[str], extras: list[str]) -> str: + """INDEX_PROMPT, then any [index] prompt_extra text, then names.""" + note = ('\n Use "calculation" for derivations and estimates as well.' + if "calculation" in kinds else "") + parts = [INDEX_PROMPT.format(kind_note=note)] + parts += [e.strip("\n") + "\n" for e in extras if e.strip()] + if names: + parts.append(NAMES_PROMPT + "\n".join(f"- {n}" for n in names) + "\n") + return "\n".join(parts) + + +def read_transcript(path: Path) -> tuple[dict[int, str], str | None]: + """Page texts by page number, and the file's transcribed_by value.""" + text = path.read_text(encoding="utf-8") + pages = {int(m.group(1)): m.group(3).strip("\n") for m in _PAGE.finditer(text)} + by = re.search(r"^transcribed_by:\s*(.+?)\s*$", text, re.MULTILINE) + return pages, by.group(1) if by else None + + +def page_prompt(base: str, pages: dict[int, str], n: int, chars: int) -> str: + def block(label: str, text: str | None, limit: int) -> str: + if text is None: + return f"{label}: (none)\n" + return f"{label}:\n<<<\n{text[:limit]}\n>>>\n" + return "\n".join([base, + block("Previous page transcript", pages.get(n - 1), chars), + block("THIS page's draft transcript", pages.get(n, ""), 4 * chars), + block("Next page transcript", pages.get(n + 1), chars)]) + + +def clean(answer: dict, kinds: list[str]) -> dict: + """Coerce the model's answer to the expected types.""" + out = {k: str(answer.get(k) or "").strip() for k in _STR_FIELDS} + for k in _LIST_FIELDS: + v = answer.get(k) or [] + out[k] = [str(x).strip() for x in (v if isinstance(v, list) else [v]) if str(x).strip()] + kind = str(answer.get("kind") or "") + out["kind"] = kind if kind in kinds else ("other" if "other" in kinds else kinds[-1]) + for k in ("continues_from_previous", "continues_to_next"): + out[k] = answer.get(k) is True + return out + + +def _q(s: str) -> str: + return json.dumps(s, ensure_ascii=False) + + +def _qlist(items: list[str]) -> str: + return "[" + ", ".join(_q(x) for x in items) + "]" + + +def render_page(stem: str, scan: str, n: int, total: int, meta: dict, transcript: str, + indexed_by: str, transcribed_by: str | None, today: str) -> str: + fence = "```" + while fence in transcript: + fence += "`" + prev = n - 1 if meta["continues_from_previous"] and n > 1 else None + nxt = n + 1 if meta["continues_to_next"] and n < total else None + lines = [ + "---", + f"notebook: {_q(stem)}", + f"scan: {_q(scan)}", + f"page: {n}", + f"kind: {_q(meta['kind'])}", + f"topics: {_qlist(meta['topics'])}", + f"references: {_qlist(meta['references'])}", + f"event: {_q(meta['event'])}", + f"event_date: {_q(meta['event_date'])}", + f"people: {_qlist(meta['people'])}", + f"continues_from: {prev if prev else 'null'}", + f"continues_to: {nxt if nxt else 'null'}", + f"indexed_by: {indexed_by}", + f"indexed: {today}", + ] + if transcribed_by: + lines.append(f"transcribed_by: {transcribed_by}") + lines += ["---", "", f"# {stem}, page {n}", "", SUMMARY_HEADING, "", + meta["summary"] or "(no summary)", ""] + if meta["key_points"]: + lines += ["## Key points", "", *[f"- {k}" for k in meta["key_points"]], ""] + if meta["references"]: + lines += ["## References", "", *[f"- {r}" for r in meta["references"]], ""] + lines += ["## Transcript (unverified)", "", f"{fence}text", transcript, fence, ""] + return "\n".join(lines) + + +def page_path(out_dir: Path, stem: str, n: int) -> Path: + return out_dir / f"{stem} p{n:03d}.md" + + +def _fail(msg: str, code: int = 2) -> None: + print(f"error: {msg}", file=sys.stderr) + sys.exit(code) + + +@click.command() +@click.argument("pdf", type=click.Path(exists=True, dir_okay=False, path_type=Path)) +@click.option("--transcript", "transcript_path", + type=click.Path(exists=True, dir_okay=False, path_type=Path), + help="Transcript with markers. Default: .md next to the scan.") +@click.option("-o", "--output-dir", type=click.Path(file_okay=False, path_type=Path), + help='Folder for the page files. Default: " pages" next to the transcript.') +@click.option("--host", default=None, + help="Use just this host from the config and fail if it is unavailable.") +@click.option("--model", default=None, help="Model name. Default: the config's per-host model.") +@click.option("--config", "config_path", type=click.Path(dir_okay=False, path_type=Path), + default=None, help="Config file. Default: ~/.config/pdf-tools/scan-notes.toml") +@click.option("--dpi", type=int, default=None, help="PDF render resolution (config default 200).") +@click.option("--timeout", type=float, default=None, + help="Per-page timeout in seconds (config default 300).") +@click.option("--force", is_flag=True, help="Rewrite page files that already exist.") +def main(pdf: Path, transcript_path: Path | None, output_dir: Path | None, + host: str | None, model: str | None, config_path: Path | None, + dpi: int | None, timeout: float | None, force: bool) -> None: + """Write one searchable Markdown file of metadata per page of a transcribed scan.""" + cfg = load_config(config_path) + ix = cfg.index + transcript_path = transcript_path or pdf.with_suffix(".md") + if not transcript_path.exists(): + _fail(f"no transcript at {transcript_path}; run scan-notes-md first") + texts, transcribed_by = read_transcript(transcript_path) + if not texts: + _fail(f"{transcript_path} has no transcript blocks") + + pages = _iter_pages([pdf], dpi=dpi or cfg.dpi) + total = len(pages) + if set(texts) != set(range(1, total + 1)): + _fail(f"{transcript_path} has {len(texts)} transcribed pages; {pdf.name} has {total}") + + out_dir = output_dir or transcript_path.parent / f"{pdf.stem} pages" + todo = [n for n in range(1, total + 1) + if force or not page_path(out_dir, pdf.stem, n).exists()] + if not todo: + print(f"all {total} pages already indexed in {out_dir}", file=sys.stderr) + return + + hosts = cfg.hosts + if model: + hosts = [dataclasses.replace(h, model=model) for h in hosts] + try: + chosen = select_host(hosts, cfg.probe_timeout_s, forced=host) + except NoHostAvailable as e: + _fail(f"{e}. Not falling back to a cloud service.", EXIT_NO_HOST) + print(f"using Ollama host {chosen.name} ({chosen.url}, {chosen.model})", file=sys.stderr) + if len(todo) < total: + print(f"{total - len(todo)} of {total} pages already indexed; skipping them", + file=sys.stderr) + + folder = cfg.confidential_folder(pdf) + names = list(dict.fromkeys([*cfg.names_for(folder), *ix.names])) + base = build_index_prompt(ix.kinds, names, [ix.prompt_extra]) + fmt = schema(ix.kinds) + indexed_by = provenance(chosen) + today = dt.date.today().isoformat() + page_timeout = timeout or cfg.timeout_s + out_dir.mkdir(parents=True, exist_ok=True) + + stats_log = StatsLog(cfg.stats_log) + run_id = f"{time.strftime('%Y%m%dT%H%M%S')}-{os.getpid()}" + loaded: dict | None = None + failed: list[int] = [] + t_start = time.monotonic() + for n in todo: + label, load = pages[n - 1] + print(f"[{n}/{total}] {label} on {chosen.name} ...", end="", file=sys.stderr, flush=True) + t0 = time.monotonic() + try: + answer, st = chat_json(_image_to_png_bytes(load()), chosen, + page_prompt(base, texts, n, ix.context_chars), + fmt, page_timeout, ix.max_output_tokens) + except OllamaError as e: + print(f" failed: {e}", file=sys.stderr) + failed.append(n) + continue + meta = clean(answer, ix.kinds) + write_atomic(page_path(out_dir, pdf.stem, n), + render_page(pdf.stem, pdf.name, n, total, meta, texts[n], + indexed_by, transcribed_by, today)) + if loaded is None: + loaded = loaded_model(chosen, cfg.probe_timeout_s) + retried = f", {st['retries']} retries" if st.get("retries") else "" + print(f" {time.monotonic() - t0:.0f} s, {st['context_tokens']} tokens, " + f"{meta['kind']}{retried}", file=sys.stderr) + nctx = loaded.get("loaded_num_ctx") or chosen.num_ctx + if nctx and st["context_tokens"] >= 0.9 * nctx: + print(f"warning: page {n} used {st['context_tokens']} of {nctx} context tokens", + file=sys.stderr) + stats_log.write({ + "time": time.strftime("%Y-%m-%dT%H:%M:%S"), + "task": "index", + "run": run_id, + "host": urlparse(chosen.url).hostname, + "model": chosen.model, + "num_ctx_setting": chosen.num_ctx, + "label": label, + "page": n, + "kind": meta["kind"], + "n_references": len(meta["references"]), + **st, + **loaded, + }) + + mins = (time.monotonic() - t_start) / 60 + done = len(todo) - len(failed) + print(f"indexed {done} page(s) in {mins:.1f} min -> {out_dir}", file=sys.stderr) + if failed: + _fail(f"{len(failed)} page(s) failed ({', '.join(map(str, failed))}); " + "rerun to retry them", EXIT_TRANSCRIBE_FAILED) + + +if __name__ == "__main__": + main() diff --git a/src/pdf_tools/scan_stats.py b/src/pdf_tools/scan_stats.py new file mode 100644 index 0000000..a171c01 --- /dev/null +++ b/src/pdf_tools/scan_stats.py @@ -0,0 +1,146 @@ +"""Per-page context and GPU statistics for scan-notes-md Ollama runs. + +Each transcribed page appends one JSON line to the stats log (config key +`stats_log`; default ~/.local/state/pdf-tools/scan-stats.jsonl). A line +holds the page label, image size, token counts, stop reason, timings, and +how the model was loaded (total size, share in GPU memory, context length). +It never holds transcript text or images. + +scan-notes-index writes the same kind of line with "task": "index". +`scan-notes-stats` summarizes the log, one block per task: token percentiles, how many pages +would exceed a given context size, truncated pages, GPU fit, and speed. +""" +from __future__ import annotations + +import json +import math +import sys +from collections import defaultdict +from pathlib import Path + +import click + +DEFAULT_STATS_LOG = "~/.local/state/pdf-tools/scan-stats.jsonl" +THRESHOLDS = (4096, 8192, 16384, 32768) + + +class StatsLog: + """Append-only JSON-lines log; a no-op when path is None.""" + + def __init__(self, path: Path | None): + self.path = path + if path is not None: + path.parent.mkdir(parents=True, exist_ok=True) + + def write(self, record: dict) -> None: + if self.path is None: + return + with self.path.open("a", encoding="utf-8") as f: + f.write(json.dumps(record, ensure_ascii=False) + "\n") + + +def read_log(path: Path) -> list[dict]: + out = [] + for line in path.read_text(encoding="utf-8").splitlines(): + line = line.strip() + if line: + try: + out.append(json.loads(line)) + except ValueError: + pass + return out + + +def _pct(values: list[float], q: float) -> float: + s = sorted(values) + if not s: + return 0 + k = max(0, min(len(s) - 1, math.ceil(q * len(s)) - 1)) + return s[k] + + +def summarize(records: list[dict], thresholds=THRESHOLDS, top: int = 5) -> str: + """Plain-text report, one block per (task, host, model, loaded context). + + The task is "transcribe" (scan-notes-md) or "index" (scan-notes-index); + records written before the field existed are transcriptions. + """ + groups: dict[tuple, list[dict]] = defaultdict(list) + for r in records: + groups[(r.get("task", "transcribe"), r.get("host"), r.get("model"), + r.get("loaded_num_ctx"))].append(r) + if not groups: + return "no pages logged yet" + + out = [] + for (task, host, model, nctx), rs in sorted(groups.items(), key=lambda kv: str(kv[0])): + n = len(rs) + out.append(f"{task}: {model} on {host}, loaded context {nctx or 'unknown'}: {n} pages, " + f"{len({r.get('run') for r in rs})} run(s)") + for key, name in [("prompt_tokens", "prompt (incl. image)"), + ("output_tokens", "output"), + ("context_tokens", "context used")]: + v = [r.get(key, 0) for r in rs] + out.append(f" {name:21s} mean {sum(v) / n:7.0f} p50 {_pct(v, .5):6.0f}" + f" p90 {_pct(v, .9):6.0f} p99 {_pct(v, .99):6.0f} max {max(v):6.0f}") + ctx = [r.get("context_tokens", 0) for r in rs] + over = ", ".join(f"> {t}: {sum(c > t for c in ctx)} ({100 * sum(c > t for c in ctx) / n:.1f}%)" + for t in thresholds) + out.append(f" pages needing more context than {over}") + cut = [r for r in rs if r.get("done_reason") == "length"] + out.append(f" output stopped at a length limit: {len(cut)} page(s)") + retried = [r for r in rs if r.get("retries")] + aborted = [r for r in rs if r.get("done_reason") == "repeat_abort"] + why = defaultdict(int) + for r in retried: + for reason in r.get("retry_reasons", ["unrecorded"]): + why[reason] += 1 + detail = ", ".join(f"{k} {v}" for k, v in sorted(why.items())) + out.append(f" model looped: {len(retried)} page(s) retried" + f"{f' ({detail})' if detail else ''}, " + f"{len(aborted)} left as placeholders") + gpu = [r["gpu_fraction"] for r in rs if r.get("gpu_fraction") is not None] + vram = [r["vram_bytes"] for r in rs if r.get("vram_bytes")] + size = [r["loaded_bytes"] for r in rs if r.get("loaded_bytes")] + if gpu: + out.append(f" model in GPU memory: {100 * min(gpu):.0f}-{100 * max(gpu):.0f}% " + f"(loaded {max(size) / 1e9:.1f} GB, in VRAM {max(vram) / 1e9:.1f} GB)") + secs = [r.get("total_s", 0) for r in rs] + out.append(f" seconds per page: mean {sum(secs) / n:.1f}, p90 {_pct(secs, .9):.1f}, " + f"max {max(secs):.1f}; total {sum(secs) / 3600:.1f} h") + out.append(f" largest pages by context used:") + for r in sorted(rs, key=lambda r: -r.get("context_tokens", 0))[:top]: + px = "x".join(str(x) for x in r.get("image_px", [])) or "?" + out.append(f" {r.get('context_tokens', 0):6d} ({r.get('prompt_tokens', 0)} in, " + f"{r.get('output_tokens', 0)} out, {px} px) {r.get('label')}") + out.append("") + return "\n".join(out).rstrip() + "\n" + + +@click.command() +@click.argument("log", required=False, type=click.Path(dir_okay=False, path_type=Path)) +@click.option("--run", "run_id", default=None, + help="Only this run id; 'last' for the most recent run.") +@click.option("--threshold", "thresholds", type=int, multiple=True, + help="Context sizes to test against (repeatable). " + f"Default: {', '.join(map(str, THRESHOLDS))}.") +@click.option("--top", default=5, show_default=True, help="Largest pages to list.") +def main(log: Path | None, run_id: str | None, thresholds: tuple[int, ...], + top: int) -> None: + """Summarize context use and GPU fit from the scan-notes-md stats log.""" + if log is None: + from .scan_config import load_config + log = load_config().stats_log + if log is None or not log.exists(): + print(f"error: no stats log at {log}", file=sys.stderr) + sys.exit(1) + records = read_log(log) + if run_id == "last" and records: + run_id = records[-1].get("run") + if run_id: + records = [r for r in records if r.get("run") == run_id] + sys.stdout.write(summarize(records, thresholds or THRESHOLDS, top)) + + +if __name__ == "__main__": + main() diff --git a/src/pdf_tools/scrub.py b/src/pdf_tools/scrub.py new file mode 100644 index 0000000..db75663 --- /dev/null +++ b/src/pdf_tools/scrub.py @@ -0,0 +1,120 @@ +"""Tool 1: strip annotations from a PDF. + +Removes the /Annots array from every page. This catches Preview/Skim/ +PDF Expert highlights, sticky notes, freehand drawings, text boxes, +strikethroughs, underlines — anything stored in the annotation layer. + +What it does NOT remove: + - Markings that were "flattened" into the page content stream + (some apps offer this as an export option). Those become part of + the page itself and can only be removed by going back to an + unmarked source. + - Form field values. We deliberately leave AcroForm /Widget annots + alone unless --include-forms is given. + - Embedded files / attachments. Use a dedicated tool if you need + those gone too. +""" +from __future__ import annotations + +import sys +from pathlib import Path + +import click +import pikepdf + +from .common import err, must_exist, with_suffix_before_ext + +# Subtypes that represent user markup. Widget = form field, which we +# usually want to KEEP. +MARKUP_SUBTYPES = { + "/Text", "/FreeText", "/Line", "/Square", "/Circle", "/Polygon", + "/PolyLine", "/Highlight", "/Underline", "/Squiggly", "/StrikeOut", + "/Stamp", "/Caret", "/Ink", "/Popup", "/FileAttachment", "/Sound", + "/Movie", "/Redact", "/Watermark", +} + + +def scrub(in_path: Path, out_path: Path, include_forms: bool = False) -> dict: + """Scrub annotations. Returns a count dict for reporting.""" + counts = {"pages": 0, "removed": 0, "kept": 0} + + with pikepdf.open(in_path) as pdf: + for page in pdf.pages: + counts["pages"] += 1 + if "/Annots" not in page: + continue + + annots = page["/Annots"] + kept = [] + for a in annots: + try: + subtype = str(a.get("/Subtype", "")) + except Exception: + subtype = "" + is_widget = subtype == "/Widget" + is_markup = subtype in MARKUP_SUBTYPES + + if is_widget and not include_forms: + kept.append(a) + counts["kept"] += 1 + elif is_markup or (include_forms and is_widget): + counts["removed"] += 1 + else: + # Unknown subtype — keep it to be safe. + kept.append(a) + counts["kept"] += 1 + + if kept: + page["/Annots"] = pikepdf.Array(kept) + else: + del page["/Annots"] + + # Linearize + strip metadata that often leaks reviewer identity. + # We keep /Title and /Subject; drop /Author and /Producer hints + # from the editing app. + try: + with pdf.open_metadata() as meta: + for k in ("dc:creator", "xmp:CreatorTool", "pdf:Producer"): + if k in meta: + del meta[k] + except Exception: + pass + + pdf.save(out_path, linearize=True) + + return counts + + +@click.command() +@click.argument("pdf", type=click.Path(exists=True, dir_okay=False, path_type=Path)) +@click.option( + "-o", "--output", + type=click.Path(dir_okay=False, path_type=Path), + help="Output path. Default: _clean.pdf", +) +@click.option( + "--include-forms", is_flag=True, + help="Also strip form field widgets (default: keep them).", +) +@click.option( + "--print-path", is_flag=True, + help="Print only the output path on stdout (for shell pipelines).", +) +def main(pdf: Path, output: Path | None, include_forms: bool, print_path: bool) -> None: + """Strip annotations from a PDF for sending.""" + in_path = must_exist(pdf) + out_path = output or with_suffix_before_ext(in_path, "_clean") + + counts = scrub(in_path, out_path, include_forms=include_forms) + + if print_path: + print(str(out_path)) + else: + err( + f"scrubbed {counts['removed']} annotations across " + f"{counts['pages']} pages (kept {counts['kept']}) -> {out_path}" + ) + + +if __name__ == "__main__": + main() diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 0000000..ec52df7 --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,308 @@ +"""End-to-end CLI behavior with Ollama faked and Claude forbidden.""" +from __future__ import annotations + +import io +import json +import urllib.error +from pathlib import Path + +import pypdfium2 as pdfium +import pytest +from click.testing import CliRunner +from PIL import Image + +from pdf_tools import extract_scan, ollama + + +@pytest.fixture +def env(tmp_path, monkeypatch): + root = tmp_path / "ACME" + cfg = tmp_path / "scan-notes.toml" + cfg.write_text(f""" +prompt_extra = "Mark drawings." +stats_log = "{tmp_path / "stats.jsonl"}" + +[[ollama.hosts]] +name = "remote" +url = "http://gpu-box:11434" +model = "gemma4:31b" + +[[ollama.hosts]] +name = "local" +url = "http://localhost:11434" +model = "gemma4:e4b" + +[[confidential]] +root = "{root}" +names = ["Board Person"] +prompt_extra = "Board-only instruction." + +[confidential.companion] +type = "meeting-notes" +fields = ["body", "committee"] +sections = ["Attendees", "Discussion", "Decisions", "Action items"] +transcript_section = "Discussion" + +[[confidential.companion.paths]] +match = "{{body}}/committees/{{committee}}/**" + +[[confidential]] +root = "{tmp_path / "lab"}" +names = ["Lab Person"] +""") + monkeypatch.setenv("PDF_TOOLS_SCAN_CONFIG", str(cfg)) + monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False) + + def no_claude(*a, **k): + raise AssertionError("Claude must not be called") + monkeypatch.setattr(extract_scan, "_transcribe_image", no_claude) + + folder = root / "ACMEP-BOM" / "committees" / "finance-audit" / "2026-10-29-fa" + folder.mkdir(parents=True) + pdf = folder / "2026-10-29-acmep-fa-notes.pdf" + doc = pdfium.PdfDocument.new() + doc.new_page(200, 260) + doc.save(pdf) + return {"root": root, "pdf": pdf, "tmp": tmp_path} + + +def fake_ollama(monkeypatch, up: dict[str, list[str]]): + def _fake(method, url, payload, timeout): + base, _, path = url.partition("/api/") + if path == "tags": + if base not in up: + raise OSError("unreachable") + return {"models": [{"name": m} for m in up[base]]} + if path == "ps": + return {"models": [{"name": m, "size": 100, "size_vram": 100, + "context_length": 4096} for m in up.get(base, [])]} + _fake.prompts.append(payload["messages"][0]["content"]) + return {"message": {"content": f"transcript via {payload['model']}"}, + "prompt_eval_count": 1000, "eval_count": 200, "done_reason": "stop", + "total_duration": 2_000_000_000} + _fake.prompts = [] + monkeypatch.setattr(ollama, "_http_json", _fake) + return _fake + + +def run(*args): + return CliRunner().invoke(extract_scan.main, [str(a) for a in args]) + + +def test_confidential_scan_defaults_to_ollama_and_writes_companion(env, monkeypatch): + fake_ollama(monkeypatch, {"http://localhost:11434": ["gemma4:e4b"]}) + r = run(env["pdf"]) + assert r.exit_code == 0, r.output + md = env["pdf"].with_suffix(".md").read_text() + assert "body: ACMEP-BOM\ncommittee: finance-audit\ntype: meeting-notes" in md + assert "## Discussion\n\n### Draft transcript (unverified)" in md + assert "transcribed_by: ollama/localhost/gemma4:e4b" in md + assert "transcript via gemma4:e4b" in md + assert "falling back to local" in r.stderr + + +def test_no_host_exits_without_cloud(env, monkeypatch): + fake_ollama(monkeypatch, {}) + monkeypatch.setenv("ANTHROPIC_API_KEY", "set-but-must-not-be-used") + r = run(env["pdf"]) + assert r.exit_code == extract_scan.EXIT_NO_HOST + assert "Not falling back to a cloud service" in r.stderr + assert not env["pdf"].with_suffix(".md").exists() + + +def test_claude_refused_for_confidential_scan(env, monkeypatch): + monkeypatch.setenv("ANTHROPIC_API_KEY", "x") + r = run("--backend", "claude", env["pdf"]) + assert r.exit_code == 2 and "--allow-cloud" in r.stderr + + +def test_claude_refused_even_with_no_companion(env, monkeypatch): + monkeypatch.setenv("ANTHROPIC_API_KEY", "x") + r = run("--backend", "claude", "--no-companion", "--stdout", env["pdf"]) + assert r.exit_code == 2 and "--allow-cloud" in r.stderr + + +def test_forced_remote_fails_clearly(env, monkeypatch): + fake_ollama(monkeypatch, {"http://localhost:11434": ["gemma4:e4b"]}) + r = run("--host", "remote", env["pdf"]) + assert r.exit_code == extract_scan.EXIT_NO_HOST + assert "remote" in r.stderr and "falling back to local" not in r.stderr + + +def test_model_flag_overrides_config(env, monkeypatch): + fake_ollama(monkeypatch, {"http://gpu-box:11434": ["qwen3-vl:8b"]}) + r = run("--model", "qwen3-vl:8b", "--host", "remote", env["pdf"]) + assert r.exit_code == 0, r.output + assert "ollama/gpu-box/qwen3-vl:8b" in env["pdf"].with_suffix(".md").read_text() + + +def test_non_companion_ollama_output_uses_page_markers(env, monkeypatch): + fake_ollama(monkeypatch, {"http://gpu-box:11434": ["gemma4:31b"]}) + img = env["tmp"] / "page.png" + Image.new("RGB", (50, 50), "white").save(img) + r = run("--backend", "ollama", "--stdout", img) + assert r.exit_code == 0, r.output + assert "" in r.stdout + assert "transcribed_by: ollama/gpu-box/gemma4:31b" in r.stdout + + +def test_companion_mode_rejects_stdout(env): + r = run("--stdout", env["pdf"]) + assert r.exit_code == 2 and "--no-companion" in r.stderr + + +def test_second_confidential_folder_uses_its_layout(env, monkeypatch): + fake_ollama(monkeypatch, {"http://gpu-box:11434": ["gemma4:31b"]}) + lab = env["tmp"] / "lab" / "reviews" + lab.mkdir(parents=True) + pdf = lab / "2026-11-02-review-notes.pdf" + doc = pdfium.PdfDocument.new() + doc.new_page(200, 260) + doc.save(pdf) + monkeypatch.setenv("ANTHROPIC_API_KEY", "x") + assert run("--backend", "claude", pdf).exit_code == 2 + r = run(pdf) + assert r.exit_code == 0, r.output + md = pdf.with_suffix(".md").read_text() + assert "type: notes" in md and "## Notes" in md and "body:" not in md + + +def test_mixing_confidential_and_other_files_refused(env, monkeypatch): + img = env["tmp"] / "page.png" + Image.new("RGB", (50, 50), "white").save(img) + r = run("--backend", "ollama", "--no-companion", "--stdout", env["pdf"], img) + assert r.exit_code == 2 and "do not mix" in r.stderr + + +def test_names_come_only_from_the_scans_folder(env, monkeypatch): + fake = fake_ollama(monkeypatch, {"http://localhost:11434": ["gemma4:e4b"]}) + assert run(env["pdf"]).exit_code == 0 + assert "- Board Person" in fake.prompts[0] + assert "Lab Person" not in fake.prompts[0] + assert "Mark drawings." in fake.prompts[0] + assert "Board-only instruction." in fake.prompts[0] + + +def test_only_top_level_settings_outside_confidential_folders(env, monkeypatch): + fake = fake_ollama(monkeypatch, {"http://localhost:11434": ["gemma4:e4b"]}) + img = env["tmp"] / "page.png" + Image.new("RGB", (50, 50), "white").save(img) + assert run("--backend", "ollama", "--stdout", img).exit_code == 0 + assert fake.prompts[0] == ollama.build_prompt([], ["Mark drawings."]) + assert "Board" not in fake.prompts[0] + + +def test_no_confidential_folders_without_config(tmp_path, monkeypatch): + monkeypatch.setenv("PDF_TOOLS_SCAN_CONFIG", str(tmp_path / "empty.toml")) + (tmp_path / "empty.toml").write_text("") + from pdf_tools.scan_config import load_config + assert load_config().confidential == [] + + +def test_interrupted_run_resumes_and_cleans_up(env, monkeypatch): + nb = env["tmp"] / "notebooks" + nb.mkdir() + pdf = nb / "2024-04 notebook.pdf" + doc = pdfium.PdfDocument.new() + for _ in range(3): + doc.new_page(200, 260) + doc.save(pdf) + + calls = [] + + def _fake(method, url, payload, timeout): + if url.endswith("/api/tags"): + return {"models": [{"name": "gemma4:e4b"}]} + if url.endswith("/api/ps"): + return {"models": []} + calls.append(1) + if len(calls) == 2 and not getattr(_fake, "healthy", False): + raise OSError("connection reset") + return {"message": {"content": f"page text {len(calls)}"}} + monkeypatch.setattr(ollama, "_http_json", _fake) + + r = run("--backend", "ollama", "--host", "local", pdf) + assert r.exit_code == extract_scan.EXIT_TRANSCRIBE_FAILED + assert "pages 1-1 are saved; rerun to resume" in r.stderr + ckpt = nb / ".2024-04 notebook.scan-partial.json" + assert ckpt.exists() and not pdf.with_suffix(".md").exists() + + _fake.healthy = True + r = run("--backend", "ollama", "--host", "local", pdf) + assert r.exit_code == 0, r.output + assert "resuming after page 1 of 3" in r.stderr + md = pdf.with_suffix(".md").read_text() + assert "page text 1" in md and "" in md + assert len(calls) == 4 # page 1 was not sent again + assert not ckpt.exists() + assert {p.name for p in nb.iterdir()} == {pdf.name, pdf.with_suffix(".md").name} + + +def test_checkpoint_from_other_model_is_ignored(env, monkeypatch): + fake_ollama(monkeypatch, {"http://localhost:11434": ["gemma4:e4b"]}) + img = env["tmp"] / "page.png" + Image.new("RGB", (50, 50), "white").save(img) + ckpt = env["tmp"] / ".page.scan-partial.json" + ckpt.write_text('{"key": {"transcribed_by": "other"}, "pages": [{"label": "x", "text": "stale"}]}') + r = run("--backend", "ollama", "--stdout", img) + assert r.exit_code == 0 and "stale" not in r.stdout + assert "ignoring saved progress" in r.stderr and not ckpt.exists() + + +def test_stats_logged_per_page_without_text(env, monkeypatch): + fake_ollama(monkeypatch, {"http://localhost:11434": ["gemma4:e4b"]}) + r = run(env["pdf"]) + assert r.exit_code == 0, r.output + assert "1200 tokens" in r.stderr + lines = (env["tmp"] / "stats.jsonl").read_text().splitlines() + assert len(lines) == 1 + rec = json.loads(lines[0]) + assert rec["model"] == "gemma4:e4b" and rec["host"] == "localhost" + assert (rec["prompt_tokens"], rec["output_tokens"], rec["context_tokens"]) == (1000, 200, 1200) + assert rec["gpu_fraction"] == 1.0 and rec["loaded_num_ctx"] == 4096 + assert rec["image_px"][0] > 0 and rec["page"] == 1 + assert "transcript via" not in lines[0] + + +def test_warns_when_output_hits_length_limit(env, monkeypatch): + def _fake(method, url, payload, timeout): + if url.endswith("/api/tags"): + return {"models": [{"name": "gemma4:e4b"}]} + if url.endswith("/api/ps"): + return {"models": [{"name": "gemma4:e4b", "size": 1, "size_vram": 1, + "context_length": 4096}]} + return {"message": {"content": "partial"}, "prompt_eval_count": 3900, + "eval_count": 196, "done_reason": "length"} + monkeypatch.setattr(ollama, "_http_json", _fake) + r = run(env["pdf"]) + assert r.exit_code == 0 + assert "marked as cut off" in r.stderr + assert "cut off at the output limit" in env["pdf"].with_suffix(".md").read_text() + + +def test_looping_page_becomes_placeholder_and_run_finishes(env, monkeypatch): + def _fake(method, url, payload, timeout): + if url.endswith("/api/tags"): + return {"models": [{"name": "gemma4:e4b"}]} + if url.endswith("/api/ps"): + return {"models": []} + raise urllib.error.HTTPError( + url, 500, "err", {}, + io.BytesIO(b'{"error":"prediction aborted, token repeat limit reached"}')) + monkeypatch.setattr(ollama, "_http_json", _fake) + r = run(env["pdf"]) + assert r.exit_code == 0, r.output + assert "writing a placeholder" in r.stderr + assert ollama.REPEAT_PLACEHOLDER in env["pdf"].with_suffix(".md").read_text() + rec = json.loads((env["tmp"] / "stats.jsonl").read_text().splitlines()[0]) + assert rec["done_reason"] == "repeat_abort" and rec["retries"] == 2 + + +def test_ollama_is_the_default_backend_outside_confidential_folders(env, monkeypatch): + fake_ollama(monkeypatch, {"http://gpu-box:11434": ["gemma4:31b"]}) + monkeypatch.setenv("ANTHROPIC_API_KEY", "set-but-must-not-be-used") + img = env["tmp"] / "page.png" + Image.new("RGB", (50, 50), "white").save(img) + r = run("--stdout", img) + assert r.exit_code == 0, r.output + assert "transcribed_by: ollama/gpu-box/gemma4:31b" in r.stdout diff --git a/tests/test_companion.py b/tests/test_companion.py new file mode 100644 index 0000000..a30c3fb --- /dev/null +++ b/tests/test_companion.py @@ -0,0 +1,291 @@ +"""Companion files: front matter from paths, and preserving existing text.""" +from __future__ import annotations + +from pathlib import Path + +import pytest + +from pdf_tools import companion as comp +from pdf_tools.companion import CompanionSpec, PathRule + +ROOT = Path("/tmp/acme-test-root") + +# A meetings layout like the one in the user's config (test data only; the +# code knows nothing about any organization). +SPEC = CompanionSpec( + type="meeting-notes", + fields=["body", "committee"], + sections=["Attendees", "Discussion", "Decisions", "Action items"], + transcript_section="Discussion", + section_text={"Action items": "- [ ] Owner: task (due date)"}, + title="{body}, {date}", + allowed={"body": ["ACME-BOD", "ACMEP-BOM", "ACMEF-BOT"]}, + acronyms={"acmep", "ceo"}, + paths=[ + PathRule("{body}/committees/{committee}/**", title="{body.short} {committee}, {date}"), + PathRule("{body}/meetings/**", set={"committee": "board"}), + PathRule("chair/{committee}/**", set={"body": "chair"}, title="{committee}, {date}"), + PathRule("{body}/{committee}/**", title="{body.short} {committee}, {date}"), + PathRule("{body}/**"), + ], +) +TITLES = { + "ACME-BOD": "ACME Board of Directors", "ACME-BOD.short": "ACME", + "ACMEP-BOM": "ACMEP Board of Managers", "ACMEP-BOM.short": "ACMEP", + "finance-audit": "Finance and Audit Committee", +} + + +def meta(rel: str) -> comp.NoteMeta: + return comp.meta_from_path(ROOT / rel, ROOT, SPEC) + + +@pytest.mark.parametrize("rel, date, body, committee", [ + ("ACMEP-BOM/committees/finance-audit/2026-10-29-fa/2026-10-29-acmep-fa-notes.pdf", + "2026-10-29", "ACMEP-BOM", "finance-audit"), + ("ACME-BOD/meetings/2026-11-12/2026-11-12-acme-bod-notes.pdf", + "2026-11-12", "ACME-BOD", "board"), + ("chair/acmep-ceo-search/2026-10-30-acmep-ceo-search-notes.pdf", + "2026-10-30", "chair", "acmep-ceo-search"), + ("ACME-BOD/committees/iac/2026-06-xx/notes.pdf", + "2026-06-xx", "ACME-BOD", "iac"), + ("ACMEP-BOM/meetings/2026-06-08/scan.pdf", + "2026-06-08", "ACMEP-BOM", "board"), +]) +def test_meta_from_path(rel, date, body, committee): + m = meta(rel) + assert (m.date, m.fields["body"], m.fields["committee"]) == (date, body, committee) + assert m.scan == Path(rel).name + + +def test_filename_date_wins_over_folder(): + m = meta("ACMEP-BOM/meetings/2026-06-08/2026-06-09-acmep-notes.pdf") + assert m.date == "2026-06-09" + + +def test_unknown_location_warns(): + m = meta("inbox/scan.pdf") + assert m.fields["body"] == "" and m.date == "" + assert any("body" in w for w in m.warnings) + assert any("date" in w for w in m.warnings) + + +def test_partial_date_warns(): + assert any("no day" in w for w in meta("ACME-BOD/meetings/2026-06-xx/n.pdf").warnings) + + +def test_titles(): + def t(rel, titles=TITLES): + return comp.title_for(meta(rel), SPEC, titles) + assert t("ACMEP-BOM/committees/finance-audit/x/2026-10-29-n.pdf") == \ + "ACMEP Finance and Audit Committee, October 29, 2026" + assert t("ACME-BOD/meetings/2026-11-12/n.pdf") == \ + "ACME Board of Directors, November 12, 2026" + assert t("chair/acmep-ceo-search/2026-10-30-n.pdf") == \ + "ACMEP CEO Search, October 30, 2026" + assert t("chair/acmep-ceo-search/2026-10-30-n.pdf", + {"acmep-ceo-search": "ACMEP CEO search"}).startswith("ACMEP CEO search,") + assert t("ACME-BOD/meetings/x/n.pdf") == "ACME Board of Directors" + + +def test_allowed_values_and_rule_order(): + m = meta("inbox/2026-01-02-n.pdf") # "inbox" is not an allowed body + assert m.fields == {"body": "", "committee": ""} + m = meta("ACME-BOD/2026-01-02-n.pdf") # matched by the last rule + assert m.fields == {"body": "ACME-BOD", "committee": ""} + assert any("committee" in w for w in m.warnings) + + +@pytest.mark.parametrize("pattern, folders, expected", [ + ("a/{x}", ("a", "b"), {"x": "b"}), + ("a/{x}", ("a", "b", "c"), None), + ("a/{x}/**", ("a", "b", "c"), {"x": "b"}), + ("a/**", ("a",), {}), + ("{x}/b", ("a", "c"), None), +]) +def test_match(pattern, folders, expected): + assert comp._match(pattern, folders, {}) == expected + + +def test_new_companion_matches_template(): + m = meta("ACMEP-BOM/committees/finance-audit/2026-10-29-fa/2026-10-29-acmep-fa-notes.pdf") + text = comp.new_companion(m, ["page one", "page two"], "ollama/gpu-box/gemma4:31b", + SPEC, TITLES) + assert text.startswith( + "---\ndate: 2026-10-29\nbody: ACMEP-BOM\ncommittee: finance-audit\n" + "type: meeting-notes\nscan: 2026-10-29-acmep-fa-notes.pdf\nsubjects: []\n" + "transcribed_by: ollama/gpu-box/gemma4:31b\n---\n") + for h in ("## Attendees", "## Discussion", comp.DRAFT_HEADING, + "## Decisions", "## Action items"): + assert h in text + assert text.index("## Discussion") < text.index(comp.DRAFT_HEADING) < text.index("## Decisions") + assert "" in text and "" in text + assert comp.PENDING_LINE not in text + + +def test_transcript_keeps_layout_and_fences_headings(): + page = "# 3 items\n - indented\n\nafter blank" + r = comp.render_transcript([page]) + assert "```text\n# 3 items\n - indented\n\nafter blank\n```" in r + r2 = comp.render_transcript(["has ``` inside"]) + assert "````text\nhas ``` inside\n````" in r2 + + +# ---- preserving existing companion text ----------------------------------- + +EXISTING = """\ +--- +date: 2026-10-29 +body: ACMEP-BOM +committee: finance-audit +type: meeting-notes +scan: 2026-10-29-acmep-fa-notes.pdf +subjects: [ACMEP performance, audit timeline] +--- + +# ACMEP Finance and Audit Committee, October 29, 2026 + +## Attendees + +Pat, the committee, staff. + +## Discussion + +My own summary paragraph. + With an indented line. + +{middle} +## Decisions + +- Decision I wrote. + +## Action items + +- [ ] Owner: task (due date) +""" + + +def _mine(text: str) -> list[str]: + """Every line Pat wrote, which must survive any merge.""" + return [l for l in EXISTING.format(middle="").splitlines() if l.strip()] + + +def assert_preserved(before: str, after: str): + after_lines = after.splitlines() + pos = 0 + for line in _mine(before): + assert line in after_lines[pos:], f"lost or reordered: {line!r}" + pos = after_lines.index(line, pos) + 1 + + +def test_pending_line_replaced(): + before = EXISTING.format(middle=comp.PENDING_LINE + "\n") + after = comp.merge_companion(before, ["draft"], "ollama/localhost/gemma4:e4b", "Discussion") + assert comp.PENDING_LINE not in after + assert after.count(comp.DRAFT_HEADING) == 1 + assert_preserved(before, after) + assert after.index("My own summary") < after.index(comp.DRAFT_HEADING) \ + < after.index("## Decisions") + + +def test_block_added_when_missing(): + before = EXISTING.format(middle="") + after = comp.merge_companion(before, ["draft"], "ollama/localhost/gemma4:e4b", "Discussion") + assert after.count(comp.DRAFT_HEADING) == 1 + assert_preserved(before, after) + assert after.index("With an indented line.") < after.index(comp.DRAFT_HEADING) \ + < after.index("## Decisions") + assert "\n\n## Decisions" in after + + +def test_existing_block_replaced_not_duplicated(): + before = EXISTING.format(middle="") + once = comp.merge_companion(before, ["first draft"], "ollama/localhost/gemma4:e4b", "Discussion") + twice = comp.merge_companion(once, ["second draft"], "ollama/gpu-box/gemma4:31b", "Discussion") + assert twice.count(comp.DRAFT_HEADING) == 1 + assert "second draft" in twice and "first draft" not in twice + assert_preserved(before, twice) + assert "transcribed_by: ollama/gpu-box/gemma4:31b" in twice + assert twice.count("transcribed_by:") == 1 + + +def test_rerun_is_stable(): + before = EXISTING.format(middle="") + once = comp.merge_companion(before, ["same"], "x", "Discussion") + assert comp.merge_companion(once, ["same"], "x", "Discussion") == once + + +def test_old_block_without_end_marker_stops_at_next_heading(): + before = EXISTING.format(middle=( + f"{comp.DRAFT_HEADING}\n\nold draft text\n\n" + "### My corrections\n\nKeep this.\n")) + after = comp.merge_companion(before, ["new"], "x", "Discussion") + assert "old draft text" not in after + assert "### My corrections\n\nKeep this." in after + assert_preserved(before, after) + + +def test_hash_line_inside_transcript_does_not_end_block(): + before = EXISTING.format(middle="") + once = comp.merge_companion(before, ["# not a heading\nmore"], "x", "Discussion") + twice = comp.merge_companion(once, ["replacement"], "x", "Discussion") + assert "not a heading" not in twice and "more\n" not in twice.split("## Decisions")[0] + + +def test_front_matter_only_gains_transcribed_by(): + before = EXISTING.format(middle="") + after = comp.merge_companion(before, ["d"], "ollama/localhost/gemma4:e4b", "Discussion") + fm_before = before.split("\n---\n", 1)[0] + fm_after = after.split("\n---\n", 1)[0] + assert fm_after == fm_before + "\ntranscribed_by: ollama/localhost/gemma4:e4b" + + +def test_no_discussion_section_appends_at_end(): + before = "---\ndate: 2026-10-29\n---\n\n# Notes\n\nFree text.\n" + after = comp.merge_companion(before, ["d"], "x") + assert after.startswith("---\ndate: 2026-10-29\ntranscribed_by: x\n---\n\n# Notes\n\nFree text.\n\n") + assert after.rstrip().endswith(comp.END_MARKER) + + +def test_write_companion_creates_then_preserves(tmp_path): + folder = tmp_path / "ACMEP-BOM" / "committees" / "finance-audit" / "2026-10-29-fa" + folder.mkdir(parents=True) + pdf = folder / "2026-10-29-acmep-fa-notes.pdf" + pdf.write_bytes(b"%PDF-1.4") + path, created, _ = comp.write_companion(pdf, tmp_path, ["one"], "x", SPEC) + assert created and path == pdf.with_suffix(".md") + + edited = path.read_text().replace("subjects: []", "subjects: [audit]") \ + .replace("## Attendees\n", "## Attendees\n\nSomeone.\n") + path.write_text(edited) + _, created, _ = comp.write_companion(pdf, tmp_path, ["two"], "y", SPEC) + final = path.read_text() + assert not created + assert "subjects: [audit]" in final and "Someone." in final + assert "two" in final and "\none\n" not in final + assert {p.name for p in folder.iterdir()} == {pdf.name, path.name} + + +# ---- basic layout (no companion table) ----------------------------------- + +def test_basic_layout_meta_has_no_body_or_warnings(): + m = comp.meta_from_path(ROOT / "projects" / "2026-11-02-lab-review-notes.pdf", ROOT) + assert (m.date, m.fields, m.warnings) == ("2026-11-02", {}, []) + + +def test_basic_layout_template(): + m = comp.meta_from_path(ROOT / "x" / "2026-11-02-lab-review-notes.pdf", ROOT) + text = comp.new_companion(m, ["p"], "ollama/localhost/gemma4:e4b") + assert text.startswith( + "---\ndate: 2026-11-02\ntype: notes\nscan: 2026-11-02-lab-review-notes.pdf\n" + "subjects: []\ntranscribed_by: ollama/localhost/gemma4:e4b\n---\n\n" + "# Lab Review Notes, November 2, 2026\n\n## Notes\n\n" + comp.DRAFT_HEADING) + assert "body:" not in text and "## Attendees" not in text + + +def test_basic_layout_merge_keeps_text(): + before = ("---\ndate: 2026-11-02\n---\n\n# Notes\n\n## Notes\n\nMine.\n\n" + "## Later\n\nAlso mine.\n") + after = comp.merge_companion(before, ["d"], "x") + assert after.index("Mine.") < after.index(comp.DRAFT_HEADING) < after.index("## Later") + assert "Also mine." in after diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 0000000..09d3906 --- /dev/null +++ b/tests/test_config.py @@ -0,0 +1,103 @@ +"""Confidential-folder declarations in the config file.""" +from __future__ import annotations + +from pathlib import Path + +import pytest + +from pdf_tools.companion import BASIC +from pdf_tools.scan_config import load_config + +EXAMPLE = Path(__file__).resolve().parent.parent / "scan-notes.example.toml" + + +def cfg_from(tmp_path, text: str): + p = tmp_path / "scan-notes.toml" + p.write_text(text) + return load_config(p) + + +def test_nothing_built_in(tmp_path, monkeypatch): + monkeypatch.delenv("PDF_TOOLS_SCAN_CONFIG", raising=False) + monkeypatch.setattr("pdf_tools.scan_config.DEFAULT_CONFIG_PATH", tmp_path / "none.toml") + cfg = load_config() + assert cfg.confidential == [] + assert [h.url for h in cfg.hosts] == ["http://localhost:11434"] + + +def test_example_file_loads(): + cfg = load_config(EXAMPLE) + assert len(cfg.confidential) == 2 + basic, meetings = cfg.confidential + assert basic.companion is BASIC + assert meetings.companion.transcript_section == "Discussion" + assert meetings.companion.fields == ["body", "committee"] + assert [r.match for r in meetings.companion.paths][0] == "{body}/committees/{committee}/**" + assert meetings.titles["BOD.short"] == "Board" + + +def test_folder_without_companion_is_basic(tmp_path): + cfg = cfg_from(tmp_path, f'[[confidential]]\nroot = "{tmp_path / "x"}"\n') + assert cfg.confidential[0].companion is BASIC + + +def test_transcript_section_defaults_to_first_section(tmp_path): + cfg = cfg_from(tmp_path, f'[[confidential]]\nroot = "{tmp_path}"\n' + '[confidential.companion]\nsections = ["Summary", "Log"]\n') + assert cfg.confidential[0].companion.transcript_section == "Summary" + + +def test_tilde_expanded_and_deepest_root_wins(tmp_path): + outer, inner = tmp_path / "a", tmp_path / "a" / "b" + cfg = cfg_from(tmp_path, + f'[[confidential]]\nroot = "{outer}"\n\n' + f'[[confidential]]\nroot = "{inner}"\n') + assert cfg.confidential_folder(inner / "c" / "s.pdf").root == inner + assert cfg.confidential_folder(outer / "s.pdf").root == outer + assert cfg.confidential_folder(tmp_path / "other.pdf") is None + # A sibling whose name merely starts with the root's name is not inside it. + assert cfg.confidential_folder(tmp_path / "ab" / "s.pdf") is None + cfg = cfg_from(tmp_path, '[[confidential]]\nroot = "~/somewhere"\n') + assert cfg.confidential[0].root == Path.home() / "somewhere" + + +def test_names_are_per_folder(tmp_path): + a, b = tmp_path / "a", tmp_path / "b" + cfg = cfg_from(tmp_path, f'names = ["Everyone"]\n' + f'[[confidential]]\nroot = "{a}"\nnames = ["Alpha", "Everyone"]\n' + f'[[confidential]]\nroot = "{b}"\nnames = ["Beta"]\n') + fa, fb = cfg.confidential + assert cfg.names_for(fa) == ["Everyone", "Alpha"] + assert cfg.names_for(fb) == ["Everyone", "Beta"] + assert cfg.names_for(None) == ["Everyone"] + + +@pytest.mark.parametrize("text", [ + '[[confidential]]\nnames = []\n', # no root + '[[confidential]]\nroot = "/x"\ncompanion = "acme"\n', # old string form + '[[confidential]]\nroot = "/x"\nnmaes = []\n', # typo + '[[confidential]]\nroot = "/x"\n[confidential.companion]\nsectoins = []\n', + '[[confidential]]\nroot = "/x"\n[[confidential.companion.paths]]\ntitle = "t"\n', + # A top-level key written after a host table lands inside that table. + '[[ollama.hosts]]\nname = "l"\nurl = "http://x"\nmodel = "m"\nprompt_extra = "x"\n', + '[ollama]\ntimeout_s = 5\nnames = []\n', + 'prompt_extar = "x"\n', +]) +def test_bad_entries_rejected(tmp_path, text): + with pytest.raises(SystemExit): + cfg_from(tmp_path, text) + + +def test_prompt_extra_top_level_and_per_folder(tmp_path): + a, b = tmp_path / "a", tmp_path / "b" + cfg = cfg_from(tmp_path, 'prompt_extra = "Figures."\n' + f'[[confidential]]\nroot = "{a}"\nprompt_extra = "Board terms."\n' + f'[[confidential]]\nroot = "{b}"\n') + fa, fb = cfg.confidential + assert cfg.extras_for(fa) == ["Figures.", "Board terms."] + assert cfg.extras_for(fb) == ["Figures."] + assert cfg.extras_for(None) == ["Figures."] + + +def test_example_prompt_extra_mentions_figures(): + assert "[FIGURE:" in load_config(EXAMPLE).prompt_extra diff --git a/tests/test_index.py b/tests/test_index.py new file mode 100644 index 0000000..d6afc4b --- /dev/null +++ b/tests/test_index.py @@ -0,0 +1,240 @@ +"""scan-notes-index: transcript parsing, page files, and the CLI with Ollama faked.""" +from __future__ import annotations + +import io +import json +import urllib.error + +import pypdfium2 as pdfium +import pytest +from click.testing import CliRunner + +from pdf_tools import companion, ollama, scan_index +from pdf_tools.extract_scan import to_plain_markdown +from pdf_tools.scan_config import OllamaHost, load_config +from pdf_tools.scan_stats import read_log, summarize + +HOST = OllamaHost("local", "http://localhost:11434", "gemma4:31b", num_ctx=8192) +KINDS = ["calculation", "idea", "meeting notes", "other", "blank"] + + +def answer(**over): + a = {"summary": "Estimate of a drag force.", "key_points": ["F = 6 pi eta a U"], + "kind": "calculation", "topics": ["Stokes drag"], "references": [], + "event": "", "event_date": "", "people": [], + "continues_from_previous": False, "continues_to_next": True} + return {**a, **over} + + +def make_scan(folder, pages=("first page", "second page", "third page")): + folder.mkdir(parents=True, exist_ok=True) + pdf = folder / "2009 notebook.pdf" + doc = pdfium.PdfDocument.new() + for _ in pages: + doc.new_page(200, 260) + doc.save(pdf) + md = pdf.with_suffix(".md") + md.write_text(to_plain_markdown(list(pages), pdf.stem, "ollama/localhost/gemma4:31b")) + return pdf + + +@pytest.fixture +def env(tmp_path, monkeypatch): + cfg = tmp_path / "scan-notes.toml" + cfg.write_text(f""" +names = ["Global Person"] +stats_log = "{tmp_path / "stats.jsonl"}" + +[ollama] +max_output_tokens = 2048 + +[[ollama.hosts]] +name = "local" +url = "http://localhost:11434" +model = "gemma4:31b" +num_ctx = 8192 + +[index] +names = ["Board Member"] +prompt_extra = "Index-only instruction." +""") + monkeypatch.setenv("PDF_TOOLS_SCAN_CONFIG", str(cfg)) + return tmp_path + + +def fake(monkeypatch, replies=None): + """Ollama with gemma4:31b; chat replies come from the list, then answer().""" + replies = list(replies or []) + + def _fake(method, url, payload, timeout): + base, _, path = url.partition("/api/") + if path == "tags": + return {"models": [{"name": "gemma4:31b"}]} + if path == "ps": + return {"models": [{"name": "gemma4:31b", "size": 20, "size_vram": 20, + "context_length": 8192}]} + _fake.payloads.append(payload) + r = replies.pop(0) if replies else answer() + if isinstance(r, Exception): + raise r + if isinstance(r, dict) and "message" in r: + return r + return {"message": {"content": r if isinstance(r, str) else json.dumps(r)}, + "prompt_eval_count": 2000, "eval_count": 300, "done_reason": "stop", + "total_duration": 9_000_000_000} + _fake.payloads = [] + monkeypatch.setattr(ollama, "_http_json", _fake) + return _fake + + +def run(*args): + return CliRunner().invoke(scan_index.main, [str(a) for a in args]) + + +def test_reads_plain_and_companion_transcripts(tmp_path): + plain = tmp_path / "a.md" + plain.write_text(to_plain_markdown(["one", "has ``` inside", ""], "a", "ollama/x/m")) + pages, by = scan_index.read_transcript(plain) + assert pages == {1: "one", 2: "has ``` inside", 3: ""} and by == "ollama/x/m" + + comp = tmp_path / "b.md" + comp.write_text("---\ntranscribed_by: ollama/y/m\n---\n\n## Notes\n\n" + + companion.draft_block(["alpha", "beta"]) + "\n") + pages, by = scan_index.read_transcript(comp) + assert pages == {1: "alpha", 2: "beta"} and by == "ollama/y/m" + + +def test_prompt_has_kinds_note_extras_and_names(): + p = scan_index.build_index_prompt(KINDS, ["Pat Doe"], ["Extra rule."]) + assert '"calculation" for derivations' in p + assert p.index("Extra rule.") < p.index(ollama.NAMES_PROMPT) < p.index("- Pat Doe") + assert '"calculation"' not in scan_index.build_index_prompt(["idea", "other"], [], []) + + +def test_page_prompt_marks_this_page_and_neighbors(): + pages = {1: "p1", 2: "p2" * 50, 3: "p3"} + p = scan_index.page_prompt("BASE", pages, 1, chars=10) + assert "Previous page transcript: (none)" in p + assert "THIS page's draft transcript:\n<<<\np1\n>>>" in p + p = scan_index.page_prompt("BASE", pages, 3, chars=10) + assert "<<<\n" + "p2" * 5 + "\n>>>" in p and "Next page transcript: (none)" in p + + +def test_clean_coerces_types_and_unknown_kind(): + m = scan_index.clean({"summary": None, "kind": "derivation", "topics": "one", + "people": ["", " A "], "continues_to_next": "yes"}, KINDS) + assert m["summary"] == "" and m["kind"] == "other" + assert m["topics"] == ["one"] and m["people"] == ["A"] + assert m["continues_to_next"] is False and m["references"] == [] + + +def test_render_page_front_matter_and_sections(): + meta = scan_index.clean(answer(references=['Smith, "x", J. Fluid Mech. 1 (2001)'], + continues_from_previous=True), KINDS) + text = scan_index.render_page("nb", "nb.pdf", 1, 3, meta, "a ``` b", "ollama/h/m", + "ollama/h/t", "2026-11-02") + assert text.startswith('---\nnotebook: "nb"\nscan: "nb.pdf"\npage: 1\nkind: "calculation"') + assert 'references: ["Smith, \\"x\\", J. Fluid Mech. 1 (2001)"]' in text + assert "continues_from: null\ncontinues_to: 2\n" in text # page 1 has no previous + assert "transcribed_by: ollama/h/t" in text + assert scan_index.SUMMARY_HEADING + "\n\nEstimate of a drag force." in text + assert "## Key points\n\n- F = 6 pi eta a U" in text + assert "````text\na ``` b\n````" in text + + +def test_cli_writes_one_file_per_page(env, monkeypatch): + f = fake(monkeypatch) + pdf = make_scan(env / "nb") + r = run(pdf) + assert r.exit_code == 0, r.output + out = env / "nb" / "2009 notebook pages" + files = sorted(p.name for p in out.iterdir()) + assert files == [f"2009 notebook p00{n}.md" for n in (1, 2, 3)] + p2 = (out / "2009 notebook p002.md").read_text() + assert "page: 2\n" in p2 and "continues_to: 3" in p2 and "second page" in p2 + assert "indexed_by: ollama/localhost/gemma4:31b" in p2 + assert "continues_to: null" in (out / "2009 notebook p003.md").read_text() + + req = f.payloads[1] + assert req["format"]["properties"]["kind"]["enum"][0] == "calculation" + assert req["options"] == {"temperature": 0, "num_ctx": 8192, "num_predict": 1536} + prompt = req["messages"][0]["content"] + assert "- Global Person" in prompt and "- Board Member" in prompt + assert "Index-only instruction." in prompt + assert "<<<\nsecond page\n>>>" in prompt and "<<<\nfirst page\n>>>" in prompt + + log = read_log(env / "stats.jsonl") + assert [x["task"] for x in log] == ["index"] * 3 and log[0]["kind"] == "calculation" + assert "summary" not in json.dumps(log) # no generated text in the log + assert "index: gemma4:31b on localhost" in summarize(log) + + +def test_existing_pages_are_skipped_unless_forced(env, monkeypatch): + f = fake(monkeypatch) + pdf = make_scan(env / "nb") + out = env / "nb" / "2009 notebook pages" + out.mkdir() + (out / "2009 notebook p001.md").write_text("kept") + assert run(pdf).exit_code == 0 + assert len(f.payloads) == 2 and (out / "2009 notebook p001.md").read_text() == "kept" + r = run(pdf) + assert r.exit_code == 0 and "already indexed" in r.stderr and len(f.payloads) == 2 + assert run("--force", pdf).exit_code == 0 and len(f.payloads) == 5 + + +def test_bad_json_is_retried(env, monkeypatch): + f = fake(monkeypatch, ["not json", {"summary": "missing the other keys"}]) + pdf = make_scan(env / "nb", pages=("only",)) + assert run(pdf).exit_code == 0 + assert len(f.payloads) == 3 + log = read_log(env / "stats.jsonl") + assert log[0]["retries"] == 2 and log[0]["retry_reasons"] == ["bad_json", "bad_json"] + + +def test_failed_page_reported_and_others_written(env, monkeypatch): + def err(): + return urllib.error.HTTPError("u", 500, "x", {}, io.BytesIO(b'{"error":"token repeat limit"}')) + fake(monkeypatch, [err(), err(), err()]) + pdf = make_scan(env / "nb", pages=("a", "b")) + r = run(pdf) + assert r.exit_code == scan_index.EXIT_TRANSCRIBE_FAILED + assert "1 page(s) failed (1)" in r.stderr + out = env / "nb" / "2009 notebook pages" + assert [p.name for p in out.iterdir()] == ["2009 notebook p002.md"] + + +def test_page_count_mismatch_refused(env, monkeypatch): + fake(monkeypatch) + pdf = make_scan(env / "nb") + pdf.with_suffix(".md").write_text(to_plain_markdown(["a"], "x", "y")) + r = run(pdf) + assert r.exit_code == 2 and "1 transcribed pages" in r.stderr + + +def test_missing_transcript_refused(env, monkeypatch): + fake(monkeypatch) + pdf = make_scan(env / "nb") + pdf.with_suffix(".md").unlink() + r = run(pdf) + assert r.exit_code == 2 and "run scan-notes-md first" in r.stderr + + +def test_no_host_exits_without_cloud(env, monkeypatch): + def down(*a): + raise urllib.error.URLError("refused") + monkeypatch.setattr(ollama, "_http_json", down) + pdf = make_scan(env / "nb") + r = run(pdf) + assert r.exit_code == scan_index.EXIT_NO_HOST + assert "Not falling back to a cloud service" in r.stderr + + +def test_index_config_rejects_unknown_keys(tmp_path, capsys): + cfg = tmp_path / "c.toml" + cfg.write_text("[index]\nkind = ['x']\n") + with pytest.raises(SystemExit): + load_config(cfg) + assert "unknown key(s) in [index]: kind" in capsys.readouterr().err + cfg.write_text("[index]\nkinds = []\n") + with pytest.raises(SystemExit): + load_config(cfg) diff --git a/tests/test_ollama_hosts.py b/tests/test_ollama_hosts.py new file mode 100644 index 0000000..6d97eed --- /dev/null +++ b/tests/test_ollama_hosts.py @@ -0,0 +1,247 @@ +"""Host selection, fallback, and response cleanup. All HTTP is faked.""" +from __future__ import annotations + +import io +import json +import urllib.error + +import pytest + +from pdf_tools import ollama +from pdf_tools.scan_config import OllamaHost + +REMOTE = OllamaHost("remote", "http://gpu-box:11434", "gemma4:31b") +LOCAL = OllamaHost("local", "http://localhost:11434", "gemma4:e4b") + + +def fake_http(tags: dict[str, list[str] | None], chat=None): + """tags maps base URL -> model names, or None for an unreachable host.""" + calls = [] + + def _fake(method, url, payload, timeout): + calls.append((method, url, payload, timeout)) + base, _, path = url.partition("/api/") + if path == "tags": + models = tags.get(base) + if models is None: + raise urllib.error.URLError("connection refused") + return {"models": [{"name": m} for m in models]} + if path == "chat": + return chat(payload) if chat else {"message": {"content": "ok"}} + raise AssertionError(url) + + _fake.calls = calls + return _fake + + +def test_remote_used_when_available(monkeypatch, capsys): + monkeypatch.setattr(ollama, "_http_json", fake_http({ + REMOTE.url: ["gemma4:31b"], LOCAL.url: ["gemma4:e4b"]})) + assert ollama.select_host([REMOTE, LOCAL], 2.5) is REMOTE + assert capsys.readouterr().err == "" + + +def test_falls_back_when_remote_unreachable(monkeypatch, capsys): + monkeypatch.setattr(ollama, "_http_json", fake_http({ + REMOTE.url: None, LOCAL.url: ["gemma4:e4b"]})) + assert ollama.select_host([REMOTE, LOCAL], 2.5) is LOCAL + err = capsys.readouterr().err.strip().splitlines() + assert len(err) == 1 + assert "unreachable" in err[0] and "falling back to local" in err[0] + + +def test_falls_back_when_remote_lacks_model(monkeypatch, capsys): + monkeypatch.setattr(ollama, "_http_json", fake_http({ + REMOTE.url: ["qwen3-vl:8b"], LOCAL.url: ["gemma4:e4b"]})) + assert ollama.select_host([REMOTE, LOCAL], 2.5) is LOCAL + assert "does not have gemma4:31b" in capsys.readouterr().err + + +def test_probe_uses_short_timeout(monkeypatch): + fake = fake_http({REMOTE.url: ["gemma4:31b"]}) + monkeypatch.setattr(ollama, "_http_json", fake) + ollama.select_host([REMOTE, LOCAL], 2.5) + assert fake.calls == [("GET", f"{REMOTE.url}/api/tags", None, 2.5)] + + +def test_no_host_raises(monkeypatch): + monkeypatch.setattr(ollama, "_http_json", fake_http({})) + with pytest.raises(ollama.NoHostAvailable): + ollama.select_host([REMOTE, LOCAL], 2.5) + + +def test_forced_host_skips_others(monkeypatch): + fake = fake_http({REMOTE.url: ["gemma4:31b"], LOCAL.url: ["gemma4:e4b"]}) + monkeypatch.setattr(ollama, "_http_json", fake) + assert ollama.select_host([REMOTE, LOCAL], 2.5, forced="local") is LOCAL + assert [c[1] for c in fake.calls] == [f"{LOCAL.url}/api/tags"] + + +def test_forced_host_unavailable_is_error_not_fallback(monkeypatch): + monkeypatch.setattr(ollama, "_http_json", fake_http({ + REMOTE.url: None, LOCAL.url: ["gemma4:e4b"]})) + with pytest.raises(ollama.NoHostAvailable, match="remote"): + ollama.select_host([REMOTE, LOCAL], 2.5, forced="remote") + + +def test_forced_host_unknown_name(monkeypatch): + monkeypatch.setattr(ollama, "_http_json", fake_http({})) + with pytest.raises(ollama.NoHostAvailable, match="no Ollama host named"): + ollama.select_host([REMOTE, LOCAL], 2.5, forced="laptop") + + +def test_untagged_model_matches_latest(monkeypatch): + host = OllamaHost("x", "http://x:11434", "llama3.2") + monkeypatch.setattr(ollama, "_http_json", fake_http({host.url: ["llama3.2:latest"]})) + assert ollama.select_host([host], 1) is host + + +def test_chat_request_shape(monkeypatch): + seen = {} + + def chat(payload): + seen.update(payload) + return {"message": {"content": "line one\n line two"}} + + monkeypatch.setattr(ollama, "_http_json", fake_http({}, chat)) + out = ollama.transcribe_png(b"\x89PNG", REMOTE, "PROMPT", 300) + assert out.text == "line one\n line two" + assert seen["stream"] is False and seen["think"] is False + assert seen["options"]["temperature"] == 0 + assert seen["model"] == "gemma4:31b" + assert len(seen["messages"]) == 1 and seen["messages"][0]["images"] + + +def test_retries_without_think_when_rejected(monkeypatch): + payloads = [] + + def _fake(method, url, payload, timeout): + payloads.append(dict(payload)) + if "think" in payload: + raise urllib.error.HTTPError( + url, 400, "Bad Request", {}, + io.BytesIO(json.dumps({"error": "model does not support thinking"}).encode())) + return {"message": {"content": "text"}} + + monkeypatch.setattr(ollama, "_http_json", _fake) + assert ollama.transcribe_png(b"x", LOCAL, "P", 10).text == "text" + assert "think" in payloads[0] and "think" not in payloads[1] + + +@pytest.mark.parametrize("raw, clean", [ + ("hmm, looks like a list\nA\nB", "A\nB"), + ("xA", "A"), + ("reasoning without an opening tag\nA", "A"), + ("A\n - indented\nB\n", "A\n - indented\nB"), +]) +def test_strip_thinking(raw, clean): + assert ollama.strip_thinking(raw) == clean + + +def test_names_added_only_when_configured(): + assert ollama.build_prompt([]) == ollama.HANDWRITING_PROMPT + p = ollama.build_prompt(["Pat Example", "ACME Foundation"]) + assert p.startswith(ollama.HANDWRITING_PROMPT) + assert "- Pat Example" in p and "otherwise write\n[illegible]" in p + + +def test_provenance(): + assert ollama.provenance(REMOTE) == "ollama/gpu-box/gemma4:31b" + assert ollama.provenance(LOCAL) == "ollama/localhost/gemma4:e4b" + + +def test_extras_go_between_base_prompt_and_names(): + p = ollama.build_prompt(["Pat"], ["Draw figures as [FIGURE: x].", " "]) + assert p.startswith(ollama.HANDWRITING_PROMPT + "\nDraw figures as [FIGURE: x].\n\n") + assert p.index("[FIGURE") < p.index(ollama.NAMES_PROMPT) < p.index("- Pat") + assert ollama.build_prompt([], ["", "\n"]) == ollama.HANDWRITING_PROMPT + + +def test_page_stats_from_response(): + st = ollama.page_stats({"prompt_eval_count": 1200, "eval_count": 300, + "done_reason": "stop", "total_duration": 9_500_000_000, + "load_duration": 0, "prompt_eval_duration": 1_000_000_000, + "eval_duration": 8_000_000_000}) + assert st["context_tokens"] == 1500 and st["done_reason"] == "stop" + assert (st["total_s"], st["prompt_s"], st["output_s"]) == (9.5, 1.0, 8.0) + assert ollama.page_stats({})["context_tokens"] == 0 + + +def test_loaded_model_reports_gpu_fit(monkeypatch): + def _fake(method, url, payload, timeout): + assert url.endswith("/api/ps") + return {"models": [{"name": "gemma4:31b", "size": 21_000_000_000, + "size_vram": 19_740_000_000, "context_length": 32768}]} + monkeypatch.setattr(ollama, "_http_json", _fake) + got = ollama.loaded_model(REMOTE, 2) + assert got == {"loaded_bytes": 21_000_000_000, "vram_bytes": 19_740_000_000, + "gpu_fraction": 0.94, "loaded_num_ctx": 32768} + + +def test_loaded_model_unreachable_is_empty(monkeypatch): + def _down(*a): + raise urllib.error.URLError("connection refused") + monkeypatch.setattr(ollama, "_http_json", _down) + assert ollama.loaded_model(REMOTE, 2) == {} + + +def _repeat_error(url): + return urllib.error.HTTPError( + url, 500, "Internal Server Error", {}, + io.BytesIO(b'{"error":"prediction aborted, token repeat limit reached"}')) + + +def test_looping_page_retried_with_sampling(monkeypatch): + seen = [] + + def _fake(method, url, payload, timeout): + seen.append(dict(payload["options"])) + if len(seen) == 1: + raise _repeat_error(url) + return {"message": {"content": "ok"}, "eval_count": 5} + monkeypatch.setattr(ollama, "_http_json", _fake) + out = ollama.transcribe_png(b"x", REMOTE, "P", 10) + assert out.text == "ok" and out.stats["retries"] == 1 + assert out.stats["retry_reasons"] == ["repeat_limit"] + assert seen[0] == {"temperature": 0} + assert seen[1] == {"temperature": 0.3, "repeat_penalty": 1.15} + assert out.stats["retry_options"] == ollama.REPEAT_RETRIES[0] + + +def test_first_try_keeps_temperature_zero(monkeypatch): + seen = [] + monkeypatch.setattr(ollama, "_http_json", lambda m, u, p, t: seen.append(p["options"]) + or {"message": {"content": "ok"}}) + out = ollama.transcribe_png(b"x", REMOTE, "P", 10) + assert seen == [{"temperature": 0}] and out.stats["retries"] == 0 + + +def test_repetition_error_after_all_retries(monkeypatch): + def _fake(method, url, payload, timeout): + raise _repeat_error(url) + monkeypatch.setattr(ollama, "_http_json", _fake) + with pytest.raises(ollama.RepetitionError): + ollama.transcribe_png(b"x", REMOTE, "P", 10) + + +def test_runaway_output_capped_and_retried(monkeypatch): + seen = [] + + def _fake(method, url, payload, timeout): + seen.append(dict(payload["options"])) + if len(seen) == 1: + return {"message": {"content": "x x x"}, "done_reason": "length", "eval_count": 2048} + return {"message": {"content": "fine"}, "done_reason": "stop", "eval_count": 300} + monkeypatch.setattr(ollama, "_http_json", _fake) + out = ollama.transcribe_png(b"x", REMOTE, "P", 10, max_output=2048) + assert seen[0] == {"temperature": 0, "num_predict": 2048} + assert out.text == "fine" and out.stats["retries"] == 1 + assert out.stats["retry_reasons"] == ["output_cap"] + + +def test_runaway_on_every_attempt_is_marked_cut_off(monkeypatch): + monkeypatch.setattr(ollama, "_http_json", lambda m, u, p, t: { + "message": {"content": "long"}, "done_reason": "length", "eval_count": 2048}) + out = ollama.transcribe_png(b"x", REMOTE, "P", 10, max_output=2048) + assert out.text == "long\n" + ollama.CUT_OFF_MARKER + assert out.stats["retries"] == 2 and out.stats["done_reason"] == "length" diff --git a/tests/test_stats.py b/tests/test_stats.py new file mode 100644 index 0000000..246abe0 --- /dev/null +++ b/tests/test_stats.py @@ -0,0 +1,36 @@ +"""The scan-notes-stats summary.""" +from __future__ import annotations + +from pdf_tools.scan_stats import StatsLog, read_log, summarize + + +def rec(ctx, run="r1", reason="stop", label="nb.pdf p.1"): + return {"run": run, "host": "gpu-box", "model": "gemma4:31b", + "loaded_num_ctx": 32768, "label": label, "image_px": [2000, 1500], + "prompt_tokens": ctx - 300, "output_tokens": 300, "context_tokens": ctx, + "done_reason": reason, "total_s": 10.0, "gpu_fraction": 0.94, + "vram_bytes": 19.7e9, "loaded_bytes": 21e9} + + +def test_threshold_counts_and_extremes(): + rs = [rec(1500), rec(3000), rec(5000), rec(9000, reason="length", label="big p.9")] + out = summarize(rs, thresholds=(4096, 8192)) + assert "4 pages, 1 run(s)" in out + assert "> 4096: 2 (50.0%)" in out and "> 8192: 1 (25.0%)" in out + assert "length limit: 1 page(s)" in out + assert "model looped: 0 page(s) retried, 0 left as placeholders" in out + assert "model in GPU memory: 94-94%" in out + assert out.index("big p.9") < out.index("nb.pdf p.1") + + +def test_log_roundtrip(tmp_path): + log = StatsLog(tmp_path / "sub" / "s.jsonl") + log.write(rec(100)) + log.write(rec(200)) + (tmp_path / "sub" / "s.jsonl").open("a").write("not json\n") + assert [r["context_tokens"] for r in read_log(tmp_path / "sub" / "s.jsonl")] == [100, 200] + StatsLog(None).write(rec(1)) # disabled log is a no-op + + +def test_empty(): + assert summarize([]) == "no pages logged yet" diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..fa1e8be --- /dev/null +++ b/uv.lock @@ -0,0 +1,1071 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "anthropic" +version = "0.102.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "docstring-parser" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/47/cb2a71f70431fb09af4db83e3ea89eb2dd8e0e348d27af53ed32e6c599dd/anthropic-0.102.0.tar.gz", hash = "sha256:96f747cad11886c4ae12d4080131b94eebd68b202bd2190fe27959031bb1fa9c", size = 763697, upload-time = "2026-05-13T18:12:41.624Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/75/0f6c603594876413bc858a00e7cc0d80a0cc14edf5c7b959a3ea6ec45e44/anthropic-0.102.0-py3-none-any.whl", hash = "sha256:ab96540bbd4b0f36564252d955a86f8abbe4f00944a24bc9931acc9b139bab6f", size = 763070, upload-time = "2026-05-13T18:12:43.474Z" }, +] + +[[package]] +name = "anyio" +version = "4.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, +] + +[[package]] +name = "certifi" +version = "2026.4.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" }, + { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" }, + { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" }, + { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" }, + { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" }, + { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" }, + { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" }, + { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" }, + { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" }, + { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" }, + { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" }, + { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" }, + { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" }, + { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" }, + { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" }, + { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" }, + { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" }, + { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" }, + { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" }, + { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" }, + { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, + { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" }, + { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" }, + { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" }, + { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, +] + +[[package]] +name = "click" +version = "8.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "cryptography" +version = "48.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/a9/db8f313fdcd85d767d4973515e1db101f9c71f95fced83233de224673757/cryptography-48.0.0.tar.gz", hash = "sha256:5c3932f4436d1cccb036cb0eaef46e6e2db91035166f1ad6505c3c9d5a635920", size = 832984, upload-time = "2026-05-04T22:59:38.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/3d/01f6dd9190170a5a241e0e98c2d04be3664a9e6f5b9b872cde63aff1c3dd/cryptography-48.0.0-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:0c558d2cdffd8f4bbb30fc7134c74d2ca9a476f830bb053074498fbc86f41ed6", size = 8001587, upload-time = "2026-05-04T22:57:36.803Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6e/e90527eef33f309beb811cf7c982c3aeffcce8e3edb178baa4ca3ae4a6fa/cryptography-48.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f5333311663ea94f75dd408665686aaf426563556bb5283554a3539177e03b8c", size = 4690433, upload-time = "2026-05-04T22:57:40.373Z" }, + { url = "https://files.pythonhosted.org/packages/90/04/673510ed51ddff56575f306cf1617d80411ee76831ccd3097599140efdfe/cryptography-48.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7995ef305d7165c3f11ae07f2517e5a4f1d5c18da1376a0a9ed496336b69e5f3", size = 4710620, upload-time = "2026-05-04T22:57:42.935Z" }, + { url = "https://files.pythonhosted.org/packages/14/d5/e9c4ef932c8d800490c34d8bd589d64a31d5890e27ec9e9ad532be893294/cryptography-48.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:40ba1f85eaa6959837b1d51c9767e230e14612eea4ef110ee8854ada22da1bf5", size = 4696283, upload-time = "2026-05-04T22:57:45.294Z" }, + { url = "https://files.pythonhosted.org/packages/0c/29/174b9dfb60b12d59ecfc6cfa04bc88c21b42a54f01b8aae09bb6e51e4c7f/cryptography-48.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:369a6348999f94bbd53435c894377b20ab95f25a9065c283570e70150d8abc3c", size = 5296573, upload-time = "2026-05-04T22:57:47.933Z" }, + { url = "https://files.pythonhosted.org/packages/95/38/0d29a6fd7d0d1373f0c0c88a04ba20e359b257753ac497564cd660fc1d55/cryptography-48.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a0e692c683f4df67815a2d258b324e66f4738bd7a96a218c826dce4f4bd05d8f", size = 4743677, upload-time = "2026-05-04T22:57:50.067Z" }, + { url = "https://files.pythonhosted.org/packages/30/be/eef653013d5c63b6a490529e0316f9ac14a37602965d4903efed1399f32b/cryptography-48.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:18349bbc56f4743c8b12dc32e2bccb2cf83ee8b69a3bba74ef8ae857e26b3d25", size = 4330808, upload-time = "2026-05-04T22:57:52.301Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/500463e87abb7a0a0f9f256ec21123ecde0a7b5541a15e840ea54551fd81/cryptography-48.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e8eac43dfca5c4cccc6dad9a80504436fca53bb9bc3100a2386d730fbe6b602", size = 4695941, upload-time = "2026-05-04T22:57:54.603Z" }, + { url = "https://files.pythonhosted.org/packages/e3/dc/7303087450c2ec9e7fbb750e17c2abfbc658f23cbd0e54009509b7cc4091/cryptography-48.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9ccdac7d40688ecb5a3b4a604b8a88c8002e3442d6c60aead1db2a89a041560c", size = 5252579, upload-time = "2026-05-04T22:57:57.207Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c0/7101d3b7215edcdc90c45da544961fd8ed2d6448f77577460fa75a8443f7/cryptography-48.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:bd72e68b06bb1e96913f97dd4901119bc17f39d4586a5adf2d3e47bc2b9d58b5", size = 4743326, upload-time = "2026-05-04T22:57:59.535Z" }, + { url = "https://files.pythonhosted.org/packages/ac/d8/5b833bad13016f562ab9d063d68199a4bd121d18458e439515601d3357ec/cryptography-48.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:59baa2cb386c4f0b9905bd6eb4c2a79a69a128408fd31d32ca4d7102d4156321", size = 4826672, upload-time = "2026-05-04T22:58:01.996Z" }, + { url = "https://files.pythonhosted.org/packages/98/e1/7074eb8bf3c135558c73fc2bcf0f5633f912e6fb87e868a55c454080ef09/cryptography-48.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9249e3cd978541d665967ac2cb2787fd6a62bddf1e75b3e347a594d7dacf4f74", size = 4972574, upload-time = "2026-05-04T22:58:03.968Z" }, + { url = "https://files.pythonhosted.org/packages/04/70/e5a1b41d325f797f39427aa44ef8baf0be500065ab6d8e10369d850d4a4f/cryptography-48.0.0-cp311-abi3-win32.whl", hash = "sha256:9c459db21422be75e2809370b829a87eb37f74cd785fc4aa9ea1e5f43b47cda4", size = 3294868, upload-time = "2026-05-04T22:58:06.467Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ac/8ac51b4a5fc5932eb7ee5c517ba7dc8cd834f0048962b6b352f00f41ebf9/cryptography-48.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:5b012212e08b8dd5edc78ef54da83dd9892fd9105323b3993eff6bea65dc21d7", size = 3817107, upload-time = "2026-05-04T22:58:08.845Z" }, + { url = "https://files.pythonhosted.org/packages/6b/84/70e3feea9feea87fd7cbe77efb2712ae1e3e6edf10749dc6e95f4e60e455/cryptography-48.0.0-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:3cb07a3ed6431663cd321ea8a000a1314c74211f823e4177fefa2255e057d1ec", size = 7986556, upload-time = "2026-05-04T22:58:11.172Z" }, + { url = "https://files.pythonhosted.org/packages/89/6e/18e07a618bb5442ba10cf4df16e99c071365528aa570dfcb8c02e25a303b/cryptography-48.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c7378637d7d88016fa6791c159f698b3d3eed28ebf844ac36b9dc04a14dae18", size = 4684776, upload-time = "2026-05-04T22:58:13.712Z" }, + { url = "https://files.pythonhosted.org/packages/be/6a/4ea3b4c6c6759794d5ee2103c304a5076dc4b19ae1f9fe47dba439e159e9/cryptography-48.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc90c0b39b2e3c65ef52c804b72e3c58f8a04ab2a1871272798e5f9572c17d20", size = 4698121, upload-time = "2026-05-04T22:58:16.448Z" }, + { url = "https://files.pythonhosted.org/packages/2f/59/6ff6ad6cae03bb887da2a5860b2c9805f8dac969ef01ce563336c49bd1d1/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:76341972e1eff8b4bea859f09c0d3e64b96ce931b084f9b9b7db8ef364c30eff", size = 4690042, upload-time = "2026-05-04T22:58:18.544Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b4/fc334ed8cfd705aca282fe4d8f5ae64a8e0f74932e9feecb344610cf6e4d/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:55b7718303bf06a5753dcdccf2f3945cf18ad7bffde41b61226e4db31ab89a9c", size = 5282526, upload-time = "2026-05-04T22:58:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/11/08/9f8c5386cc4cd90d8255c7cdd0f5baf459a08502a09de30dc51f553d38dc/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:a64697c641c7b1b2178e573cbc31c7c6684cd56883a478d75143dbb7118036db", size = 4733116, upload-time = "2026-05-04T22:58:23.627Z" }, + { url = "https://files.pythonhosted.org/packages/b8/77/99307d7574045699f8805aa500fa0fb83422d115b5400a064ddd306d7750/cryptography-48.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:561215ea3879cb1cbbf272867e2efda62476f240fb58c64de6b393ae19246741", size = 4316030, upload-time = "2026-05-04T22:58:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/fd/36/a608b98337af3cb2aff4818e406649d30572b7031918b04c87d979495348/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:ad64688338ed4bc1a6618076ba75fd7194a5f1797ac60b47afe926285adb3166", size = 4689640, upload-time = "2026-05-04T22:58:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a6/825010a291b4438aecc1f568bc428189fc1175515223632477c07dc0a6df/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:906cbf0670286c6e0044156bc7d4af9cbb0ef6db9f73e52c3ec56ba6bdde5336", size = 5237657, upload-time = "2026-05-04T22:58:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/b9/09/4e76a09b4caa29aad535ddc806f5d4c5d01885bd978bd984fbc6ca032cae/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:ea8990436d914540a40ab24b6a77c0969695ed52f4a4874c5137ccf7045a7057", size = 4732362, upload-time = "2026-05-04T22:58:32.009Z" }, + { url = "https://files.pythonhosted.org/packages/18/78/444fa04a77d0cb95f417dda20d450e13c56ba8e5220fc892a1658f44f882/cryptography-48.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c18684a7f0cc9a3cb60328f496b8e3372def7c5d2df39ac267878b05565aaaae", size = 4819580, upload-time = "2026-05-04T22:58:34.254Z" }, + { url = "https://files.pythonhosted.org/packages/38/85/ea67067c70a1fd4be2c63d35eeed82658023021affccc7b17705f8527dd2/cryptography-48.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9be5aafa5736574f8f15f262adc81b2a9869e2cfe9014d52a44633905b40d52c", size = 4963283, upload-time = "2026-05-04T22:58:36.376Z" }, + { url = "https://files.pythonhosted.org/packages/75/54/cc6d0f3deac3e81c7f847e8a189a12b6cdd65059b43dad25d4316abd849a/cryptography-48.0.0-cp314-cp314t-win32.whl", hash = "sha256:c17dfe85494deaeddc5ce251aebd1d60bbe6afc8b62071bb0b469431a000124f", size = 3270954, upload-time = "2026-05-04T22:58:38.791Z" }, + { url = "https://files.pythonhosted.org/packages/49/67/cc947e288c0758a4e5473d1dcb743037ab7785541265a969240b8885441a/cryptography-48.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27241b1dc9962e056062a8eef1991d02c3a24569c95975bd2322a8a52c6e5e12", size = 3797313, upload-time = "2026-05-04T22:58:40.746Z" }, + { url = "https://files.pythonhosted.org/packages/f2/63/61d4a4e1c6b6bab6ce1e213cd36a24c415d90e76d78c5eb8577c5541d2e8/cryptography-48.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:58d00498e8933e4a194f3076aee1b4a97dfec1a6da444535755822fe5d8b0b86", size = 7983482, upload-time = "2026-05-04T22:58:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ac/f5b5995b87770c693e2596559ffafe195b4033a57f14a82268a2842953f3/cryptography-48.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:614d0949f4790582d2cc25553abd09dd723025f0c0e7c67376a1d77196743d6e", size = 4683266, upload-time = "2026-05-04T22:58:46.064Z" }, + { url = "https://files.pythonhosted.org/packages/ec/c6/8b14f67e18338fbc4adb76f66c001f5c3610b3e2d1837f268f47a347dbbb/cryptography-48.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ce4bfae76319a532a2dc68f82cc32f5676ee792a983187dac07183690e5c66f", size = 4696228, upload-time = "2026-05-04T22:58:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/ea/73/f808fbae9514bd91b47875b003f13e284c8c6bdfd904b7944e803937eec1/cryptography-48.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:2eb992bbd4661238c5a397594c83f5b4dc2bc5b848c365c8f991b6780efcc5c7", size = 4689097, upload-time = "2026-05-04T22:58:50.9Z" }, + { url = "https://files.pythonhosted.org/packages/93/01/d86632d7d28db8ae83221995752eeb6639ffb374c2d22955648cf8d52797/cryptography-48.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:22a5cb272895dce158b2cacdfdc3debd299019659f42947dbdac6f32d68fe832", size = 5283582, upload-time = "2026-05-04T22:58:53.017Z" }, + { url = "https://files.pythonhosted.org/packages/02/e1/50edc7a50334807cc4791fc4a0ce7468b4a1416d9138eab358bfc9a3d70b/cryptography-48.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2b4d59804e8408e2fea7d1fbaf218e5ec984325221db76e6a241a9abd6cdd95c", size = 4730479, upload-time = "2026-05-04T22:58:55.611Z" }, + { url = "https://files.pythonhosted.org/packages/6f/af/99a582b1b1641ff5911ac559beb45097cf79efd4ead4657f578ef1af2d47/cryptography-48.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:984a20b0f62a26f48a3396c72e4bc34c66e356d356bf370053066b3b6d54634a", size = 4326481, upload-time = "2026-05-04T22:58:57.607Z" }, + { url = "https://files.pythonhosted.org/packages/90/ee/89aa26a06ef0a7d7611788ffd571a7c50e368cc6a4d5eef8b4884e866edb/cryptography-48.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5a5ed8fde7a1d09376ca0b40e68cd59c69fe23b1f9768bd5824f54681626032a", size = 4688713, upload-time = "2026-05-04T22:59:00.077Z" }, + { url = "https://files.pythonhosted.org/packages/70/ba/bcb1b0bb7a33d4c7c0c4d4c7874b4a62ae4f56113a5f4baefa362dfb1f0f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:8cd666227ef7af430aa5914a9910e0ddd703e75f039cef0825cd0da71b6b711a", size = 5238165, upload-time = "2026-05-04T22:59:02.317Z" }, + { url = "https://files.pythonhosted.org/packages/c9/70/ca4003b1ce5ca3dc3186ada51908c8a9b9ff7d5cab83cc0d43ee14ec144f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9071196d81abc88b3516ac8cdfad32e2b66dd4a5393a8e68a961e9161ddc6239", size = 4729947, upload-time = "2026-05-04T22:59:05.255Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/4ec7cf774207905aef1a8d11c3750d5a1db805eb380ee4e16df317870128/cryptography-48.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e2d54c8be6152856a36f0882ab231e70f8ec7f14e93cf87db8a2ed056bf160c", size = 4822059, upload-time = "2026-05-04T22:59:07.802Z" }, + { url = "https://files.pythonhosted.org/packages/1e/75/a2e55f99c16fcac7b5d6c1eb19ad8e00799854d6be5ca845f9259eae1681/cryptography-48.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5da777e32ffed6f85a7b2b3f7c5cbc88c146bfcd0a1d7baf5fcc6c52ee35dd4", size = 4960575, upload-time = "2026-05-04T22:59:09.851Z" }, + { url = "https://files.pythonhosted.org/packages/b8/23/6e6f32143ab5d8b36ca848a502c4bcd477ae75b9e1677e3530d669062578/cryptography-48.0.0-cp39-abi3-win32.whl", hash = "sha256:77a2ccbbe917f6710e05ba9adaa25fb5075620bf3ea6fb751997875aff4ae4bd", size = 3279117, upload-time = "2026-05-04T22:59:12.019Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/0fea98a70cf1749d41d738836f6349d97945f7c89433a259a6c2642eefeb/cryptography-48.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:16cd65b9330583e4619939b3a3843eec1e6e789744bb01e7c7e2e62e33c239c8", size = 3792100, upload-time = "2026-05-04T22:59:14.884Z" }, + { url = "https://files.pythonhosted.org/packages/be/d2/024b5e06be9d44cb021fb0e1a03d34d63989cf56a0fe62f3dfbab695b9b4/cryptography-48.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:84cf79f0dc8b36ac5da873481716e87aef31fcfa0444f9e1d8b4b2cece142855", size = 3950391, upload-time = "2026-05-04T22:59:17.415Z" }, + { url = "https://files.pythonhosted.org/packages/bc/17/3861e17c56fa0fd37491a14a8673fdb77c57fc5693cafe745ea8b06dba75/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:fdfef35d751d510fcef5252703621574364fec16418c4a1e5e1055248401054b", size = 4637126, upload-time = "2026-05-04T22:59:20.197Z" }, + { url = "https://files.pythonhosted.org/packages/f0/0a/7e226dbff530f21480727eb764973a7bff2b912f8e15cd4f129e71b56d1d/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:0890f502ddf7d9c6426129c3f49f5c0a39278ed7cd6322c8755ffca6ee675a13", size = 4667270, upload-time = "2026-05-04T22:59:22.647Z" }, + { url = "https://files.pythonhosted.org/packages/3b/f2/5a72274ca9f1b2a8b44a662ee0bf1b435909deb473d6f97bcd035bcdbc71/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:ecde28a596bead48b0cfd2a1b4416c3d43074c2d785e3a398d7ec1fc4d0f7fbb", size = 4636797, upload-time = "2026-05-04T22:59:24.912Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e1/48cedb2fe63626e91ded1edad159e2a4fb8b6906c4425eb7749673077ce7/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:4defde8685ae324a9eb9d818717e93b4638ef67070ac9bc15b8ca85f63048355", size = 4666800, upload-time = "2026-05-04T22:59:27.474Z" }, + { url = "https://files.pythonhosted.org/packages/a2/ca/7e8365deec19afb2b2c7be7c1c0aa8f99633b54e90c570999acda93260fc/cryptography-48.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:db63bf618e5dea46c07de12e900fe1cdd2541e6dc9dbae772a70b7d4d4765f6a", size = 3739536, upload-time = "2026-05-04T22:59:29.61Z" }, +] + +[[package]] +name = "deprecated" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" }, +] + +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", hash = "sha256:292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015", size = 29341, upload-time = "2026-04-14T04:09:19.867Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/77/7b3966d0b9d1d31a36ddf1746926a11dface89a83409bf1483f0237aa758/idna-3.15.tar.gz", hash = "sha256:ca962446ea538f7092a95e057da437618e886f4d349216d2b1e294abfdb65fdc", size = 199245, upload-time = "2026-05-12T22:45:57.011Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/23/408243171aa9aaba178d3e2559159c24c1171a641aa83b67bdd3394ead8e/idna-3.15-py3-none-any.whl", hash = "sha256:048adeaf8c2d788c40fee287673ccaa74c24ffd8dcf09ffa555a2fbb59f10ac8", size = 72340, upload-time = "2026-05-12T22:45:55.733Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jiter" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/c1/0cddc6eb17d4c53a99840953f95dd3accdc5cfc7a337b0e9b26476276be9/jiter-0.14.0.tar.gz", hash = "sha256:e8a39e66dac7153cf3f964a12aad515afa8d74938ec5cc0018adcdae5367c79e", size = 165725, upload-time = "2026-04-10T14:28:42.01Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/1f/198ae537fccb7080a0ed655eb56abf64a92f79489dfbf79f40fa34225bcd/jiter-0.14.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7e791e247b8044512e070bd1f3633dc08350d32776d2d6e7473309d0edf256a2", size = 316896, upload-time = "2026-04-10T14:26:01.986Z" }, + { url = "https://files.pythonhosted.org/packages/cf/34/da67cff3fce964a36d03c3e365fb0f8726ade2a6cfd4d3c70107e216ead6/jiter-0.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71527ce13fd5a0c4e40ad37331f8c547177dbb2dd0a93e5278b6a5eecf748804", size = 321085, upload-time = "2026-04-10T14:26:03.364Z" }, + { url = "https://files.pythonhosted.org/packages/ed/36/4c72e67180d4e71a4f5dcf7886d0840e83c49ab11788172177a77570326e/jiter-0.14.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02c4a7ab56f746014874f2c525584c0daca1dec37f66fd707ecef3b7e5c2228c", size = 347393, upload-time = "2026-04-10T14:26:05.314Z" }, + { url = "https://files.pythonhosted.org/packages/bc/db/9b39e09ceafa9878235c0fc29e3e3f9b12a4c6a98ea3085b998cadf3accc/jiter-0.14.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:376e9dafff914253bb9d46cdc5f7965607fbe7feb0a491c34e35f92b2770702e", size = 372937, upload-time = "2026-04-10T14:26:06.884Z" }, + { url = "https://files.pythonhosted.org/packages/b0/96/0dcba1d7a82c1b720774b48ef239376addbaf30df24c34742ac4a57b67b2/jiter-0.14.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23ad2a7a9da1935575c820428dd8d2490ce4d23189691ce33da1fc0a58e14e1c", size = 463646, upload-time = "2026-04-10T14:26:08.345Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e3/f61b71543e746e6b8b805e7755814fc242715c16f1dba58e1cbccb8032c2/jiter-0.14.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:54b3ddf5786bc7732d293bba3411ac637ecfa200a39983166d1df86a59a43c9f", size = 380225, upload-time = "2026-04-10T14:26:10.161Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5e/0ddeb7096aca099114abe36c4921016e8d251e6f35f5890240b31f1f60ae/jiter-0.14.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c001d5a646c2a50dc055dd526dad5d5245969e8234d2b1131d0451e81f3a373", size = 358682, upload-time = "2026-04-10T14:26:11.574Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d1/fe0c46cd7fda9cad8f1ff9ad217dc61f1e4280b21052ec6dfe88c1446ef2/jiter-0.14.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:834bb5bdabca2e91592a03d373838a8d0a1b8bbde7077ae6913fd2fc51812d00", size = 359973, upload-time = "2026-04-10T14:26:13.316Z" }, + { url = "https://files.pythonhosted.org/packages/ac/21/f5317f91729b501019184771c80d60abd89907009e7bfa6c7e348c5bdd44/jiter-0.14.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4e9178be60e229b1b2b0710f61b9e24d1f4f8556985a83ff4c4f95920eea7314", size = 397568, upload-time = "2026-04-10T14:26:15.212Z" }, + { url = "https://files.pythonhosted.org/packages/e9/05/79d8f33fb2bf168db0df5c9cd16fe440a8ada57e929d3677b22712c2568f/jiter-0.14.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a7e4ccff04ec03614e62c613e976a3a5860dc9714ce8266f44328bdc8b1cab2c", size = 522535, upload-time = "2026-04-10T14:26:16.956Z" }, + { url = "https://files.pythonhosted.org/packages/5c/00/d1e3ff3d2a465e67f08507d74bafb2dcd29eba91dc939820e39e8dea38b8/jiter-0.14.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:69539d936fb5d55caf6ecd33e2e884de083ff0ea28579780d56c4403094bb8d9", size = 556709, upload-time = "2026-04-10T14:26:18.5Z" }, + { url = "https://files.pythonhosted.org/packages/60/5b/bbb2189f62ace8d95e869aa4c84c9946616f301e2d02895a6f20dcc3bba3/jiter-0.14.0-cp311-cp311-win32.whl", hash = "sha256:4927d09b3e572787cc5e0a5318601448e1ab9391bcef95677f5840c2d00eaa6d", size = 208660, upload-time = "2026-04-10T14:26:20.511Z" }, + { url = "https://files.pythonhosted.org/packages/b8/86/c500b53dcbf08575f5963e536ebd757a1f7c568272ba5d180b212c9a87fb/jiter-0.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:42d6ed359ac49eb922fdd565f209c57340aa06d589c84c8413e42a0f9ae1b842", size = 204659, upload-time = "2026-04-10T14:26:22.152Z" }, + { url = "https://files.pythonhosted.org/packages/75/4a/a676249049d42cb29bef82233e4fe0524d414cbe3606c7a4b311193c2f77/jiter-0.14.0-cp311-cp311-win_arm64.whl", hash = "sha256:6dd689f5f4a5a33747b28686e051095beb214fe28cfda5e9fe58a295a788f593", size = 194772, upload-time = "2026-04-10T14:26:23.458Z" }, + { url = "https://files.pythonhosted.org/packages/5a/68/7390a418f10897da93b158f2d5a8bd0bcd73a0f9ec3bb36917085bb759ef/jiter-0.14.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:2fb2ce3a7bc331256dfb14cefc34832366bb28a9aca81deaf43bbf2a5659e607", size = 316295, upload-time = "2026-04-10T14:26:24.887Z" }, + { url = "https://files.pythonhosted.org/packages/60/a0/5854ac00ff63551c52c6c89534ec6aba4b93474e7924d64e860b1c94165b/jiter-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5252a7ca23785cef5d02d4ece6077a1b556a410c591b379f82091c3001e14844", size = 315898, upload-time = "2026-04-10T14:26:26.601Z" }, + { url = "https://files.pythonhosted.org/packages/41/a1/4f44832650a16b18e8391f1bf1d6ca4909bc738351826bcc198bba4357f4/jiter-0.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c409578cbd77c338975670ada777add4efd53379667edf0aceea730cabede6fb", size = 343730, upload-time = "2026-04-10T14:26:28.326Z" }, + { url = "https://files.pythonhosted.org/packages/48/64/a329e9d469f86307203594b1707e11ae51c3348d03bfd514a5f997870012/jiter-0.14.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7ede4331a1899d604463369c730dbb961ffdc5312bc7f16c41c2896415b1304a", size = 370102, upload-time = "2026-04-10T14:26:30.089Z" }, + { url = "https://files.pythonhosted.org/packages/94/c1/5e3dfc59635aa4d4c7bd20a820ac1d09b8ed851568356802cf1c08edb3cf/jiter-0.14.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92cd8b6025981a041f5310430310b55b25ca593972c16407af8837d3d7d2ca01", size = 461335, upload-time = "2026-04-10T14:26:31.911Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1b/dd157009dbc058f7b00108f545ccb72a2d56461395c4fc7b9cfdccb00af4/jiter-0.14.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:351bf6eda4e3a7ceb876377840c702e9a3e4ecc4624dbfb2d6463c67ae52637d", size = 378536, upload-time = "2026-04-10T14:26:33.595Z" }, + { url = "https://files.pythonhosted.org/packages/91/78/256013667b7c10b8834f8e6e54cd3e562d4c6e34227a1596addccc05e38c/jiter-0.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1dcfbeb93d9ecd9ca128bbf8910120367777973fa193fb9a39c31237d8df165", size = 353859, upload-time = "2026-04-10T14:26:35.098Z" }, + { url = "https://files.pythonhosted.org/packages/de/d9/137d65ade9093a409fe80955ce60b12bb753722c986467aeda47faf450ad/jiter-0.14.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ae039aaef8de3f8157ecc1fdd4d85043ac4f57538c245a0afaecb8321ec951c3", size = 357626, upload-time = "2026-04-10T14:26:36.685Z" }, + { url = "https://files.pythonhosted.org/packages/2e/48/76750835b87029342727c1a268bea8878ab988caf81ee4e7b880900eeb5a/jiter-0.14.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7d9d51eb96c82a9652933bd769fe6de66877d6eb2b2440e281f2938c51b5643e", size = 393172, upload-time = "2026-04-10T14:26:38.097Z" }, + { url = "https://files.pythonhosted.org/packages/a6/60/456c4e81d5c8045279aefe60e9e483be08793828800a4e64add8fdde7f2a/jiter-0.14.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d824ca4148b705970bf4e120924a212fdfca9859a73e42bd7889a63a4ea6bb98", size = 520300, upload-time = "2026-04-10T14:26:39.532Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9f/2020e0984c235f678dced38fe4eec3058cf528e6af36ebf969b410305941/jiter-0.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ff3a6465b3a0f54b1a430f45c3c0ba7d61ceb45cbc3e33f9e1a7f638d690baf3", size = 553059, upload-time = "2026-04-10T14:26:40.991Z" }, + { url = "https://files.pythonhosted.org/packages/ef/32/e2d298e1a22a4bbe6062136d1c7192db7dba003a6975e51d9a9eecabc4c2/jiter-0.14.0-cp312-cp312-win32.whl", hash = "sha256:5dec7c0a3e98d2a3f8a2e67382d0d7c3ac60c69103a4b271da889b4e8bb1e129", size = 206030, upload-time = "2026-04-10T14:26:42.517Z" }, + { url = "https://files.pythonhosted.org/packages/36/ac/96369141b3d8a4a8e4590e983085efe1c436f35c0cda940dd76d942e3e40/jiter-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:fc7e37b4b8bc7e80a63ad6cfa5fc11fab27dbfea4cc4ae644b1ab3f273dc348f", size = 201603, upload-time = "2026-04-10T14:26:44.328Z" }, + { url = "https://files.pythonhosted.org/packages/01/c3/75d847f264647017d7e3052bbcc8b1e24b95fa139c320c5f5066fa7a0bdd/jiter-0.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:ee4a72f12847ef29b072aee9ad5474041ab2924106bdca9fcf5d7d965853e057", size = 191525, upload-time = "2026-04-10T14:26:46Z" }, + { url = "https://files.pythonhosted.org/packages/97/2a/09f70020898507a89279659a1afe3364d57fc1b2c89949081975d135f6f5/jiter-0.14.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:af72f204cf4d44258e5b4c1745130ac45ddab0e71a06333b01de660ab4187a94", size = 315502, upload-time = "2026-04-10T14:26:47.697Z" }, + { url = "https://files.pythonhosted.org/packages/d6/be/080c96a45cd74f9fce5db4fd68510b88087fb37ffe2541ff73c12db92535/jiter-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4b77da71f6e819be5fbcec11a453fde5b1d0267ef6ed487e2a392fd8e14e4e3a", size = 314870, upload-time = "2026-04-10T14:26:49.149Z" }, + { url = "https://files.pythonhosted.org/packages/7d/5e/2d0fee155826a968a832cc32438de5e2a193292c8721ca70d0b53e58245b/jiter-0.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f4ea612fe8b84b8b04e51d0e78029ecf3466348e25973f953de6e6a59aa4c1", size = 343406, upload-time = "2026-04-10T14:26:50.762Z" }, + { url = "https://files.pythonhosted.org/packages/70/af/bf9ee0d3a4f8dc0d679fc1337f874fe60cdbf841ebbb304b374e1c9aaceb/jiter-0.14.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62fe2451f8fcc0240261e6a4df18ecbcd58327857e61e625b2393ea3b468aac9", size = 369415, upload-time = "2026-04-10T14:26:52.188Z" }, + { url = "https://files.pythonhosted.org/packages/0f/83/8e8561eadba31f4d3948a5b712fb0447ec71c3560b57a855449e7b8ddc98/jiter-0.14.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6112f26f5afc75bcb475787d29da3aa92f9d09c7858f632f4be6ffe607be82e9", size = 461456, upload-time = "2026-04-10T14:26:53.611Z" }, + { url = "https://files.pythonhosted.org/packages/f6/c9/c5299e826a5fe6108d172b344033f61c69b1bb979dd8d9ddd4278a160971/jiter-0.14.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:215a6cb8fb7dc702aa35d475cc00ddc7f970e5c0b1417fb4b4ac5d82fa2a29db", size = 378488, upload-time = "2026-04-10T14:26:55.211Z" }, + { url = "https://files.pythonhosted.org/packages/5d/37/c16d9d15c0a471b8644b1abe3c82668092a707d9bedcf076f24ff2e380cd/jiter-0.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4ab96a30fb3cb2c7e0cd33f7616c8860da5f5674438988a54ac717caccdbaa", size = 353242, upload-time = "2026-04-10T14:26:56.705Z" }, + { url = "https://files.pythonhosted.org/packages/58/ea/8050cb0dc654e728e1bfacbc0c640772f2181af5dedd13ae70145743a439/jiter-0.14.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3a99c1387b1f2928f799a9de899193484d66206a50e98233b6b088a7f0c1edb2", size = 356823, upload-time = "2026-04-10T14:26:58.281Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/cf71506d270e5f84d97326bf220e47aed9b95e9a4a060758fb07772170ab/jiter-0.14.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ab18d11074485438695f8d34a1b6da61db9754248f96d51341956607a8f39985", size = 392564, upload-time = "2026-04-10T14:27:00.018Z" }, + { url = "https://files.pythonhosted.org/packages/b0/cc/8c6c74a3efb5bd671bfd14f51e8a73375464ca914b1551bc3b40e26ac2c9/jiter-0.14.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:801028dcfc26ac0895e4964cbc0fd62c73be9fd4a7d7b1aaf6e5790033a719b7", size = 520322, upload-time = "2026-04-10T14:27:01.664Z" }, + { url = "https://files.pythonhosted.org/packages/41/24/68d7b883ec959884ddf00d019b2e0e82ba81b167e1253684fa90519ce33c/jiter-0.14.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ad425b087aafb4a1c7e1e98a279200743b9aaf30c3e0ba723aec93f061bd9bc8", size = 552619, upload-time = "2026-04-10T14:27:03.316Z" }, + { url = "https://files.pythonhosted.org/packages/b6/89/b1a0985223bbf3150ff9e8f46f98fc9360c1de94f48abe271bbe1b465682/jiter-0.14.0-cp313-cp313-win32.whl", hash = "sha256:882bcb9b334318e233950b8be366fe5f92c86b66a7e449e76975dfd6d776a01f", size = 205699, upload-time = "2026-04-10T14:27:04.662Z" }, + { url = "https://files.pythonhosted.org/packages/4c/19/3f339a5a7f14a11730e67f6be34f9d5105751d547b615ef593fa122a5ded/jiter-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:9b8c571a5dba09b98bd3462b5a53f27209a5cbbe85670391692ede71974e979f", size = 201323, upload-time = "2026-04-10T14:27:06.139Z" }, + { url = "https://files.pythonhosted.org/packages/50/56/752dd89c84be0e022a8ea3720bcfa0a8431db79a962578544812ce061739/jiter-0.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:34f19dcc35cb1abe7c369b3756babf8c7f04595c0807a848df8f26ef8298ef92", size = 191099, upload-time = "2026-04-10T14:27:07.564Z" }, + { url = "https://files.pythonhosted.org/packages/91/28/292916f354f25a1fe8cf2c918d1415c699a4a659ae00be0430e1c5d9ffea/jiter-0.14.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e89bcd7d426a75bb4952c696b267075790d854a07aad4c9894551a82c5b574ab", size = 320880, upload-time = "2026-04-10T14:27:09.326Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c7/b002a7d8b8957ac3d469bd59c18ef4b1595a5216ae0de639a287b9816023/jiter-0.14.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b25beaa0d4447ea8c7ae0c18c688905d34840d7d0b937f2f7bdd52162c98a40", size = 346563, upload-time = "2026-04-10T14:27:11.287Z" }, + { url = "https://files.pythonhosted.org/packages/f9/3b/f8d07580d8706021d255a6356b8fab13ee4c869412995550ce6ed4ddf97d/jiter-0.14.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:651a8758dd413c51e3b7f6557cdc6921faf70b14106f45f969f091f5cda990ea", size = 357928, upload-time = "2026-04-10T14:27:12.729Z" }, + { url = "https://files.pythonhosted.org/packages/47/5b/ac1a974da29e35507230383110ffec59998b290a8732585d04e19a9eb5ba/jiter-0.14.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e1a7eead856a5038a8d291f1447176ab0b525c77a279a058121b5fccee257f6f", size = 203519, upload-time = "2026-04-10T14:27:14.125Z" }, + { url = "https://files.pythonhosted.org/packages/96/6d/9fc8433d667d2454271378a79747d8c76c10b51b482b454e6190e511f244/jiter-0.14.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e692633a12cda97e352fdcd1c4acc971b1c28707e1e33aeef782b0cbf051975", size = 190113, upload-time = "2026-04-10T14:27:16.638Z" }, + { url = "https://files.pythonhosted.org/packages/4f/1e/354ed92461b165bd581f9ef5150971a572c873ec3b68a916d5aa91da3cc2/jiter-0.14.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:6f396837fc7577871ca8c12edaf239ed9ccef3bbe39904ae9b8b63ce0a48b140", size = 315277, upload-time = "2026-04-10T14:27:18.109Z" }, + { url = "https://files.pythonhosted.org/packages/a6/95/8c7c7028aa8636ac21b7a55faef3e34215e6ed0cbf5ae58258427f621aa3/jiter-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a4d50ea3d8ba4176f79754333bd35f1bbcd28e91adc13eb9b7ca91bc52a6cef9", size = 315923, upload-time = "2026-04-10T14:27:19.603Z" }, + { url = "https://files.pythonhosted.org/packages/47/40/e2a852a44c4a089f2681a16611b7ce113224a80fd8504c46d78491b47220/jiter-0.14.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce17f8a050447d1b4153bda4fb7d26e6a9e74eb4f4a41913f30934c5075bf615", size = 344943, upload-time = "2026-04-10T14:27:21.262Z" }, + { url = "https://files.pythonhosted.org/packages/fc/1f/670f92adee1e9895eac41e8a4d623b6da68c4d46249d8b556b60b63f949e/jiter-0.14.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4f1c4b125e1652aefbc2e2c1617b60a160ab789d180e3d423c41439e5f32850", size = 369725, upload-time = "2026-04-10T14:27:22.766Z" }, + { url = "https://files.pythonhosted.org/packages/01/2f/541c9ba567d05de1c4874a0f8f8c5e3fd78e2b874266623da9a775cf46e0/jiter-0.14.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be808176a6a3a14321d18c603f2d40741858a7c4fc982f83232842689fe86dd9", size = 461210, upload-time = "2026-04-10T14:27:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/ce/a9/c31cbec09627e0d5de7aeaec7690dba03e090caa808fefd8133137cf45bc/jiter-0.14.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26679d58ba816f88c3849306dd58cb863a90a1cf352cdd4ef67e30ccf8a77994", size = 380002, upload-time = "2026-04-10T14:27:26.155Z" }, + { url = "https://files.pythonhosted.org/packages/50/02/3c05c1666c41904a2f607475a73e7a4763d1cbde2d18229c4f85b22dc253/jiter-0.14.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80381f5a19af8fa9aef743f080e34f6b25ebd89656475f8cf0470ec6157052aa", size = 354678, upload-time = "2026-04-10T14:27:27.701Z" }, + { url = "https://files.pythonhosted.org/packages/7d/97/e15b33545c2b13518f560d695f974b9891b311641bdcf178d63177e8801e/jiter-0.14.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:004df5fdb8ecbd6d99f3227df18ba1a259254c4359736a2e6f036c944e02d7c5", size = 358920, upload-time = "2026-04-10T14:27:29.256Z" }, + { url = "https://files.pythonhosted.org/packages/ad/d2/8b1461def6b96ba44530df20d07ef7a1c7da22f3f9bf1727e2d611077bf1/jiter-0.14.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cff5708f7ed0fa098f2b53446c6fa74c48469118e5cd7497b4f1cd569ab06928", size = 394512, upload-time = "2026-04-10T14:27:31.344Z" }, + { url = "https://files.pythonhosted.org/packages/e3/88/837566dd6ed6e452e8d3205355afd484ce44b2533edfa4ed73a298ea893e/jiter-0.14.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:2492e5f06c36a976d25c7cc347a60e26d5470178d44cde1b9b75e60b4e519f28", size = 521120, upload-time = "2026-04-10T14:27:33.299Z" }, + { url = "https://files.pythonhosted.org/packages/89/6b/b00b45c4d1b4c031777fe161d620b755b5b02cdade1e316dcb46e4471d63/jiter-0.14.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:7609cfbe3a03d37bfdbf5052012d5a879e72b83168a363deae7b3a26564d57de", size = 553668, upload-time = "2026-04-10T14:27:34.868Z" }, + { url = "https://files.pythonhosted.org/packages/ad/d8/6fe5b42011d19397433d345716eac16728ac241862a2aac9c91923c7509a/jiter-0.14.0-cp314-cp314-win32.whl", hash = "sha256:7282342d32e357543565286b6450378c3cd402eea333fc1ebe146f1fabb306fc", size = 207001, upload-time = "2026-04-10T14:27:36.455Z" }, + { url = "https://files.pythonhosted.org/packages/e5/43/5c2e08da1efad5e410f0eaaabeadd954812612c33fbbd8fd5328b489139d/jiter-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:bd77945f38866a448e73b0b7637366afa814d4617790ecd88a18ca74377e6c02", size = 202187, upload-time = "2026-04-10T14:27:38Z" }, + { url = "https://files.pythonhosted.org/packages/aa/1f/6e39ac0b4cdfa23e606af5b245df5f9adaa76f35e0c5096790da430ca506/jiter-0.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:f2d4c61da0821ee42e0cdf5489da60a6d074306313a377c2b35af464955a3611", size = 192257, upload-time = "2026-04-10T14:27:39.504Z" }, + { url = "https://files.pythonhosted.org/packages/05/57/7dbc0ffbbb5176a27e3518716608aa464aee2e2887dc938f0b900a120449/jiter-0.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1bf7ff85517dd2f20a5750081d2b75083c1b269cf75afc7511bdf1f9548beb3b", size = 323441, upload-time = "2026-04-10T14:27:41.039Z" }, + { url = "https://files.pythonhosted.org/packages/83/6e/7b3314398d8983f06b557aa21b670511ec72d3b79a68ee5e4d9bff972286/jiter-0.14.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8ef8791c3e78d6c6b157c6d360fbb5c715bebb8113bc6a9303c5caff012754a", size = 348109, upload-time = "2026-04-10T14:27:42.552Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4f/8dc674bcd7db6dba566de73c08c763c337058baff1dbeb34567045b27cdc/jiter-0.14.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e74663b8b10da1fe0f4e4703fd7980d24ad17174b6bb35d8498d6e3ebce2ae6a", size = 368328, upload-time = "2026-04-10T14:27:44.574Z" }, + { url = "https://files.pythonhosted.org/packages/3b/5f/188e09a1f20906f98bbdec44ed820e19f4e8eb8aff88b9d1a5a497587ff3/jiter-0.14.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1aca29ba52913f78362ec9c2da62f22cdc4c3083313403f90c15460979b84d9b", size = 463301, upload-time = "2026-04-10T14:27:46.717Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f0/19046ef965ed8f349e8554775bb12ff4352f443fbe12b95d31f575891256/jiter-0.14.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b39b7d87a952b79949af5fef44d2544e58c21a28da7f1bae3ef166455c61746", size = 378891, upload-time = "2026-04-10T14:27:48.32Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c3/da43bd8431ee175695777ee78cf0e93eacbb47393ff493f18c45231b427d/jiter-0.14.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d918a68b26e9fab068c2b5453577ef04943ab2807b9a6275df2a812599a310", size = 360749, upload-time = "2026-04-10T14:27:49.88Z" }, + { url = "https://files.pythonhosted.org/packages/72/26/e054771be889707c6161dbdec9c23d33a9ec70945395d70f07cfea1e9a6f/jiter-0.14.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:b08997c35aee1201c1a5361466a8fb9162d03ae7bf6568df70b6c859f1e654a4", size = 358526, upload-time = "2026-04-10T14:27:51.504Z" }, + { url = "https://files.pythonhosted.org/packages/c3/0f/7bea65ea2a6d91f2bf989ff11a18136644392bf2b0497a1fa50934c30a9c/jiter-0.14.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:260bf7ca20704d58d41f669e5e9fe7fe2fa72901a6b324e79056f5d52e9c9be2", size = 393926, upload-time = "2026-04-10T14:27:53.368Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/b1ff7d70deef61ac0b7c6c2f12d2ace950cdeecb4fdc94500a0926802857/jiter-0.14.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:37826e3df29e60f30a382f9294348d0238ef127f4b5d7f5f8da78b5b9e050560", size = 521052, upload-time = "2026-04-10T14:27:55.058Z" }, + { url = "https://files.pythonhosted.org/packages/0b/7b/3b0649983cbaf15eda26a414b5b1982e910c67bd6f7b1b490f3cfc76896a/jiter-0.14.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:645be49c46f2900937ba0eaf871ad5183c96858c0af74b6becc7f4e367e36e06", size = 553716, upload-time = "2026-04-10T14:27:57.269Z" }, + { url = "https://files.pythonhosted.org/packages/97/f8/33d78c83bd93ae0c0af05293a6660f88a1977caef39a6d72a84afab94ce0/jiter-0.14.0-cp314-cp314t-win32.whl", hash = "sha256:2f7877ed45118de283786178eceaf877110abacd04fde31efff3940ae9672674", size = 207957, upload-time = "2026-04-10T14:27:59.285Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ac/2b760516c03e2227826d1f7025d89bf6bf6357a28fe75c2a2800873c50bf/jiter-0.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:14c0cb10337c49f5eafe8e7364daca5e29a020ea03580b8f8e6c597fed4e1588", size = 204690, upload-time = "2026-04-10T14:28:00.962Z" }, + { url = "https://files.pythonhosted.org/packages/dc/2e/a44c20c58aeed0355f2d326969a181696aeb551a25195f47563908a815be/jiter-0.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5419d4aa2024961da9fe12a9cfe7484996735dca99e8e090b5c88595ef1951ff", size = 191338, upload-time = "2026-04-10T14:28:02.853Z" }, + { url = "https://files.pythonhosted.org/packages/32/a1/ef34ca2cab2962598591636a1804b93645821201cc0095d4a93a9a329c9d/jiter-0.14.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:a25ffa2dbbdf8721855612f6dca15c108224b12d0c4024d0ac3d7902132b4211", size = 311366, upload-time = "2026-04-10T14:28:27.943Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/520576a532a6b8a6f42747afed289c8448c879a34d7802fe2c832d4fd38f/jiter-0.14.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ac9cbaa86c10996b92bd12c91659b60f939f8e28fcfa6bc11a0e90a774ce95b", size = 309873, upload-time = "2026-04-10T14:28:29.688Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7c/c16db114ea1f2f532f198aa8dc39585026af45af362c69a0492f31bc4821/jiter-0.14.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:844e73b6c56b505e9e169234ea3bdea2ea43f769f847f47ac559ba1d2361ebea", size = 344816, upload-time = "2026-04-10T14:28:31.348Z" }, + { url = "https://files.pythonhosted.org/packages/99/8f/15e7741ff19e9bcd4d753f7ff22f988fd54592f134ca13701c13ea8c20e0/jiter-0.14.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e52c076f187405fc21523c746c04399c9af8ece566077ed147b2126f2bcba577", size = 351445, upload-time = "2026-04-10T14:28:33.093Z" }, + { url = "https://files.pythonhosted.org/packages/21/42/9042c3f3019de4adcb8c16591c325ec7255beea9fcd33a42a43f3b0b1000/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:fbd9e482663ca9d005d051330e4d2d8150bb208a209409c10f7e7dfdf7c49da9", size = 308810, upload-time = "2026-04-10T14:28:34.673Z" }, + { url = "https://files.pythonhosted.org/packages/60/cf/a7e19b308bd86bb04776803b1f01a5f9a287a4c55205f4708827ee487fbf/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:33a20d838b91ef376b3a56896d5b04e725c7df5bc4864cc6569cf046a8d73b6d", size = 308443, upload-time = "2026-04-10T14:28:36.658Z" }, + { url = "https://files.pythonhosted.org/packages/ca/44/e26ede3f0caeff93f222559cb0cc4ca68579f07d009d7b6010c5b586f9b1/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:432c4db5255d86a259efde91e55cb4c8d18c0521d844c9e2e7efcce3899fb016", size = 343039, upload-time = "2026-04-10T14:28:38.356Z" }, + { url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" }, +] + +[[package]] +name = "lxml" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", hash = "sha256:bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13", size = 4197006, upload-time = "2026-04-18T04:32:51.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/5d/3bccad330292946f97962df9d5f2d3ae129cce6e212732a781e856b91e07/lxml-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:cec05be8c876f92a5aa07b01d60bbb4d11cfbdd654cad0561c0d7b5c043a61b9", size = 8526232, upload-time = "2026-04-18T04:27:40.389Z" }, + { url = "https://files.pythonhosted.org/packages/a7/51/adc8826570a112f83bb4ddb3a2ab510bbc2ccd62c1b9fe1f34fae2d90b57/lxml-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9c03e048b6ce8e77b09c734e931584894ecd58d08296804ca2d0b184c933ce50", size = 4595448, upload-time = "2026-04-18T04:27:44.208Z" }, + { url = "https://files.pythonhosted.org/packages/54/84/5a9ec07cbe1d2334a6465f863b949a520d2699a755738986dcd3b6b89e3f/lxml-6.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:942454ff253da14218f972b23dc72fa4edf6c943f37edd19cd697618b626fac5", size = 4923771, upload-time = "2026-04-18T04:32:17.402Z" }, + { url = "https://files.pythonhosted.org/packages/a7/23/851cfa33b6b38adb628e45ad51fb27105fa34b2b3ba9d1d4aa7a9428dfe0/lxml-6.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d036ee7b99d5148072ac7c9b847193decdfeac633db350363f7bce4fff108f0e", size = 5068101, upload-time = "2026-04-18T04:32:21.437Z" }, + { url = "https://files.pythonhosted.org/packages/b0/38/41bf99c2023c6b79916ba057d83e9db21d642f473cac210201222882d38b/lxml-6.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ae5d8d5427f3cc317e7950f2da7ad276df0cfa37b8de2f5658959e618ea8512", size = 5002573, upload-time = "2026-04-18T04:32:25.373Z" }, + { url = "https://files.pythonhosted.org/packages/c2/20/053aa10bdc39747e1e923ce2d45413075e84f70a136045bb09e5eaca41d3/lxml-6.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:363e47283bde87051b821826e71dde47f107e08614e1aa312ba0c5711e77738c", size = 5202816, upload-time = "2026-04-18T04:32:29.393Z" }, + { url = "https://files.pythonhosted.org/packages/9a/da/bc710fad8bf04b93baee752c192eaa2210cd3a84f969d0be7830fea55802/lxml-6.1.0-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:f504d861d9f2a8f94020130adac88d66de93841707a23a86244263d1e54682f5", size = 5329999, upload-time = "2026-04-18T04:32:34.019Z" }, + { url = "https://files.pythonhosted.org/packages/b3/cb/bf035dedbdf7fab49411aa52e4236f3445e98d38647d85419e6c0d2806b9/lxml-6.1.0-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:23a5dc68e08ed13331d61815c08f260f46b4a60fdd1640bbeb82cf89a9d90289", size = 4659643, upload-time = "2026-04-18T04:32:37.932Z" }, + { url = "https://files.pythonhosted.org/packages/5c/4f/22be31f33727a5e4c7b01b0a874503026e50329b259d3587e0b923cf964b/lxml-6.1.0-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f15401d8d3dbf239e23c818afc10c7207f7b95f9a307e092122b6f86dd43209a", size = 5265963, upload-time = "2026-04-18T04:32:41.881Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2b/d44d0e5c79226017f4ab8c87a802ebe4f89f97e6585a8e4166dffcdd7b6e/lxml-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fcf3da95e93349e0647d48d4b36a12783105bcc74cb0c416952f9988410846a3", size = 5045444, upload-time = "2026-04-18T04:32:44.512Z" }, + { url = "https://files.pythonhosted.org/packages/d3/c3/3f034fec1594c331a6dbf9491238fdcc9d66f68cc529e109ec75b97197e1/lxml-6.1.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:0d082495c5fcf426e425a6e28daaba1fcb6d8f854a4ff01effb1f1f381203eb9", size = 4712703, upload-time = "2026-04-18T04:32:47.16Z" }, + { url = "https://files.pythonhosted.org/packages/12/16/0b83fccc158218aca75a7aa33e97441df737950734246b9fffa39301603d/lxml-6.1.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:e3c4f84b24a1fcba435157d111c4b755099c6ff00a3daee1ad281817de75ed11", size = 5252745, upload-time = "2026-04-18T04:32:50.427Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ee/12e6c1b39a77666c02eaa77f94a870aaf63c4ac3a497b2d52319448b01c6/lxml-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:976a6b39b1b13e8c354ad8d3f261f3a4ac6609518af91bdb5094760a08f132c4", size = 5226822, upload-time = "2026-04-18T04:32:53.437Z" }, + { url = "https://files.pythonhosted.org/packages/34/20/c7852904858b4723af01d2fc14b5d38ff57cb92f01934a127ebd9a9e51aa/lxml-6.1.0-cp311-cp311-win32.whl", hash = "sha256:857efde87d365706590847b916baff69c0bc9252dc5af030e378c9800c0b10e3", size = 3594026, upload-time = "2026-04-18T04:27:31.903Z" }, + { url = "https://files.pythonhosted.org/packages/02/05/d60c732b56da5085175c07c74b2df4e6d181b0c9a61e1691474f06ef4b39/lxml-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:183bfb45a493081943be7ea2b5adfc2b611e1cf377cefa8b8a8be404f45ef9a7", size = 4025114, upload-time = "2026-04-18T04:27:34.077Z" }, + { url = "https://files.pythonhosted.org/packages/c2/df/c84dcc175fd690823436d15b41cb920cd5ba5e14cd8bfb00949d5903b320/lxml-6.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:19f4164243fc206d12ed3d866e80e74f5bc3627966520da1a5f97e42c32a3f39", size = 3667742, upload-time = "2026-04-18T04:27:38.45Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d4/9326838b59dc36dfae42eec9656b97520f9997eee1de47b8316aaeed169c/lxml-6.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d2f17a16cd8751e8eb233a7e41aecdf8e511712e00088bf9be455f604cd0d28d", size = 8570663, upload-time = "2026-04-18T04:27:48.253Z" }, + { url = "https://files.pythonhosted.org/packages/d8/a4/053745ce1f8303ccbb788b86c0db3a91b973675cefc42566a188637b7c40/lxml-6.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0cea5b1d3e6e77d71bd2b9972eb2446221a69dc52bb0b9c3c6f6e5700592d93", size = 4624024, upload-time = "2026-04-18T04:27:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/90/97/a517944b20f8fd0932ad2109482bee4e29fe721416387a363306667941f6/lxml-6.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc46da94826188ed45cb53bd8e3fc076ae22675aea2087843d4735627f867c6d", size = 4930895, upload-time = "2026-04-18T04:32:56.29Z" }, + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a", size = 5093820, upload-time = "2026-04-18T04:32:58.94Z" }, + { url = "https://files.pythonhosted.org/packages/88/ee/2a5c2aa2c32016a226ca25d3e1056a8102ea6e1fe308bf50213586635400/lxml-6.1.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5715e0e28736a070f3f34a7ccc09e2fdcba0e3060abbcf61a1a5718ff6d6b105", size = 5005790, upload-time = "2026-04-18T04:33:01.272Z" }, + { url = "https://files.pythonhosted.org/packages/e3/38/a0db9be8f38ad6043ab9429487c128dd1d30f07956ef43040402f8da49e8/lxml-6.1.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4937460dc5df0cdd2f06a86c285c28afda06aefa3af949f9477d3e8df430c485", size = 5630827, upload-time = "2026-04-18T04:33:04.036Z" }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814", size = 5240445, upload-time = "2026-04-18T04:33:06.87Z" }, + { url = "https://files.pythonhosted.org/packages/55/ba/eeef4ccba09b2212fe239f46c1692a98db1878e0872ae320756488878a94/lxml-6.1.0-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:40d9189f80075f2e1f88db21ef815a2b17b28adf8e50aaf5c789bfe737027f32", size = 5350121, upload-time = "2026-04-18T04:33:09.365Z" }, + { url = "https://files.pythonhosted.org/packages/7e/01/1da87c7b587c38d0cbe77a01aae3b9c1c49ed47d76918ef3db8fc151b1ca/lxml-6.1.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:05b9b8787e35bec69e68daf4952b2e6dfcfb0db7ecf1a06f8cdfbbac4eb71aad", size = 4694949, upload-time = "2026-04-18T04:33:11.628Z" }, + { url = "https://files.pythonhosted.org/packages/a1/88/7db0fe66d5aaf128443ee1623dec3db1576f3e4c17751ec0ef5866468590/lxml-6.1.0-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0f08beb0182e3e9a86fae124b3c47a7b41b7b69b225e1377db983802404e54", size = 5243901, upload-time = "2026-04-18T04:33:13.95Z" }, + { url = "https://files.pythonhosted.org/packages/00/a8/1346726af7d1f6fca1f11223ba34001462b0a3660416986d37641708d57c/lxml-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73becf6d8c81d4c76b1014dbd3584cb26d904492dcf73ca85dc8bff08dcd6d2d", size = 5048054, upload-time = "2026-04-18T04:33:16.965Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b7/85057012f035d1a0c87e02f8c723ca3c3e6e0728bcf4cb62080b21b1c1e3/lxml-6.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1ae225f66e5938f4fa29d37e009a3bb3b13032ac57eb4eb42afa44f6e4054e69", size = 4777324, upload-time = "2026-04-18T04:33:19.832Z" }, + { url = "https://files.pythonhosted.org/packages/75/6c/ad2f94a91073ef570f33718040e8e160d5fb93331cf1ab3ca1323f939e2d/lxml-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:690022c7fae793b0489aa68a658822cea83e0d5933781811cabbf5ea3bcfe73d", size = 5645702, upload-time = "2026-04-18T04:33:22.436Z" }, + { url = "https://files.pythonhosted.org/packages/3b/89/0bb6c0bd549c19004c60eea9dc554dd78fd647b72314ef25d460e0d208c6/lxml-6.1.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:63aeafc26aac0be8aff14af7871249e87ea1319be92090bfd632ec68e03b16a5", size = 5232901, upload-time = "2026-04-18T04:33:26.21Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d9/d609a11fb567da9399f525193e2b49847b5a409cdebe737f06a8b7126bdc/lxml-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:264c605ab9c0e4aa1a679636f4582c4d3313700009fac3ec9c3412ed0d8f3e1d", size = 5261333, upload-time = "2026-04-18T04:33:28.984Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3a/ac3f99ec8ac93089e7dd556f279e0d14c24de0a74a507e143a2e4b496e7c/lxml-6.1.0-cp312-cp312-win32.whl", hash = "sha256:56971379bc5ee8037c5a0f09fa88f66cdb7d37c3e38af3e45cf539f41131ac1f", size = 3596289, upload-time = "2026-04-18T04:27:42.819Z" }, + { url = "https://files.pythonhosted.org/packages/f2/a7/0a915557538593cb1bbeedcd40e13c7a261822c26fecbbdb71dad0c2f540/lxml-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:bba078de0031c219e5dd06cf3e6bf8fb8e6e64a77819b358f53bb132e3e03366", size = 3997059, upload-time = "2026-04-18T04:27:46.764Z" }, + { url = "https://files.pythonhosted.org/packages/92/96/a5dc078cf0126fbfbc35611d77ecd5da80054b5893e28fb213a5613b9e1d/lxml-6.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:c3592631e652afa34999a088f98ba7dfc7d6aff0d535c410bea77a71743f3819", size = 3659552, upload-time = "2026-04-18T04:27:51.133Z" }, + { url = "https://files.pythonhosted.org/packages/08/03/69347590f1cf4a6d5a4944bb6099e6d37f334784f16062234e1f892fdb1d/lxml-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a0092f2b107b69601adf562a57c956fbb596e05e3e6651cabd3054113b007e45", size = 8559689, upload-time = "2026-04-18T04:31:57.785Z" }, + { url = "https://files.pythonhosted.org/packages/3f/58/25e00bb40b185c974cfe156c110474d9a8a8390d5f7c92a4e328189bb60e/lxml-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fc7140d7a7386e6b545d41b7358f4d02b656d4053f5fa6859f92f4b9c2572c4d", size = 4617892, upload-time = "2026-04-18T04:32:01.78Z" }, + { url = "https://files.pythonhosted.org/packages/f5/54/92ad98a94ac318dc4f97aaac22ff8d1b94212b2ae8af5b6e9b354bf825f7/lxml-6.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:419c58fc92cc3a2c3fa5f78c63dbf5da70c1fa9c1b25f25727ecee89a96c7de2", size = 4923489, upload-time = "2026-04-18T04:33:31.401Z" }, + { url = "https://files.pythonhosted.org/packages/15/3b/a20aecfab42bdf4f9b390590d345857ad3ffd7c51988d1c89c53a0c73faf/lxml-6.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:37fabd1452852636cf38ecdcc9dd5ca4bba7a35d6c53fa09725deeb894a87491", size = 5082162, upload-time = "2026-04-18T04:33:34.262Z" }, + { url = "https://files.pythonhosted.org/packages/45/26/2cdb3d281ac1bd175603e290cbe4bad6eff127c0f8de90bafd6f8548f0fd/lxml-6.1.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2853c8b2170cc6cd54a6b4d50d2c1a8a7aeca201f23804b4898525c7a152cfc", size = 4993247, upload-time = "2026-04-18T04:33:36.674Z" }, + { url = "https://files.pythonhosted.org/packages/f6/05/d735aef963740022a08185c84821f689fc903acb3d50326e6b1e9886cc22/lxml-6.1.0-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8e369cbd690e788c8d15e56222d91a09c6a417f49cbc543040cba0fe2e25a79e", size = 5613042, upload-time = "2026-04-18T04:33:39.205Z" }, + { url = "https://files.pythonhosted.org/packages/ee/b8/ead7c10efff731738c72e59ed6eb5791854879fbed7ae98781a12006263a/lxml-6.1.0-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e69aa6805905807186eb00e66c6d97a935c928275182eb02ee40ba00da9623b2", size = 5228304, upload-time = "2026-04-18T04:33:41.647Z" }, + { url = "https://files.pythonhosted.org/packages/6b/10/e9842d2ec322ea65f0a7270aa0315a53abed06058b88ef1b027f620e7a5f/lxml-6.1.0-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:4bd1bdb8a9e0e2dd229de19b5f8aebac80e916921b4b2c6ef8a52bc131d0c1f9", size = 5341578, upload-time = "2026-04-18T04:33:44.596Z" }, + { url = "https://files.pythonhosted.org/packages/89/54/40d9403d7c2775fa7301d3ddd3464689bfe9ba71acc17dfff777071b4fdc/lxml-6.1.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:cbd7b79cdcb4986ad78a2662625882747f09db5e4cd7b2ae178a88c9c51b3dfe", size = 4700209, upload-time = "2026-04-18T04:33:47.552Z" }, + { url = "https://files.pythonhosted.org/packages/85/b2/bbdcc2cf45dfc7dfffef4fd97e5c47b15919b6a365247d95d6f684ef5e82/lxml-6.1.0-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:43e4d297f11080ec9d64a4b1ad7ac02b4484c9f0e2179d9c4ef78e886e747b88", size = 5232365, upload-time = "2026-04-18T04:33:50.249Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/b06875665e53aaba7127611a7bed3b7b9658e20b22bc2dd217a0b7ab0091/lxml-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cc16682cc987a3da00aa56a3aa3075b08edb10d9b1e476938cfdbee8f3b67181", size = 5043654, upload-time = "2026-04-18T04:33:52.71Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9c/e71a069d09641c1a7abeb30e693f828c7c90a41cbe3d650b2d734d876f85/lxml-6.1.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d6d8efe71429635f0559579092bb5e60560d7b9115ee38c4adbea35632e7fa24", size = 4769326, upload-time = "2026-04-18T04:33:55.244Z" }, + { url = "https://files.pythonhosted.org/packages/cc/06/7a9cd84b3d4ed79adf35f874750abb697dec0b4a81a836037b36e47c091a/lxml-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e39ab3a28af7784e206d8606ec0e4bcad0190f63a492bca95e94e5a4aef7f6e", size = 5635879, upload-time = "2026-04-18T04:33:58.509Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f0/9d57916befc1e54c451712c7ee48e9e74e80ae4d03bdce49914e0aee42cd/lxml-6.1.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:9eb667bf50856c4a58145f8ca2d5e5be160191e79eb9e30855a476191b3c3495", size = 5224048, upload-time = "2026-04-18T04:34:00.943Z" }, + { url = "https://files.pythonhosted.org/packages/99/75/90c4eefda0c08c92221fe0753db2d6699a4c628f76ff4465ec20dea84cc1/lxml-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7f4a77d6f7edf9230cee3e1f7f6764722a41604ee5681844f18db9a81ea0ec33", size = 5250241, upload-time = "2026-04-18T04:34:03.365Z" }, + { url = "https://files.pythonhosted.org/packages/5e/73/16596f7e4e38fa33084b9ccbccc22a15f82a290a055126f2c1541236d2ff/lxml-6.1.0-cp313-cp313-win32.whl", hash = "sha256:28902146ffbe5222df411c5d19e5352490122e14447e98cd118907ee3fd6ee62", size = 3596938, upload-time = "2026-04-18T04:31:56.206Z" }, + { url = "https://files.pythonhosted.org/packages/8e/63/981401c5680c1eb30893f00a19641ac80db5d1e7086c62cb4b13ed813038/lxml-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:4a1503c56e4e2b38dc76f2f2da7bae69670c0f1933e27cfa34b2fa5876410b16", size = 3995728, upload-time = "2026-04-18T04:31:58.763Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e8/c358a38ac3e541d16a1b527e4e9cb78c0419b0506a070ace11777e5e8404/lxml-6.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:e0af85773850417d994d019741239b901b22c6680206f46a34766926e466141d", size = 3658372, upload-time = "2026-04-18T04:32:03.629Z" }, + { url = "https://files.pythonhosted.org/packages/eb/45/cee4cf203ef0bab5c52afc118da61d6b460c928f2893d40023cfa27e0b80/lxml-6.1.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:ab863fd37458fed6456525f297d21239d987800c46e67da5ef04fc6b3dd93ac8", size = 8576713, upload-time = "2026-04-18T04:32:06.831Z" }, + { url = "https://files.pythonhosted.org/packages/8a/a7/eda05babeb7e046839204eaf254cd4d7c9130ce2bbf0d9e90ea41af5654d/lxml-6.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6fd8b1df8254ff4fd93fd31da1fc15770bde23ac045be9bb1f87425702f61cc9", size = 4623874, upload-time = "2026-04-18T04:32:10.755Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e9/db5846de9b436b91890a62f29d80cd849ea17948a49bf532d5278ee69a9e/lxml-6.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:47024feaae386a92a146af0d2aeed65229bf6fff738e6a11dda6b0015fb8fd03", size = 4949535, upload-time = "2026-04-18T04:34:06.657Z" }, + { url = "https://files.pythonhosted.org/packages/5a/ba/0d3593373dcae1d68f40dc3c41a5a92f2544e68115eb2f62319a4c2a6500/lxml-6.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3f00972f84450204cd5d93a5395965e348956aaceaadec693a22ec743f8ae3eb", size = 5086881, upload-time = "2026-04-18T04:34:09.556Z" }, + { url = "https://files.pythonhosted.org/packages/43/76/759a7484539ad1af0d125a9afe9c3fb5f82a8779fd1f5f56319d9e4ea2fd/lxml-6.1.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97faa0860e13b05b15a51fb4986421ef7a30f0b3334061c416e0981e9450ca4c", size = 5031305, upload-time = "2026-04-18T04:34:12.336Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b9/c1f0daf981a11e47636126901fd4ab82429e18c57aeb0fc3ad2940b42d8b/lxml-6.1.0-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:972a6451204798675407beaad97b868d0c733d9a74dafefc63120b81b8c2de28", size = 5647522, upload-time = "2026-04-18T04:34:14.89Z" }, + { url = "https://files.pythonhosted.org/packages/31/e6/1f533dcd205275363d9ba3511bcec52fa2df86abf8abe6a5f2c599f0dc31/lxml-6.1.0-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fe022f20bc4569ec66b63b3fb275a3d628d9d32da6326b2982584104db6d3086", size = 5239310, upload-time = "2026-04-18T04:34:17.652Z" }, + { url = "https://files.pythonhosted.org/packages/c3/8c/4175fb709c78a6e315ed814ed33be3defd8b8721067e70419a6cf6f971da/lxml-6.1.0-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:75c4c7c619a744f972f4451bf5adf6d0fb00992a1ffc9fd78e13b0bc817cc99f", size = 5350799, upload-time = "2026-04-18T04:34:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/6ffdebc5994975f0dde4acb59761902bd9d9bb84422b9a0bd239a7da9ca8/lxml-6.1.0-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:3648f20d25102a22b6061c688beb3a805099ea4beb0a01ce62975d926944d292", size = 4697693, upload-time = "2026-04-18T04:34:23.541Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f1/565f36bd5c73294602d48e04d23f81ff4c8736be6ba5e1d1ec670ac9be80/lxml-6.1.0-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77b9f99b17cbf14026d1e618035077060fc7195dd940d025149f3e2e830fbfcb", size = 5250708, upload-time = "2026-04-18T04:34:26.001Z" }, + { url = "https://files.pythonhosted.org/packages/5a/11/a68ab9dd18c5c499404deb4005f4bc4e0e88e5b72cd755ad96efec81d18d/lxml-6.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32662519149fd7a9db354175aa5e417d83485a8039b8aaa62f873ceee7ea4cad", size = 5084737, upload-time = "2026-04-18T04:34:28.32Z" }, + { url = "https://files.pythonhosted.org/packages/ab/78/e8f41e2c74f4af564e6a0348aea69fb6daaefa64bc071ef469823d22cc18/lxml-6.1.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:73d658216fc173cf2c939e90e07b941c5e12736b0bf6a99e7af95459cfe8eabb", size = 4737817, upload-time = "2026-04-18T04:34:30.784Z" }, + { url = "https://files.pythonhosted.org/packages/06/2d/aa4e117aa2ce2f3b35d9ff246be74a2f8e853baba5d2a92c64744474603a/lxml-6.1.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ac4db068889f8772a4a698c5980ec302771bb545e10c4b095d4c8be26749616f", size = 5670753, upload-time = "2026-04-18T04:34:33.675Z" }, + { url = "https://files.pythonhosted.org/packages/08/f5/dd745d50c0409031dbfcc4881740542a01e54d6f0110bd420fa7782110b8/lxml-6.1.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:45e9dfbd1b661eb64ba0d4dbe762bd210c42d86dd1e5bd2bdf89d634231beb43", size = 5238071, upload-time = "2026-04-18T04:34:36.12Z" }, + { url = "https://files.pythonhosted.org/packages/3e/74/ad424f36d0340a904665867dab310a3f1f4c96ff4039698de83b77f44c1f/lxml-6.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:89e8d73d09ac696a5ba42ec69787913d53284f12092f651506779314f10ba585", size = 5264319, upload-time = "2026-04-18T04:34:39.035Z" }, + { url = "https://files.pythonhosted.org/packages/53/36/a15d8b3514ec889bfd6aa3609107fcb6c9189f8dc347f1c0b81eded8d87c/lxml-6.1.0-cp314-cp314-win32.whl", hash = "sha256:ebe33f4ec1b2de38ceb225a1749a2965855bffeef435ba93cd2d5d540783bf2f", size = 3657139, upload-time = "2026-04-18T04:32:20.006Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a4/263ebb0710851a3c6c937180a9a86df1206fdfe53cc43005aa2237fd7736/lxml-6.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:398443df51c538bd578529aa7e5f7afc6c292644174b47961f3bf87fe5741120", size = 4064195, upload-time = "2026-04-18T04:32:23.876Z" }, + { url = "https://files.pythonhosted.org/packages/80/68/2000f29d323b6c286de077ad20b429fc52272e44eae6d295467043e56012/lxml-6.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:8c8984e1d8c4b3949e419158fda14d921ff703a9ed8a47236c6eb7a2b6cb4946", size = 3741870, upload-time = "2026-04-18T04:32:27.922Z" }, + { url = "https://files.pythonhosted.org/packages/30/e9/21383c7c8d43799f0da90224c0d7c921870d476ec9b3e01e1b2c0b8237c5/lxml-6.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1081dd10bc6fa437db2500e13993abf7cc30716d0a2f40e65abb935f02ec559c", size = 8827548, upload-time = "2026-04-18T04:32:15.094Z" }, + { url = "https://files.pythonhosted.org/packages/a5/01/c6bc11cd587030dd4f719f65c5657960649fe3e19196c844c75bf32cd0d6/lxml-6.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dabecc48db5f42ba348d1f5d5afdc54c6c4cc758e676926c7cd327045749517d", size = 4735866, upload-time = "2026-04-18T04:32:18.924Z" }, + { url = "https://files.pythonhosted.org/packages/f3/01/757132fff5f4acf25463b5298f1a46099f3a94480b806547b29ce5e385de/lxml-6.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e3dd5fe19c9e0ac818a9c7f132a5e43c1339ec1cbbfecb1a938bd3a47875b7c9", size = 4969476, upload-time = "2026-04-18T04:34:41.889Z" }, + { url = "https://files.pythonhosted.org/packages/fd/fb/1bc8b9d27ed64be7c8903db6c89e74dc8c2cd9ec630a7462e4654316dc5b/lxml-6.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9e7b0a4ca6dcc007a4cef00a761bba2dea959de4bd2df98f926b33c92ca5dfb9", size = 5103719, upload-time = "2026-04-18T04:34:44.797Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e7/5bf82fa28133536a54601aae633b14988e89ed61d4c1eb6b899b023233aa/lxml-6.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d27bbe326c6b539c64b42638b18bc6003a8d88f76213a97ac9ed4f885efeab7", size = 5027890, upload-time = "2026-04-18T04:34:47.634Z" }, + { url = "https://files.pythonhosted.org/packages/2d/20/e048db5d4b4ea0366648aa595f26bb764b2670903fc585b87436d0a5032c/lxml-6.1.0-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4e425db0c5445ef0ad56b0eec54f89b88b2d884656e536a90b2f52aecb4ca86", size = 5596008, upload-time = "2026-04-18T04:34:51.503Z" }, + { url = "https://files.pythonhosted.org/packages/9a/c2/d10807bc8da4824b39e5bd01b5d05c077b6fd01bd91584167edf6b269d22/lxml-6.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4b89b098105b8599dc57adac95d1813409ac476d3c948a498775d3d0c6124bfb", size = 5224451, upload-time = "2026-04-18T04:34:54.263Z" }, + { url = "https://files.pythonhosted.org/packages/3c/15/2ebea45bea427e7f0057e9ce7b2d62c5aba20c6b001cca89ed0aadb3ad41/lxml-6.1.0-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:c4a699432846df86cc3de502ee85f445ebad748a1c6021d445f3e514d2cd4b1c", size = 5312135, upload-time = "2026-04-18T04:34:56.818Z" }, + { url = "https://files.pythonhosted.org/packages/31/e2/87eeae151b0be2a308d49a7ec444ff3eb192b14251e62addb29d0bf3778f/lxml-6.1.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:30e7b2ed63b6c8e97cca8af048589a788ab5c9c905f36d9cf1c2bb549f450d2f", size = 4639126, upload-time = "2026-04-18T04:34:59.704Z" }, + { url = "https://files.pythonhosted.org/packages/a3/51/8a3f6a20902ad604dd746ec7b4000311b240d389dac5e9d95adefd349e0c/lxml-6.1.0-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:022981127642fe19866d2907d76241bb07ed21749601f727d5d5dd1ce5d1b773", size = 5232579, upload-time = "2026-04-18T04:35:02.658Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d2/650d619bdbe048d2c3f2c31edb00e35670a5e2d65b4fe3b61bce37b19121/lxml-6.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:23cad0cc86046d4222f7f418910e46b89971c5a45d3c8abfad0f64b7b05e4a9b", size = 5084206, upload-time = "2026-04-18T04:35:05.175Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8a/672ca1a3cbeabd1f511ca275a916c0514b747f4b85bdaae103b8fa92f307/lxml-6.1.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:21c3302068f50d1e8728c67c87ba92aa87043abee517aa2576cca1855326b405", size = 4758906, upload-time = "2026-04-18T04:35:08.098Z" }, + { url = "https://files.pythonhosted.org/packages/be/f1/ef4b691da85c916cb2feb1eec7414f678162798ac85e042fa164419ac05c/lxml-6.1.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:be10838781cb3be19251e276910cd508fe127e27c3242e50521521a0f3781690", size = 5620553, upload-time = "2026-04-18T04:35:11.23Z" }, + { url = "https://files.pythonhosted.org/packages/59/17/94e81def74107809755ac2782fdad4404420f1c92ca83433d117a6d5acf0/lxml-6.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2173a7bffe97667bbf0767f8a99e587740a8c56fdf3befac4b09cb29a80276fd", size = 5229458, upload-time = "2026-04-18T04:35:14.254Z" }, + { url = "https://files.pythonhosted.org/packages/21/55/c4be91b0f830a871fc1b0d730943d56013b683d4671d5198260e2eae722b/lxml-6.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c6854e9cf99c84beb004eecd7d3a3868ef1109bf2b1df92d7bc11e96a36c2180", size = 5247861, upload-time = "2026-04-18T04:35:17.006Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ca/77123e4d77df3cb1e968ade7b1f808f5d3a5c1c96b18a33895397de292c1/lxml-6.1.0-cp314-cp314t-win32.whl", hash = "sha256:00750d63ef0031a05331b9223463b1c7c02b9004cef2346a5b2877f0f9494dd2", size = 3897377, upload-time = "2026-04-18T04:32:07.656Z" }, + { url = "https://files.pythonhosted.org/packages/64/ce/3554833989d074267c063209bae8b09815e5656456a2d332b947806b05ff/lxml-6.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:80410c3a7e3c617af04de17caa9f9f20adaa817093293d69eae7d7d0522836f5", size = 4392701, upload-time = "2026-04-18T04:32:12.113Z" }, + { url = "https://files.pythonhosted.org/packages/2b/a0/9b916c68c0e57752c07f8f64b30138d9d4059dbeb27b90274dedbea128ff/lxml-6.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:26dd9f57ee3bd41e7d35b4c98a2ffd89ed11591649f421f0ec19f67d50ec67ac", size = 3817120, upload-time = "2026-04-18T04:32:15.803Z" }, + { url = "https://files.pythonhosted.org/packages/f2/88/55143966481409b1740a3ac669e611055f49efd68087a5ce41582325db3e/lxml-6.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:546b66c0dd1bb8d9fa89d7123e5fa19a8aff3a1f2141eb22df96112afb17b842", size = 3930134, upload-time = "2026-04-18T04:32:35.008Z" }, + { url = "https://files.pythonhosted.org/packages/b5/97/28b985c2983938d3cb696dd5501423afb90a8c3e869ef5d3c62569282c0f/lxml-6.1.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5cfa1a34df366d9dc0d5eaf420f4cf2bb1e1bebe1066d1c2fc28c179f8a4004c", size = 4210749, upload-time = "2026-04-18T04:36:03.626Z" }, + { url = "https://files.pythonhosted.org/packages/29/67/dfab2b7d58214921935ccea7ce9b3df9b7d46f305d12f0f532ac7cf6b804/lxml-6.1.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db88156fcf544cdbf0d95588051515cfdfd4c876fc66444eb98bceb5d6db76de", size = 4318463, upload-time = "2026-04-18T04:36:06.309Z" }, + { url = "https://files.pythonhosted.org/packages/32/a2/4ac7eb32a4d997dd352c32c32399aae27b3f268d440e6f9cfa405b575d2f/lxml-6.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:07f98f5496f96bf724b1e3c933c107f0cbf2745db18c03d2e13a291c3afd2635", size = 4251124, upload-time = "2026-04-18T04:36:09.056Z" }, + { url = "https://files.pythonhosted.org/packages/33/ef/d6abd850bb4822f9b720cfe36b547a558e694881010ff7d012191e8769c6/lxml-6.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4642e04449a1e164b5ff71ffd901ddb772dfabf5c9adf1b7be5dffe1212bc037", size = 4401758, upload-time = "2026-04-18T04:36:11.803Z" }, + { url = "https://files.pythonhosted.org/packages/40/44/3ee09a5b60cb44c4f2fbc1c9015cfd6ff5afc08f991cab295d3024dcbf2d/lxml-6.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:7da13bb6fbadfafb474e0226a30570a3445cfd47c86296f2446dafbd77079ace", size = 3508860, upload-time = "2026-04-18T04:32:48.619Z" }, +] + +[[package]] +name = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[package]] +name = "pdf-tools" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "anthropic" }, + { name = "click" }, + { name = "pdfannots" }, + { name = "pdfminer-six" }, + { name = "pikepdf" }, + { name = "pillow" }, + { name = "pypdf" }, + { name = "pypdfium2" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pytest" }, +] + +[package.metadata] +requires-dist = [ + { name = "anthropic", specifier = ">=0.39" }, + { name = "click", specifier = ">=8.1" }, + { name = "pdfannots", specifier = ">=0.4" }, + { name = "pdfminer-six", specifier = ">=20240706" }, + { name = "pikepdf", specifier = ">=9.0" }, + { name = "pillow", specifier = ">=10.4" }, + { name = "pypdf", specifier = ">=5.0" }, + { name = "pypdfium2", specifier = ">=4.30" }, +] + +[package.metadata.requires-dev] +dev = [{ name = "pytest", specifier = ">=9.2.0" }] + +[[package]] +name = "pdfannots" +version = "0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pdfminer-six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0f/05/f37a34a83ccaaaca5c47a2bfeddc59b6bce6bb7f1e8f43e31b6e44d1ed14/pdfannots-0.5.tar.gz", hash = "sha256:75da28053efa64980763b7b4891f14887d3d316f8273fcf4d02b593bbf57089c", size = 1332858, upload-time = "2025-01-08T11:09:26.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/8e/098c69c1d7dd3df5ad9175937fbcca5d52ef916b2229ae6fe29394d7d216/pdfannots-0.5-py3-none-any.whl", hash = "sha256:195aa95c702eb18511741733a862d8c4fa1f136677c3e95aa7c021679ba588bd", size = 28109, upload-time = "2025-01-08T11:09:24.996Z" }, +] + +[[package]] +name = "pdfminer-six" +version = "20260107" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "charset-normalizer" }, + { name = "cryptography" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/34/a4/5cec1112009f0439a5ca6afa8ace321f0ab2f48da3255b7a1c8953014670/pdfminer_six-20260107.tar.gz", hash = "sha256:96bfd431e3577a55a0efd25676968ca4ce8fd5b53f14565f85716ff363889602", size = 8512094, upload-time = "2026-01-07T13:29:12.937Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/8b/28c4eaec9d6b036a52cb44720408f26b1a143ca9bce76cc19e8f5de00ab4/pdfminer_six-20260107-py3-none-any.whl", hash = "sha256:366585ba97e80dffa8f00cebe303d2f381884d8637af4ce422f1df3ef38111a9", size = 6592252, upload-time = "2026-01-07T13:29:10.742Z" }, +] + +[[package]] +name = "pikepdf" +version = "10.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "deprecated" }, + { name = "lxml" }, + { name = "packaging" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/66/32a45480d84cb239c7ad31209c956496fe5b20f6fb163d794db4c79f840c/pikepdf-10.5.1.tar.gz", hash = "sha256:ffa6c7d0b77deb3af9735e0b0cae177c897431e10d342bb171b62e5527a622b7", size = 4582470, upload-time = "2026-03-18T07:56:00.036Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/6e/755108ffa7fcb069440c2963e2ba898b9ddd6db5b39c29984dc0f3b39247/pikepdf-10.5.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:6d182a507e24d03a0f47a75ea20ec2bc0bbc0224f95c0fce3805f7d626b39ae2", size = 4762486, upload-time = "2026-03-18T07:55:07.439Z" }, + { url = "https://files.pythonhosted.org/packages/ca/4e/f26b27eb3f1c460a861c6b7ad7afc157b1d403f4fae0432b8c2406f2a784/pikepdf-10.5.1-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:e1e5f38f644bc966be6094d5c303c9e64cf576c7c5805dfef4272be0ff69a57f", size = 5075340, upload-time = "2026-03-18T07:55:09.769Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a5/3763bd07252f69220417cb57555877b0561e02093efa1451905641e54d6c/pikepdf-10.5.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44c17a8e364135787b8982a0db182af750aba2ee413d0cc1e0b143de61cccc1a", size = 2485205, upload-time = "2026-03-18T07:55:11.768Z" }, + { url = "https://files.pythonhosted.org/packages/24/3e/d546f3ebeac51cb1e3a949a11bd2b92528b290c92f30464e26db9bb0dba5/pikepdf-10.5.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e78d638c820f464c3f02650a02833f12b98c6799695effd9d0d4611a390921f", size = 2717709, upload-time = "2026-03-18T07:55:13.306Z" }, + { url = "https://files.pythonhosted.org/packages/7a/03/edcc3bd696e1e3a8e414c6f9f969a3e2cbcc97e055c1daafc98676d5d019/pikepdf-10.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:45569f23d4ae6157ee7c140f467555b3132517ae5fec63aedbd93c57740152d7", size = 3690537, upload-time = "2026-03-18T07:55:14.893Z" }, + { url = "https://files.pythonhosted.org/packages/be/3b/f82d70827ac6a4436df21b6f72bae2946c246a4838aae40e6231c697021d/pikepdf-10.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5799d75141f331b2f3324d218efe10fa52677f71d0ec73d308961c0448e571ba", size = 3895585, upload-time = "2026-03-18T07:55:16.86Z" }, + { url = "https://files.pythonhosted.org/packages/ce/46/faa4483808ecd87720ce704d47931812b05fbe1c5f4bae6c7705f5b09874/pikepdf-10.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f243bf46f556261d27dc73131954e16a1869700dbea697780a2572cf5ad7ef44", size = 3804998, upload-time = "2026-03-18T07:55:18.533Z" }, + { url = "https://files.pythonhosted.org/packages/71/c8/f0c8ea17555e6bfffa5f598988edc9f1c5861f9909ca72ee745362958453/pikepdf-10.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:03665c0d3658f4bb6084dd65d2db3a44f5af2ef0cd005cbb2ef0af82bcad8c83", size = 4772405, upload-time = "2026-03-18T07:55:20.562Z" }, + { url = "https://files.pythonhosted.org/packages/b8/90/9c201894f8a27a2dad1b6dce92dd497e785e81f4f902f2e261ee04e8c1d6/pikepdf-10.5.1-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:141dab118d6462abf9324f3fe79f18f597db75c6ac96e90984b65f5544e540a3", size = 5089114, upload-time = "2026-03-18T07:55:22.298Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e1/2a0f82254265d432ee0b7323cf897fcbc062f8036853a0353ced58cb5521/pikepdf-10.5.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5d5d0fbfd54acfce3496693f1378d0a0c43025ad96abeb2ffe466737bddaaa0", size = 2491105, upload-time = "2026-03-18T07:55:23.899Z" }, + { url = "https://files.pythonhosted.org/packages/92/23/2d56b5a478aa62d5b1307aa273ca3bb67ac7db7f948708e3ab9dba9eb6b4/pikepdf-10.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3246732f3733dee4048c69a2141c2c0a80af7c9e1d31f35222d6d0d108e3678", size = 2735333, upload-time = "2026-03-18T07:55:25.527Z" }, + { url = "https://files.pythonhosted.org/packages/a6/dd/9678100282f538e5804eb80d885cf0131b1a7a36ca6acbb204858c52c6bd/pikepdf-10.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1580124500a328444c68b8b82ba9bf6166c31e02c5e4924e4bbcea2a8d2e7ee0", size = 3700125, upload-time = "2026-03-18T07:55:27.48Z" }, + { url = "https://files.pythonhosted.org/packages/88/2b/70e9ee1257b9f0010083bd3d9a51e648749284892ad3bb9e3a8691799953/pikepdf-10.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bc2b338a157c8aabafd8ecc7f2aab15e45bf2dcd0ebfe388ffff4fb4147a9e97", size = 3908975, upload-time = "2026-03-18T07:55:29.232Z" }, + { url = "https://files.pythonhosted.org/packages/ad/b0/87cc2fbdcd8ce0a8aeace28c52b0f2acc56cc19a064ec514ed80f246f891/pikepdf-10.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:b220200d96bcaec722c8c8e4a96037515c9d212775587b588fafe692c630a89e", size = 3812237, upload-time = "2026-03-18T07:55:31.285Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d4/eb00bb96b383a1dd3151d347a6339408af642d75ed998f8ac7368ddf5bcd/pikepdf-10.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:0b30d192baf0132e6d945e8b2200288bd32f2b0ec2357b1fe414ef595531b181", size = 4772545, upload-time = "2026-03-18T07:55:33.251Z" }, + { url = "https://files.pythonhosted.org/packages/42/6f/f25b9e66afd647cd090d0e62a5287135ec0ae4971b2f1601a1e3dad96fa9/pikepdf-10.5.1-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:d59a710ba6fc5a5220ac59dba4bd43612663a2fde33973a616843bc79eaf0fac", size = 5088950, upload-time = "2026-03-18T07:55:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/69/9e/f2781afe47f149f88b1c2a3e72a0f2501fcc104c23bffb2e68c89ec81ea7/pikepdf-10.5.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f245df7aeb1a69c166e923ceae9bf47c895a06286dcb94a92225f1b10156e6f", size = 2490804, upload-time = "2026-03-18T07:55:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/9a/77/f87710f01d74dfe8d3713cfe682b350c77aa7a5443552fffceb7b3b40543/pikepdf-10.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e1cdfdeec93a6eca49e6ce592269fd78007d13440719d6f95f3a5a33e609d9f", size = 2734878, upload-time = "2026-03-18T07:55:39.061Z" }, + { url = "https://files.pythonhosted.org/packages/7b/b1/b350dc5cf82de45c0c1c79fd01384b0af07e3ba82da77e276bc98ca00489/pikepdf-10.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b21b093335069d79eecf8639b150e6100043b1275ffdeb00501640d2bcbdf760", size = 3699375, upload-time = "2026-03-18T07:55:40.984Z" }, + { url = "https://files.pythonhosted.org/packages/2c/5e/f7c7473c36687d453bede6afb0a4d8fb0ebb2e846f35219db12542889df1/pikepdf-10.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:89cc87b440f663f1e4f51670930f0aa310cec30cc02d9a1c36a61432be9380fd", size = 3908458, upload-time = "2026-03-18T07:55:43.051Z" }, + { url = "https://files.pythonhosted.org/packages/38/4a/b2949669f3eaae08cc32d21b13f505ebbcabb0d7dd8808fdf743a9eb69ae/pikepdf-10.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:d10f915c80881be4802204a54ba3ce5ee9e13dd59aa6fbe4cb95230039defa86", size = 3812315, upload-time = "2026-03-18T07:55:44.829Z" }, + { url = "https://files.pythonhosted.org/packages/3c/48/b513468b4a5c7d4d9007c2c9b59686d15cca88c339225e4f2069c15799f9/pikepdf-10.5.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:ac7a96d6e4a23cd2dfc07f2cec9f55b000fcd4be4be888dbbe5a767dcd4c409e", size = 4770764, upload-time = "2026-03-18T07:55:46.597Z" }, + { url = "https://files.pythonhosted.org/packages/2d/42/da2abc72d0d04b48158b6bccad6e31dfd2cef63f501cdb6192af100d7545/pikepdf-10.5.1-cp314-cp314-macosx_15_0_x86_64.whl", hash = "sha256:1b81fd3f3de40ec4ad87fe9337d91e5f1301d4c4450ff02f4aa581c76609a3b7", size = 5089799, upload-time = "2026-03-18T07:55:48.45Z" }, + { url = "https://files.pythonhosted.org/packages/1d/47/19731ef57be6007fb5007438618d6803d7abb4adaa095e55a8e7bd5cfa25/pikepdf-10.5.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:781ee394f38ebdf412dc674a1e3333a844dbab673d4d8db04050055062b8fa8d", size = 2493677, upload-time = "2026-03-18T07:55:50.219Z" }, + { url = "https://files.pythonhosted.org/packages/25/87/3e115b7a47c3a5bb3a58a7ba51de20d4964393735fab0085fc94a979113b/pikepdf-10.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17e6a136b870424e66167035406662842783049ee14262f49ed2572caa584475", size = 2736452, upload-time = "2026-03-18T07:55:52.266Z" }, + { url = "https://files.pythonhosted.org/packages/ae/2b/f30006c28b58a12116561fe4fe62c9cd630e97a88de799c27a3073c6bb55/pikepdf-10.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c9ae38d8dd7acf1b4c9bcd9a38fb75735bc62049c34634b1899e47068b314c5f", size = 3702958, upload-time = "2026-03-18T07:55:54.294Z" }, + { url = "https://files.pythonhosted.org/packages/83/47/d467f13394c3be1c57b0fbc4264a8f0d1f6ae42ae61299c4695a89b2d983/pikepdf-10.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:013411404eb129b8d0cd565ce09c4f99254b9837a8e66f90d150b7c1f23a7124", size = 3910716, upload-time = "2026-03-18T07:55:56.233Z" }, + { url = "https://files.pythonhosted.org/packages/5c/b5/7753d726905f217b78e677fee82e877a6880bc326db3a13c1934884ed54b/pikepdf-10.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:70d1b5ae2e61ab5a08e2c978d18208766d5aa0747a2181c95d6e3acaa114f278", size = 3923717, upload-time = "2026-03-18T07:55:58.16Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydantic" +version = "2.13.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/fa/6d7708d2cfc1a832acb6aeb0cd16e801902df8a0f583bb3b4b527fde022e/pydantic_core-2.46.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594", size = 2111872, upload-time = "2026-05-06T13:40:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/ae/6f/aa064a3e74b5745afbdf250594f38e7ead05e2d651bcb35994b9417a0d4d/pydantic_core-2.46.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c", size = 1948255, upload-time = "2026-05-06T13:39:12.574Z" }, + { url = "https://files.pythonhosted.org/packages/43/3a/41114a9f7569b84b4d84e7a018c57c56347dac30c0d4a872946ec4e36c46/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826", size = 1972827, upload-time = "2026-05-06T13:38:19.841Z" }, + { url = "https://files.pythonhosted.org/packages/ef/25/1ab42e8048fe551934d9884e8d64daa7e990ad386f310a15981aeb6a5b08/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04", size = 2041051, upload-time = "2026-05-06T13:38:10.447Z" }, + { url = "https://files.pythonhosted.org/packages/94/c2/1a934597ddf08da410385b3b7aae91956a5a76c635effef456074fad7e88/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e", size = 2221314, upload-time = "2026-05-06T13:40:13.089Z" }, + { url = "https://files.pythonhosted.org/packages/02/6d/9e8ad178c9c4df27ad3c8f25d1fe2a7ab0d2ba0559fad4aee5d3d1f16771/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3", size = 2285146, upload-time = "2026-05-06T13:38:59.224Z" }, + { url = "https://files.pythonhosted.org/packages/80/50/540cd3aeefc041beb111125c4bff779831a2111fc6b15a9138cda277d32c/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4", size = 2089685, upload-time = "2026-05-06T13:38:17.762Z" }, + { url = "https://files.pythonhosted.org/packages/6b/a4/b440ad35f05f6a38f89fa0f149accb3f0e02be94ca5e15f3c449a61b4bc9/pydantic_core-2.46.4-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398", size = 2115420, upload-time = "2026-05-06T13:37:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/99/61/de4f55db8dfd57bfdfa9a12ec90fe1b57c4f41062f7ca86f08586b3e0ac0/pydantic_core-2.46.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3", size = 2165122, upload-time = "2026-05-06T13:37:01.167Z" }, + { url = "https://files.pythonhosted.org/packages/f7/52/7c529d7bdb2d1068bd52f51fe32572c8301f9a4febf1948f10639f1436f5/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848", size = 2182573, upload-time = "2026-05-06T13:38:45.04Z" }, + { url = "https://files.pythonhosted.org/packages/37/b3/7c40325848ba78247f2812dcf9c7274e38cd801820ca6dd9fe63bcfb0eb4/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3", size = 2317139, upload-time = "2026-05-06T13:37:15.539Z" }, + { url = "https://files.pythonhosted.org/packages/d9/37/f913f81a657c865b75da6c0dbed79876073c2a43b5bd9edbe8da785e4d49/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109", size = 2360433, upload-time = "2026-05-06T13:37:30.099Z" }, + { url = "https://files.pythonhosted.org/packages/c4/67/6acaa1be2567f9256b056d8477158cac7240813956ce86e49deae8e173b4/pydantic_core-2.46.4-cp311-cp311-win32.whl", hash = "sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda", size = 1985513, upload-time = "2026-05-06T13:38:15.669Z" }, + { url = "https://files.pythonhosted.org/packages/aa/e6/c505f83dfeda9a2e5c995cfd872949e4d05e12f7feb3dca72f633daefa94/pydantic_core-2.46.4-cp311-cp311-win_amd64.whl", hash = "sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33", size = 2071114, upload-time = "2026-05-06T13:40:35.416Z" }, + { url = "https://files.pythonhosted.org/packages/0f/da/7a263a96d965d9d0df5e8de8a475f33495451117035b09acb110288c381f/pydantic_core-2.46.4-cp311-cp311-win_arm64.whl", hash = "sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d", size = 2044298, upload-time = "2026-05-06T13:38:29.754Z" }, + { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" }, + { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" }, + { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" }, + { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" }, + { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" }, + { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" }, + { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" }, + { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" }, + { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" }, + { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" }, + { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" }, + { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" }, + { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" }, + { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" }, + { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" }, + { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" }, + { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" }, + { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" }, + { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" }, + { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" }, + { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" }, + { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" }, + { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" }, + { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" }, + { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" }, + { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" }, + { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" }, + { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" }, + { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" }, + { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" }, + { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" }, + { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" }, + { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" }, + { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" }, + { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" }, + { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" }, + { url = "https://files.pythonhosted.org/packages/ee/a4/73995fd4ebbb46ba0ee51e6fa049b8f02c40daebb762208feda8a6b7894d/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c", size = 2111589, upload-time = "2026-05-06T13:37:10.817Z" }, + { url = "https://files.pythonhosted.org/packages/fb/7f/f37d3a5e8bfcc2e403f5c57a730f2d815693fb42119e8ea48b3789335af1/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b", size = 1944552, upload-time = "2026-05-06T13:36:56.717Z" }, + { url = "https://files.pythonhosted.org/packages/15/3c/d7eb777b3ff43e8433a4efb39a17aa8fd98a4ee8561a24a67ef5db07b2d6/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b", size = 1982984, upload-time = "2026-05-06T13:39:06.207Z" }, + { url = "https://files.pythonhosted.org/packages/63/87/70b9f40170a81afd55ca26c9b2acb25c20d64bcfbf888fafecb3ba077d4c/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea", size = 2138417, upload-time = "2026-05-06T13:39:45.476Z" }, + { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" }, + { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" }, + { url = "https://files.pythonhosted.org/packages/11/cb/428de0385b6c8d44b716feba566abfacfbd23ee3c4439faa789a1456242f/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0", size = 2112782, upload-time = "2026-05-06T13:37:04.016Z" }, + { url = "https://files.pythonhosted.org/packages/0b/b5/6a17bdadd0fc1f170adfd05a20d37c832f52b117b4d9131da1f41bb097ce/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7", size = 1952146, upload-time = "2026-05-06T13:39:43.092Z" }, + { url = "https://files.pythonhosted.org/packages/2a/dc/03734d80e362cd43ef65428e9de77c730ce7f2f11c60d2b1e1b39f0fbf99/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2", size = 2134492, upload-time = "2026-05-06T13:36:58.124Z" }, + { url = "https://files.pythonhosted.org/packages/de/df/5e5ffc085ed07cc22d298134d3d911c63e91f6a0eb91fe646750a3209910/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9", size = 2156604, upload-time = "2026-05-06T13:37:49.88Z" }, + { url = "https://files.pythonhosted.org/packages/81/44/6e112a4253e56f5705467cbab7ab5e91ee7398ba3d56d358635958893d3e/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf", size = 2183828, upload-time = "2026-05-06T13:37:43.053Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ad/5565071e937d8e752842ac241463944c9eb14c87e2d269f2658a5bd05e98/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30", size = 2310000, upload-time = "2026-05-06T13:37:56.694Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c3/66883a5cec183e7fba4d024b4cbbe61851a63750ef606b0afecc46d1f2bf/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc", size = 2361286, upload-time = "2026-05-06T13:40:05.667Z" }, + { url = "https://files.pythonhosted.org/packages/4b/2d/69abac8f838090bbecd5df894befb2c2619e7996a98ddb949db9f3b93225/pydantic_core-2.46.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983", size = 2193071, upload-time = "2026-05-06T13:38:08.682Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pypdf" +version = "6.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/58/6dd97d78a4b17a7a6b9d1c6ad23895abc41f0fdc49c553cc05bdfdcc36d0/pypdf-6.11.0.tar.gz", hash = "sha256:062b51c81b0910e6d2755e99e1c5547a0a23b7d0a32322af66240d8edcfabe87", size = 6453975, upload-time = "2026-05-09T13:26:48.955Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/b1/68feb7eb3b99f0c020b414234825f4a5d70e0126c18d933770e8c93a35fc/pypdf-6.11.0-py3-none-any.whl", hash = "sha256:769394d5756d5b304c9b6bef88b54b1816b328e7e6fc9254e625529a15ed4ab8", size = 338819, upload-time = "2026-05-09T13:26:46.904Z" }, +] + +[[package]] +name = "pypdfium2" +version = "5.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/d0/c81d3a7c2a9af37b817ace1de0acd40cf44d15f12407c5e86b3668364a5c/pypdfium2-5.14.0.tar.gz", hash = "sha256:c5f009b3157f10e97dceb55963f5910eff92feb00587ba10a76f12b87ce1a4b6", size = 376498, upload-time = "2026-10-04T15:19:19.835Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/03/79e89eac9d811e83d606342e129f5f39e168442ddf23b024fea4a7ee4762/pypdfium2-5.14.0-py3-none-android_23_arm64_v8a.whl", hash = "sha256:bed597b2cea3990164e43f9003f71db18959d0abd5d73adc9c176e7be2d84b98", size = 3453370, upload-time = "2026-10-04T15:18:40.79Z" }, + { url = "https://files.pythonhosted.org/packages/cc/68/369b80e408017b18eaecaa3c730bded07d90bfb65562215df200b56fb8e2/pypdfium2-5.14.0-py3-none-android_23_armeabi_v7a.whl", hash = "sha256:1951f0aed469150b13c62eabd501a9839e608ab9983ca8579be9eb73213b72b6", size = 2889924, upload-time = "2026-10-04T15:18:42.825Z" }, + { url = "https://files.pythonhosted.org/packages/d1/ea/14673bc9d8b7beeaa1eb46e9951b22543edaf2a4676c586e3b1e032ff6ee/pypdfium2-5.14.0-py3-none-macosx_13_0_arm64.whl", hash = "sha256:2de384df66ba55fcaab0775f30f28ec1090af3dfa60276a07821efc96d993118", size = 3542294, upload-time = "2026-10-04T15:18:44.345Z" }, + { url = "https://files.pythonhosted.org/packages/a6/11/b720097b01fa0874854f2f6669cbea4e4ea4e075769687714fac64d68964/pypdfium2-5.14.0-py3-none-macosx_13_0_x86_64.whl", hash = "sha256:e4e203ea9710fd00e5448edb6f1615dc8587035357f75f40b432dde0c33e8da1", size = 3735845, upload-time = "2026-10-04T15:18:45.975Z" }, + { url = "https://files.pythonhosted.org/packages/92/b4/0c31aa51887cd6cd032191dfe010a6d01ed43cf03204cfbd2184ebe4b715/pypdfium2-5.14.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1b696e6901e16f114a2ec6332e5e3f8f5033a901614ead28499ab18ca6024f5", size = 3719672, upload-time = "2026-10-04T15:18:47.455Z" }, + { url = "https://files.pythonhosted.org/packages/93/a8/ae6ef96bf66559328d07b9e402ea704352ea00c49b6a73573da57e1fb378/pypdfium2-5.14.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:593f2c952ae3ffdca0efcbb3d9464fbccb876254386114ff900cabef21157c3f", size = 3435593, upload-time = "2026-10-04T15:18:49.131Z" }, + { url = "https://files.pythonhosted.org/packages/59/ff/a78405fab4c8bad0ec25b49c5efba2c85ed14609ec73645f95220560bd81/pypdfium2-5.14.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d436ee9e024f981e68f5775f5a9d115f93ea14ee6c2c6efd35dd17d83edf4942", size = 3868604, upload-time = "2026-10-04T15:18:51.304Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6e/09e9b62ab66c9acef5ad14f8a8c0d7b4d8d6ea6492e4e65b612ef146d373/pypdfium2-5.14.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f6f13bbcc5f4adabc2676e52f662c6cb375de86b314790b0ae08f3ab62eb116a", size = 4279333, upload-time = "2026-10-04T15:18:52.948Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a3/c9cc797fc8bdfb8f37b9b0f8b9d02a5fc196b2015f408d53624cab5b0519/pypdfium2-5.14.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11f281613fa22313d9c7ab89947665e84eccf8ebe40e1198a84a88352305648d", size = 3799581, upload-time = "2026-10-04T15:18:54.913Z" }, + { url = "https://files.pythonhosted.org/packages/b9/76/54355a4bbd88bdd5ed3f4405bdc345eb593df9995daf90d285cbdf5c1410/pypdfium2-5.14.0-py3-none-manylinux_2_27_s390x.manylinux_2_28_s390x.whl", hash = "sha256:51d9e9b64ebc34effaf57f9b6d4511b3f66ad3744bd1690d2cc6700853173dcf", size = 4113022, upload-time = "2026-10-04T15:18:56.774Z" }, + { url = "https://files.pythonhosted.org/packages/7d/bc/ea461961ed0e0c4866df7a5610e76f769ef468bff28cd007e2aeecc8b882/pypdfium2-5.14.0-py3-none-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:605ab9d0d4c5e223599c9065b88d16b2c1f131c807c80dea8adbb16f1433e95b", size = 4062832, upload-time = "2026-10-04T15:18:58.471Z" }, + { url = "https://files.pythonhosted.org/packages/32/30/dde99bc8cb3f8ace1d856095c2b4a29c80eecf9089b186a3b0845d0abc69/pypdfium2-5.14.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:382de7fe20d32c42993a274d7b6c555a5623a97570dfc1d2f5e0a16fe0d5d482", size = 5058436, upload-time = "2026-10-04T15:18:59.993Z" }, + { url = "https://files.pythonhosted.org/packages/ec/16/5314182dda2695fdf5bd414a450ee866087068cca4725703932770d4be04/pypdfium2-5.14.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:dbfd6deff68cc46b134acd6be380d98d694a9f018fbb622c07229225c85db389", size = 4595505, upload-time = "2026-10-04T15:19:01.835Z" }, + { url = "https://files.pythonhosted.org/packages/63/3f/474c42e726f0020095c7d5f3fb88cfd4e5d39c1361105a72899ada0ecd1b/pypdfium2-5.14.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9f4d77db5232826dd03a63481f32164331b96c21fd68f0667b2e43dbae141a93", size = 5309775, upload-time = "2026-10-04T15:19:03.564Z" }, + { url = "https://files.pythonhosted.org/packages/6b/0c/723a6cf11cff00f125310d8c2c08362dc6c100d05fff8f92285a4df1bd41/pypdfium2-5.14.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:b40a0913196a1483f0fdc22a53f8719c3aef87f1c4d8d9c38d2ad4e207500fdf", size = 5224565, upload-time = "2026-10-04T15:19:05.264Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c5/86ab02a41e77a7aa962af6545a406815aeb9abaecd9f25dec34dbc336b72/pypdfium2-5.14.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:790e2cac1641a65912b73bd7243f45195d36f1663c85a3e1a126a8f5867c82a3", size = 4704416, upload-time = "2026-10-04T15:19:07.05Z" }, + { url = "https://files.pythonhosted.org/packages/ac/de/fb75013f924c5a4dde4a4a41ec13e7495f9b80022bf35dd51baa54e05910/pypdfium2-5.14.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:09b99c8f0cb427eb17fec13c0862ed598bba34b4843df153f70fff806a2820bc", size = 5163621, upload-time = "2026-10-04T15:19:09.021Z" }, + { url = "https://files.pythonhosted.org/packages/cd/77/e59c814f10b533bc4565abe90ccef888ba29be45ada4627ebbf710961f0d/pypdfium2-5.14.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e70d87cb0577eab38f2106f9c9606b458930beef612a1b5f298772ed259f5ec0", size = 5121606, upload-time = "2026-10-04T15:19:10.609Z" }, + { url = "https://files.pythonhosted.org/packages/21/25/e067396b4bdd26c19f0997bfa3422d3975a49ceec2c59668e7599f2adcba/pypdfium2-5.14.0-py3-none-pyemscripten_2026_0_wasm32.whl", hash = "sha256:c73be14076bedebd9bcaf9b062579c95c668580043bccd29eb0db502101d5716", size = 2675501, upload-time = "2026-10-04T15:19:12.588Z" }, + { url = "https://files.pythonhosted.org/packages/7f/0c/6c21f68a57d0c4c506b9e5f72506ba91d8dde47eef699f3fd9561f7bff0e/pypdfium2-5.14.0-py3-none-win32.whl", hash = "sha256:9fd5cc94a389d50298e4d8cb79af6b9b8e0d785606e2a937725dc6e271c9c6e6", size = 3805374, upload-time = "2026-10-04T15:19:14.357Z" }, + { url = "https://files.pythonhosted.org/packages/00/dc/ca7874924c9cfd701ad53f89529968523790e70473e0b71e834668316148/pypdfium2-5.14.0-py3-none-win_amd64.whl", hash = "sha256:149fd5c6397b8df8bf7911a93506eff0be874f877afe7ac936cf5d37d21a6a06", size = 3947280, upload-time = "2026-10-04T15:19:16.302Z" }, + { url = "https://files.pythonhosted.org/packages/46/ab/35f2276deeeebb781925e2647dd88a39f8ea1a910104a0dbb28218473502/pypdfium2-5.14.0-py3-none-win_arm64.whl", hash = "sha256:eb8aeca157808f323e39ea298cc6d6c8e080c192ea2efb1ca81daa0f0ff4d095", size = 3745021, upload-time = "2026-10-04T15:19:18.276Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "wrapt" +version = "2.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2e/64/925f213fdcbb9baeb1530449ac71a4d57fc361c053d06bf78d0c5c7cd80c/wrapt-2.1.2.tar.gz", hash = "sha256:3996a67eecc2c68fd47b4e3c564405a5777367adfd9b8abb58387b63ee83b21e", size = 81678, upload-time = "2026-03-06T02:53:25.134Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/81/60c4471fce95afa5922ca09b88a25f03c93343f759aae0f31fb4412a85c7/wrapt-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:96159a0ee2b0277d44201c3b5be479a9979cf154e8c82fa5df49586a8e7679bb", size = 60666, upload-time = "2026-03-06T02:52:58.934Z" }, + { url = "https://files.pythonhosted.org/packages/6b/be/80e80e39e7cb90b006a0eaf11c73ac3a62bbfb3068469aec15cc0bc795de/wrapt-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:98ba61833a77b747901e9012072f038795de7fc77849f1faa965464f3f87ff2d", size = 61601, upload-time = "2026-03-06T02:53:00.487Z" }, + { url = "https://files.pythonhosted.org/packages/b0/be/d7c88cd9293c859fc74b232abdc65a229bb953997995d6912fc85af18323/wrapt-2.1.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:767c0dbbe76cae2a60dd2b235ac0c87c9cccf4898aef8062e57bead46b5f6894", size = 114057, upload-time = "2026-03-06T02:52:44.08Z" }, + { url = "https://files.pythonhosted.org/packages/ea/25/36c04602831a4d685d45a93b3abea61eca7fe35dab6c842d6f5d570ef94a/wrapt-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c691a6bc752c0cc4711cc0c00896fcd0f116abc253609ef64ef930032821842", size = 116099, upload-time = "2026-03-06T02:54:56.74Z" }, + { url = "https://files.pythonhosted.org/packages/5c/4e/98a6eb417ef551dc277bec1253d5246b25003cf36fdf3913b65cb7657a56/wrapt-2.1.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f3b7d73012ea75aee5844de58c88f44cf62d0d62711e39da5a82824a7c4626a8", size = 112457, upload-time = "2026-03-06T02:53:52.842Z" }, + { url = "https://files.pythonhosted.org/packages/cb/a6/a6f7186a5297cad8ec53fd7578533b28f795fdf5372368c74bd7e6e9841c/wrapt-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:577dff354e7acd9d411eaf4bfe76b724c89c89c8fc9b7e127ee28c5f7bcb25b6", size = 115351, upload-time = "2026-03-06T02:53:32.684Z" }, + { url = "https://files.pythonhosted.org/packages/97/6f/06e66189e721dbebd5cf20e138acc4d1150288ce118462f2fcbff92d38db/wrapt-2.1.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3d7b6fd105f8b24e5bd23ccf41cb1d1099796524bcc6f7fbb8fe576c44befbc9", size = 111748, upload-time = "2026-03-06T02:53:08.455Z" }, + { url = "https://files.pythonhosted.org/packages/ef/43/4808b86f499a51370fbdbdfa6cb91e9b9169e762716456471b619fca7a70/wrapt-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:866abdbf4612e0b34764922ef8b1c5668867610a718d3053d59e24a5e5fcfc15", size = 113783, upload-time = "2026-03-06T02:53:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/91/2c/a3f28b8fa7ac2cefa01cfcaca3471f9b0460608d012b693998cd61ef43df/wrapt-2.1.2-cp311-cp311-win32.whl", hash = "sha256:5a0a0a3a882393095573344075189eb2d566e0fd205a2b6414e9997b1b800a8b", size = 57977, upload-time = "2026-03-06T02:53:27.844Z" }, + { url = "https://files.pythonhosted.org/packages/3f/c3/2b1c7bd07a27b1db885a2fab469b707bdd35bddf30a113b4917a7e2139d2/wrapt-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:64a07a71d2730ba56f11d1a4b91f7817dc79bc134c11516b75d1921a7c6fcda1", size = 60336, upload-time = "2026-03-06T02:54:28.104Z" }, + { url = "https://files.pythonhosted.org/packages/ec/5c/76ece7b401b088daa6503d6264dd80f9a727df3e6042802de9a223084ea2/wrapt-2.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:b89f095fe98bc12107f82a9f7d570dc83a0870291aeb6b1d7a7d35575f55d98a", size = 58756, upload-time = "2026-03-06T02:53:16.319Z" }, + { url = "https://files.pythonhosted.org/packages/4c/b6/1db817582c49c7fcbb7df6809d0f515af29d7c2fbf57eb44c36e98fb1492/wrapt-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ff2aad9c4cda28a8f0653fc2d487596458c2a3f475e56ba02909e950a9efa6a9", size = 61255, upload-time = "2026-03-06T02:52:45.663Z" }, + { url = "https://files.pythonhosted.org/packages/a2/16/9b02a6b99c09227c93cd4b73acc3678114154ec38da53043c0ddc1fba0dc/wrapt-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6433ea84e1cfacf32021d2a4ee909554ade7fd392caa6f7c13f1f4bf7b8e8748", size = 61848, upload-time = "2026-03-06T02:53:48.728Z" }, + { url = "https://files.pythonhosted.org/packages/af/aa/ead46a88f9ec3a432a4832dfedb84092fc35af2d0ba40cd04aea3889f247/wrapt-2.1.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c20b757c268d30d6215916a5fa8461048d023865d888e437fab451139cad6c8e", size = 121433, upload-time = "2026-03-06T02:54:40.328Z" }, + { url = "https://files.pythonhosted.org/packages/3a/9f/742c7c7cdf58b59085a1ee4b6c37b013f66ac33673a7ef4aaed5e992bc33/wrapt-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79847b83eb38e70d93dc392c7c5b587efe65b3e7afcc167aa8abd5d60e8761c8", size = 123013, upload-time = "2026-03-06T02:53:26.58Z" }, + { url = "https://files.pythonhosted.org/packages/e8/44/2c3dd45d53236b7ed7c646fcf212251dc19e48e599debd3926b52310fafb/wrapt-2.1.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f8fba1bae256186a83d1875b2b1f4e2d1242e8fac0f58ec0d7e41b26967b965c", size = 117326, upload-time = "2026-03-06T02:53:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/74/e2/b17d66abc26bd96f89dec0ecd0ef03da4a1286e6ff793839ec431b9fae57/wrapt-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e3d3b35eedcf5f7d022291ecd7533321c4775f7b9cd0050a31a68499ba45757c", size = 121444, upload-time = "2026-03-06T02:54:09.5Z" }, + { url = "https://files.pythonhosted.org/packages/3c/62/e2977843fdf9f03daf1586a0ff49060b1b2fc7ff85a7ea82b6217c1ae36e/wrapt-2.1.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6f2c5390460de57fa9582bc8a1b7a6c86e1a41dfad74c5225fc07044c15cc8d1", size = 116237, upload-time = "2026-03-06T02:54:03.884Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/27fc67914e68d740bce512f11734aec08696e6b17641fef8867c00c949fc/wrapt-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7dfa9f2cf65d027b951d05c662cc99ee3bd01f6e4691ed39848a7a5fffc902b2", size = 120563, upload-time = "2026-03-06T02:53:20.412Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9f/b750b3692ed2ef4705cb305bd68858e73010492b80e43d2a4faa5573cbe7/wrapt-2.1.2-cp312-cp312-win32.whl", hash = "sha256:eba8155747eb2cae4a0b913d9ebd12a1db4d860fc4c829d7578c7b989bd3f2f0", size = 58198, upload-time = "2026-03-06T02:53:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/8e/b2/feecfe29f28483d888d76a48f03c4c4d8afea944dbee2b0cd3380f9df032/wrapt-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1c51c738d7d9faa0b3601708e7e2eda9bf779e1b601dce6c77411f2a1b324a63", size = 60441, upload-time = "2026-03-06T02:52:47.138Z" }, + { url = "https://files.pythonhosted.org/packages/44/e1/e328f605d6e208547ea9fd120804fcdec68536ac748987a68c47c606eea8/wrapt-2.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:c8e46ae8e4032792eb2f677dbd0d557170a8e5524d22acc55199f43efedd39bf", size = 58836, upload-time = "2026-03-06T02:53:22.053Z" }, + { url = "https://files.pythonhosted.org/packages/4c/7a/d936840735c828b38d26a854e85d5338894cda544cb7a85a9d5b8b9c4df7/wrapt-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:787fd6f4d67befa6fe2abdffcbd3de2d82dfc6fb8a6d850407c53332709d030b", size = 61259, upload-time = "2026-03-06T02:53:41.922Z" }, + { url = "https://files.pythonhosted.org/packages/5e/88/9a9b9a90ac8ca11c2fdb6a286cb3a1fc7dd774c00ed70929a6434f6bc634/wrapt-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4bdf26e03e6d0da3f0e9422fd36bcebf7bc0eeb55fdf9c727a09abc6b9fe472e", size = 61851, upload-time = "2026-03-06T02:52:48.672Z" }, + { url = "https://files.pythonhosted.org/packages/03/a9/5b7d6a16fd6533fed2756900fc8fc923f678179aea62ada6d65c92718c00/wrapt-2.1.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bbac24d879aa22998e87f6b3f481a5216311e7d53c7db87f189a7a0266dafffb", size = 121446, upload-time = "2026-03-06T02:54:14.013Z" }, + { url = "https://files.pythonhosted.org/packages/45/bb/34c443690c847835cfe9f892be78c533d4f32366ad2888972c094a897e39/wrapt-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16997dfb9d67addc2e3f41b62a104341e80cac52f91110dece393923c0ebd5ca", size = 123056, upload-time = "2026-03-06T02:54:10.829Z" }, + { url = "https://files.pythonhosted.org/packages/93/b9/ff205f391cb708f67f41ea148545f2b53ff543a7ac293b30d178af4d2271/wrapt-2.1.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:162e4e2ba7542da9027821cb6e7c5e068d64f9a10b5f15512ea28e954893a267", size = 117359, upload-time = "2026-03-06T02:53:03.623Z" }, + { url = "https://files.pythonhosted.org/packages/1f/3d/1ea04d7747825119c3c9a5e0874a40b33594ada92e5649347c457d982805/wrapt-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f29c827a8d9936ac320746747a016c4bc66ef639f5cd0d32df24f5eacbf9c69f", size = 121479, upload-time = "2026-03-06T02:53:45.844Z" }, + { url = "https://files.pythonhosted.org/packages/78/cc/ee3a011920c7a023b25e8df26f306b2484a531ab84ca5c96260a73de76c0/wrapt-2.1.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a9dd9813825f7ecb018c17fd147a01845eb330254dff86d3b5816f20f4d6aaf8", size = 116271, upload-time = "2026-03-06T02:54:46.356Z" }, + { url = "https://files.pythonhosted.org/packages/98/fd/e5ff7ded41b76d802cf1191288473e850d24ba2e39a6ec540f21ae3b57cb/wrapt-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6f8dbdd3719e534860d6a78526aafc220e0241f981367018c2875178cf83a413", size = 120573, upload-time = "2026-03-06T02:52:50.163Z" }, + { url = "https://files.pythonhosted.org/packages/47/c5/242cae3b5b080cd09bacef0591691ba1879739050cc7c801ff35c8886b66/wrapt-2.1.2-cp313-cp313-win32.whl", hash = "sha256:5c35b5d82b16a3bc6e0a04349b606a0582bc29f573786aebe98e0c159bc48db6", size = 58205, upload-time = "2026-03-06T02:53:47.494Z" }, + { url = "https://files.pythonhosted.org/packages/12/69/c358c61e7a50f290958809b3c61ebe8b3838ea3e070d7aac9814f95a0528/wrapt-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:f8bc1c264d8d1cf5b3560a87bbdd31131573eb25f9f9447bb6252b8d4c44a3a1", size = 60452, upload-time = "2026-03-06T02:53:30.038Z" }, + { url = "https://files.pythonhosted.org/packages/8e/66/c8a6fcfe321295fd8c0ab1bd685b5a01462a9b3aa2f597254462fc2bc975/wrapt-2.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:3beb22f674550d5634642c645aba4c72a2c66fb185ae1aebe1e955fae5a13baf", size = 58842, upload-time = "2026-03-06T02:52:52.114Z" }, + { url = "https://files.pythonhosted.org/packages/da/55/9c7052c349106e0b3f17ae8db4b23a691a963c334de7f9dbd60f8f74a831/wrapt-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0fc04bc8664a8bc4c8e00b37b5355cffca2535209fba1abb09ae2b7c76ddf82b", size = 63075, upload-time = "2026-03-06T02:53:19.108Z" }, + { url = "https://files.pythonhosted.org/packages/09/a8/ce7b4006f7218248dd71b7b2b732d0710845a0e49213b18faef64811ffef/wrapt-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a9b9d50c9af998875a1482a038eb05755dfd6fe303a313f6a940bb53a83c3f18", size = 63719, upload-time = "2026-03-06T02:54:33.452Z" }, + { url = "https://files.pythonhosted.org/packages/e4/e5/2ca472e80b9e2b7a17f106bb8f9df1db11e62101652ce210f66935c6af67/wrapt-2.1.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2d3ff4f0024dd224290c0eabf0240f1bfc1f26363431505fb1b0283d3b08f11d", size = 152643, upload-time = "2026-03-06T02:52:42.721Z" }, + { url = "https://files.pythonhosted.org/packages/36/42/30f0f2cefca9d9cbf6835f544d825064570203c3e70aa873d8ae12e23791/wrapt-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3278c471f4468ad544a691b31bb856374fbdefb7fee1a152153e64019379f015", size = 158805, upload-time = "2026-03-06T02:54:25.441Z" }, + { url = "https://files.pythonhosted.org/packages/bb/67/d08672f801f604889dcf58f1a0b424fe3808860ede9e03affc1876b295af/wrapt-2.1.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a8914c754d3134a3032601c6984db1c576e6abaf3fc68094bb8ab1379d75ff92", size = 145990, upload-time = "2026-03-06T02:53:57.456Z" }, + { url = "https://files.pythonhosted.org/packages/68/a7/fd371b02e73babec1de6ade596e8cd9691051058cfdadbfd62a5898f3295/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ff95d4264e55839be37bafe1536db2ab2de19da6b65f9244f01f332b5286cfbf", size = 155670, upload-time = "2026-03-06T02:54:55.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/2d/9fe0095dfdb621009f40117dcebf41d7396c2c22dca6eac779f4c007b86c/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:76405518ca4e1b76fbb1b9f686cff93aebae03920cc55ceeec48ff9f719c5f67", size = 144357, upload-time = "2026-03-06T02:54:24.092Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b6/ec7b4a254abbe4cde9fa15c5d2cca4518f6b07d0f1b77d4ee9655e30280e/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c0be8b5a74c5824e9359b53e7e58bef71a729bacc82e16587db1c4ebc91f7c5a", size = 150269, upload-time = "2026-03-06T02:53:31.268Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6b/2fabe8ebf148f4ee3c782aae86a795cc68ffe7d432ef550f234025ce0cfa/wrapt-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:f01277d9a5fc1862f26f7626da9cf443bebc0abd2f303f41c5e995b15887dabd", size = 59894, upload-time = "2026-03-06T02:54:15.391Z" }, + { url = "https://files.pythonhosted.org/packages/ca/fb/9ba66fc2dedc936de5f8073c0217b5d4484e966d87723415cc8262c5d9c2/wrapt-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:84ce8f1c2104d2f6daa912b1b5b039f331febfeee74f8042ad4e04992bd95c8f", size = 63197, upload-time = "2026-03-06T02:54:41.943Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1c/012d7423c95d0e337117723eb8ecf73c622ce15a97847e84cf3f8f26cd7e/wrapt-2.1.2-cp313-cp313t-win_arm64.whl", hash = "sha256:a93cd767e37faeddbe07d8fc4212d5cba660af59bdb0f6372c93faaa13e6e679", size = 60363, upload-time = "2026-03-06T02:54:48.093Z" }, + { url = "https://files.pythonhosted.org/packages/39/25/e7ea0b417db02bb796182a5316398a75792cd9a22528783d868755e1f669/wrapt-2.1.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1370e516598854e5b4366e09ce81e08bfe94d42b0fd569b88ec46cc56d9164a9", size = 61418, upload-time = "2026-03-06T02:53:55.706Z" }, + { url = "https://files.pythonhosted.org/packages/ec/0f/fa539e2f6a770249907757eaeb9a5ff4deb41c026f8466c1c6d799088a9b/wrapt-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6de1a3851c27e0bd6a04ca993ea6f80fc53e6c742ee1601f486c08e9f9b900a9", size = 61914, upload-time = "2026-03-06T02:52:53.37Z" }, + { url = "https://files.pythonhosted.org/packages/53/37/02af1867f5b1441aaeda9c82deed061b7cd1372572ddcd717f6df90b5e93/wrapt-2.1.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:de9f1a2bbc5ac7f6012ec24525bdd444765a2ff64b5985ac6e0692144838542e", size = 120417, upload-time = "2026-03-06T02:54:30.74Z" }, + { url = "https://files.pythonhosted.org/packages/c3/b7/0138a6238c8ba7476c77cf786a807f871672b37f37a422970342308276e7/wrapt-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:970d57ed83fa040d8b20c52fe74a6ae7e3775ae8cff5efd6a81e06b19078484c", size = 122797, upload-time = "2026-03-06T02:54:51.539Z" }, + { url = "https://files.pythonhosted.org/packages/e1/ad/819ae558036d6a15b7ed290d5b14e209ca795dd4da9c58e50c067d5927b0/wrapt-2.1.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3969c56e4563c375861c8df14fa55146e81ac11c8db49ea6fb7f2ba58bc1ff9a", size = 117350, upload-time = "2026-03-06T02:54:37.651Z" }, + { url = "https://files.pythonhosted.org/packages/8b/2d/afc18dc57a4600a6e594f77a9ae09db54f55ba455440a54886694a84c71b/wrapt-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:57d7c0c980abdc5f1d98b11a2aa3bb159790add80258c717fa49a99921456d90", size = 121223, upload-time = "2026-03-06T02:54:35.221Z" }, + { url = "https://files.pythonhosted.org/packages/b9/5b/5ec189b22205697bc56eb3b62aed87a1e0423e9c8285d0781c7a83170d15/wrapt-2.1.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:776867878e83130c7a04237010463372e877c1c994d449ca6aaafeab6aab2586", size = 116287, upload-time = "2026-03-06T02:54:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/f7/2d/f84939a7c9b5e6cdd8a8d0f6a26cabf36a0f7e468b967720e8b0cd2bdf69/wrapt-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fab036efe5464ec3291411fabb80a7a39e2dd80bae9bcbeeca5087fdfa891e19", size = 119593, upload-time = "2026-03-06T02:54:16.697Z" }, + { url = "https://files.pythonhosted.org/packages/0b/fe/ccd22a1263159c4ac811ab9374c061bcb4a702773f6e06e38de5f81a1bdc/wrapt-2.1.2-cp314-cp314-win32.whl", hash = "sha256:e6ed62c82ddf58d001096ae84ce7f833db97ae2263bff31c9b336ba8cfe3f508", size = 58631, upload-time = "2026-03-06T02:53:06.498Z" }, + { url = "https://files.pythonhosted.org/packages/65/0a/6bd83be7bff2e7efaac7b4ac9748da9d75a34634bbbbc8ad077d527146df/wrapt-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:467e7c76315390331c67073073d00662015bb730c566820c9ca9b54e4d67fd04", size = 60875, upload-time = "2026-03-06T02:53:50.252Z" }, + { url = "https://files.pythonhosted.org/packages/6c/c0/0b3056397fe02ff80e5a5d72d627c11eb885d1ca78e71b1a5c1e8c7d45de/wrapt-2.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:da1f00a557c66225d53b095a97eace0fc5349e3bfda28fa34ffae238978ee575", size = 59164, upload-time = "2026-03-06T02:53:59.128Z" }, + { url = "https://files.pythonhosted.org/packages/71/ed/5d89c798741993b2371396eb9d4634f009ff1ad8a6c78d366fe2883ea7a6/wrapt-2.1.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:62503ffbc2d3a69891cf29beeaccdb4d5e0a126e2b6a851688d4777e01428dbb", size = 63163, upload-time = "2026-03-06T02:52:54.873Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8c/05d277d182bf36b0a13d6bd393ed1dec3468a25b59d01fba2dd70fe4d6ae/wrapt-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c7e6cd120ef837d5b6f860a6ea3745f8763805c418bb2f12eeb1fa6e25f22d22", size = 63723, upload-time = "2026-03-06T02:52:56.374Z" }, + { url = "https://files.pythonhosted.org/packages/f4/27/6c51ec1eff4413c57e72d6106bb8dec6f0c7cdba6503d78f0fa98767bcc9/wrapt-2.1.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3769a77df8e756d65fbc050333f423c01ae012b4f6731aaf70cf2bef61b34596", size = 152652, upload-time = "2026-03-06T02:53:23.79Z" }, + { url = "https://files.pythonhosted.org/packages/db/4c/d7dd662d6963fc7335bfe29d512b02b71cdfa23eeca7ab3ac74a67505deb/wrapt-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a76d61a2e851996150ba0f80582dd92a870643fa481f3b3846f229de88caf044", size = 158807, upload-time = "2026-03-06T02:53:35.742Z" }, + { url = "https://files.pythonhosted.org/packages/b4/4d/1e5eea1a78d539d346765727422976676615814029522c76b87a95f6bcdd/wrapt-2.1.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6f97edc9842cf215312b75fe737ee7c8adda75a89979f8e11558dfff6343cc4b", size = 146061, upload-time = "2026-03-06T02:52:57.574Z" }, + { url = "https://files.pythonhosted.org/packages/89/bc/62cabea7695cd12a288023251eeefdcb8465056ddaab6227cb78a2de005b/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4006c351de6d5007aa33a551f600404ba44228a89e833d2fadc5caa5de8edfbf", size = 155667, upload-time = "2026-03-06T02:53:39.422Z" }, + { url = "https://files.pythonhosted.org/packages/e9/99/6f2888cd68588f24df3a76572c69c2de28287acb9e1972bf0c83ce97dbc1/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:a9372fc3639a878c8e7d87e1556fa209091b0a66e912c611e3f833e2c4202be2", size = 144392, upload-time = "2026-03-06T02:54:22.41Z" }, + { url = "https://files.pythonhosted.org/packages/40/51/1dfc783a6c57971614c48e361a82ca3b6da9055879952587bc99fe1a7171/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3144b027ff30cbd2fca07c0a87e67011adb717eb5f5bd8496325c17e454257a3", size = 150296, upload-time = "2026-03-06T02:54:07.848Z" }, + { url = "https://files.pythonhosted.org/packages/6c/38/cbb8b933a0201076c1f64fc42883b0023002bdc14a4964219154e6ff3350/wrapt-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:3b8d15e52e195813efe5db8cec156eebe339aaf84222f4f4f051a6c01f237ed7", size = 60539, upload-time = "2026-03-06T02:54:00.594Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/e5176e4b241c9f528402cebb238a36785a628179d7d8b71091154b3e4c9e/wrapt-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:08ffa54146a7559f5b8df4b289b46d963a8e74ed16ba3687f99896101a3990c5", size = 63969, upload-time = "2026-03-06T02:54:39Z" }, + { url = "https://files.pythonhosted.org/packages/5c/99/79f17046cf67e4a95b9987ea129632ba8bcec0bc81f3fb3d19bdb0bd60cd/wrapt-2.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:72aaa9d0d8e4ed0e2e98019cea47a21f823c9dd4b43c7b77bba6679ffcca6a00", size = 60554, upload-time = "2026-03-06T02:53:14.132Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c7/8528ac2dfa2c1e6708f647df7ae144ead13f0a31146f43c7264b4942bf12/wrapt-2.1.2-py3-none-any.whl", hash = "sha256:b8fd6fa2b2c4e7621808f8c62e8317f4aae56e59721ad933bac5239d913cf0e8", size = 43993, upload-time = "2026-03-06T02:53:12.905Z" }, +]