Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

feat(model-hub): web_fetch local engine behind the flag (WF-2G) (#2962)

Call White73f1639102b8
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index f861ddab3..1b397a642 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -110,6 +110,48 @@ jobs:
pip install pre-commit
pre-commit run --all-files
+ web-fetch-runtime:
+ needs: [changes, build-linux-artifacts]
+ if: needs.changes.outputs.docs_only == 'false'
+ runs-on: ${{ matrix.os }}
+ timeout-minutes: 15
+ strategy:
+ fail-fast: false
+ matrix:
+ include:
+ - {os: ubuntu-latest, python: "3.10"}
+ - {os: ubuntu-latest, python: "3.11"}
+ - {os: ubuntu-latest, python: "3.12"}
+ - {os: ubuntu-latest, python: "3.13"}
+ - {os: ubuntu-latest, python: "3.14"}
+ - {os: ubuntu-24.04-arm, python: "3.12"}
+ - {os: macos-15-intel, python: "3.12"}
+ - {os: macos-15, python: "3.12"}
+ - {os: windows-latest, python: "3.12"}
+ defaults:
+ run:
+ shell: bash
+ steps:
+ - uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5
+ - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+ with:
+ python-version: ${{ matrix.python }}
+ - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8
+ with:
+ name: vibe-wheel-linux
+ path: dist
+ - name: Install frozen binary dependencies and wheel
+ run: |
+ python -m pip install --disable-pip-version-check --only-binary=:all: --no-deps uv==0.12.10
+ uv export --frozen --no-dev --no-emit-project --output-file fetch-requirements.txt
+ uv pip install --system --require-hashes --only-binary=:all: --no-binary claude-agent-sdk --no-binary http-ece -r fetch-requirements.txt
+ uv pip install --system --no-deps dist/*.whl
+ uv pip install --system pytest pytest-asyncio jsonschema
+ python -c "from pathlib import Path; p=Path('ui/dist'); p.mkdir(parents=True,exist_ok=True); (p/'index.html').touch()"
+ - name: Verify native resources, pinned transports and disposable workers offline
+ run: |
+ python -m pytest -q tests/test_model_hub_fetch_policy.py tests/test_model_hub_fetch_transport.py tests/test_model_hub_fetch_tls.py tests/test_model_hub_local_fetch.py tests/test_desktop_runtime_bundle_builder.py -k 'not packaged_cli_survives'
+
ui-checks:
needs: changes
if: needs.changes.outputs.docs_only == 'false'
diff --git a/core/handlers/model_hub/local_fetch.py b/core/handlers/model_hub/local_fetch.py
new file mode 100644
index 000000000..591b20cca
--- /dev/null
+++ b/core/handlers/model_hub/local_fetch.py
@@ -0,0 +1,278 @@
+"""Dormant local fetch: disposable workers, bounded admission and host health.
+
+The mandatory gate has independent capacity. Fetch workers start only after
+atomic host/worker admission; queued calls own neither a process nor a host.
+"""
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import os
+import sys
+import tempfile
+import time
+from collections import OrderedDict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable
+
+import psutil
+
+from .async_owner import await_owned_task
+from core.web_fetch_worker.policy import FetchFailure, parse_url
+from .retry import retry_after_deadline
+
+
+_WORKER = "import sys; sys.path.insert(0, sys.argv.pop(1)); from core.web_fetch_worker.worker import main; main()"
+_MEMORY_LIMIT = 768 * 1024 * 1024
+_IPC_LIMIT = 1200000
+_WORKERS = 8
+
+
+class LocalFetchEngine:
+ def __init__(self):
+ self._hosts: set[str] = set()
+ self._workers = {"gate": 0, "fetch": 0}
+ self._changed = asyncio.Event()
+ self._cooldowns = OrderedDict()
+
+ def _notify(self):
+ previous, self._changed = self._changed, asyncio.Event()
+ previous.set()
+
+ async def _admit(self, operation, host, state):
+ state["waiting"] = True
+ while self._workers[operation] >= _WORKERS or (operation == "fetch" and host in self._hosts):
+ await self._changed.wait()
+ # No await between checking and claiming: no host is held by a call
+ # waiting for capacity, so redirects cannot deadlock with that waiter.
+ self._workers[operation] += 1
+ state["slot"] = True
+ if operation == "fetch":
+ self._hosts.add(host)
+ state["held_host"] = host
+ state["waiting"] = False
+
+ async def _change_host(self, host, state):
+ if host != state["held_host"]:
+ if state["held_host"]:
+ self._hosts.discard(state["held_host"])
+ state["held_host"] = None
+ self._notify()
+ state["waiting"] = True
+ while host in self._hosts:
+ await self._changed.wait()
+ self._hosts.add(host)
+ state["held_host"] = host
+ state["waiting"] = False
+ state["host"] = host
+
+ def _release(self, operation, state):
+ if state["held_host"]:
+ self._hosts.discard(state["held_host"])
+ state["held_host"] = None
+ if state["slot"]:
+ self._workers[operation] -= 1
+ state["slot"] = False
+ self._notify()
+
+ async def check(self, url: str, *, deadline: float) -> str:
+ """Mandatory gate, also when local fetching is disabled or reordered."""
+ address = parse_url(url)
+ result = await self._run("gate", address.url, deadline=min(deadline, time.monotonic() + 5))
+ if result.get("error_code"):
+ code = result["error_code"]
+ raise FetchFailure(code if code in {"fetch_url_blocked", "service_busy"} else "fetch_dns_unverified", terminal=True)
+ return result["url"]
+
+ async def fetch(self, url: str, *, deadline: float, locale: str = "en", on_sent: Callable | None = None) -> dict:
+ address = parse_url(url)
+ return await self._run("fetch", address.url, deadline=min(deadline, time.monotonic() + 30),
+ locale=locale, on_sent=on_sent)
+
+ @staticmethod
+ def _failure(state, code):
+ if state["operation"] == "gate":
+ return {"error_code": "service_busy" if state["waiting"] else "fetch_dns_unverified", "terminal": True}
+ if code == "fetch_timeout" and (state["waiting"] or state["phase"] in {"policy", "admission"}):
+ # Budget spent on admission/revalidation is not a DNS failure and
+ # cannot cool a host. The chain must gate the ORIGINAL URL again.
+ return {"error_code": "fetch_timeout" if state["sent"] else "service_busy", "terminal": False,
+ "cooldown_suppressed": True}
+ if state["phase"] == "policy":
+ return {"error_code": "fetch_dns_unverified", "terminal": True}
+ if state["phase"] == "extract":
+ code = "fetch_target_unreadable"
+ return {"error_code": code, "terminal": False, "cooldown_suppressed": code == "fetch_timeout"}
+
+ async def _run(self, operation, url, *, deadline, locale="en", on_sent=None):
+ state = {"operation": operation, "sent": False, "host": None, "held_host": None, "slot": False,
+ "waiting": True, "phase": "policy" if operation == "gate" else "admission"}
+ try:
+ return await self._run_owned(operation, url, state, deadline=deadline, locale=locale, on_sent=on_sent)
+ finally:
+ # Publish the settled host-health outcome before waking any waiter.
+ # Child reaping completes inside _run_owned on success/timeout/Stop.
+ self._release(operation, state)
+
+ async def _run_owned(self, operation, url, state, *, deadline, locale, on_sent):
+ invocation = asyncio.create_task(self._invoke(operation, url, locale, state, on_sent, deadline))
+
+ async def drain():
+ try:
+ await invocation
+ except asyncio.CancelledError:
+ pass # The child's cancellation is not another caller Stop.
+
+ try:
+ result = await asyncio.wait_for(asyncio.shield(invocation), timeout=max(0, deadline - time.monotonic()))
+ except asyncio.TimeoutError:
+ invocation.cancel()
+ draining = asyncio.create_task(drain())
+ try:
+ await asyncio.shield(draining)
+ except asyncio.CancelledError:
+ await await_owned_task(draining)
+ raise
+ result = self._failure(state, "fetch_timeout")
+ except asyncio.CancelledError:
+ # Python <=3.11 wait_for can abandon its inner cancellation wait
+ # on a second Stop. Own the whole invocation, not just its finally.
+ invocation.cancel()
+ try:
+ await await_owned_task(asyncio.create_task(drain()))
+ except Exception:
+ pass # Reaping owns resources; Stop owns the public outcome.
+ raise
+ if result.get("error_code") == "service_busy" and not state["sent"]:
+ result["skipped"] = "unavailable"
+ if state.get("fallback") and result.get("error_code") and not result.get("terminal"):
+ result = {**state["fallback"], "cooldown_code": result["error_code"],
+ "cooldown_suppressed": result.get("cooldown_suppressed", False),
+ "retry_after": result.get("retry_after"), **({"skipped": result["skipped"]} if result.get("skipped") else {})}
+ for field in ("follow_url", "follow_kind"):
+ result.pop(field, None)
+ result["sent"] = state["sent"]
+ result.update(state.get("transport", {}))
+ host = state["host"]
+ cooldown_code = result.pop("cooldown_code", None) or result.get("error_code")
+ suppressed = result.pop("cooldown_suppressed", False)
+ retry_after = result.pop("retry_after", None)
+ if host and not result.get("skipped") and not suppressed:
+ now = datetime.now(timezone.utc)
+ if cooldown_code in {"fetch_timeout", "fetch_unavailable", "service_rate_limited"}:
+ deadline_at = retry_after_deadline(retry_after, now)
+ previous = self._cooldowns.get(host, (0, 0))
+ backoff = min(300, max(30, previous[1] * 2))
+ until = max(now.timestamp() + backoff, deadline_at.timestamp() if deadline_at else 0)
+ self._cooldowns[host] = (until, backoff)
+ self._cooldowns.move_to_end(host)
+ while len(self._cooldowns) > 1024:
+ self._cooldowns.popitem(last=False)
+ result["retry_at"] = datetime.fromtimestamp(until, timezone.utc).isoformat()
+ elif not result.get("error_code"):
+ self._cooldowns.pop(host, None)
+ if not result.get("error_code"):
+ result.pop("skipped", None)
+ return result
+
+ async def _invoke(self, operation, url, locale, state, on_sent, deadline):
+ process = monitor = reader = None
+ await self._admit(operation, parse_url(url).host, state)
+ with tempfile.TemporaryDirectory(prefix="avibe-fetch-") as home:
+ environment = {key: os.environ[key] for key in ("SystemRoot", "WINDIR") if key in os.environ}
+ environment.update(HOME=home, USERPROFILE=home, TMPDIR=home, TMP=home, TEMP=home,
+ XDG_CONFIG_HOME=home, XDG_CACHE_HOME=home)
+ spawning = asyncio.create_task(asyncio.create_subprocess_exec(
+ sys.executable, "-I", "-B", "-c", _WORKER, str(Path(__file__).resolve().parents[3]),
+ cwd=home, env=environment, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE,
+ stderr=asyncio.subprocess.DEVNULL, limit=_IPC_LIMIT,
+ ))
+ try:
+ try:
+ process = await asyncio.shield(spawning)
+ except asyncio.CancelledError:
+ process = await await_owned_task(spawning)
+ raise
+ monitor = asyncio.create_task(self._monitor(process))
+ process.stdin.write((json.dumps({"operation": operation, "url": url, "locale": locale,
+ "remaining_seconds": max(0, deadline - time.monotonic())}) + "\n").encode())
+ await process.stdin.drain()
+ while True:
+ reader = asyncio.create_task(process.stdout.readline())
+ completed, _ = await asyncio.wait({reader, monitor}, return_when=asyncio.FIRST_COMPLETED)
+ if monitor in completed:
+ return self._failure(state, "fetch_unavailable")
+ raw = reader.result()
+ if not raw or len(raw) > _IPC_LIMIT:
+ return self._failure(state, "fetch_unavailable")
+ event = await asyncio.to_thread(json.loads, raw)
+ kind = event.get("event")
+ if kind in {"result", "failure"}:
+ return event["result"] if kind == "result" else {key: value for key, value in event.items() if key != "event"}
+ if kind == "host":
+ host = event["host"]
+ await self._change_host(host, state)
+ state["phase"] = "policy" # The worker re-resolves after this ACK.
+ until = self._cooldowns.get(host, (0, 0))[0]
+ if until > time.time():
+ return {"error_code": "fetch_unavailable", "skipped": "cooling", "terminal": False,
+ "retry_at": datetime.fromtimestamp(until, timezone.utc).isoformat()}
+ elif kind == "phase":
+ state["phase"] = event["phase"]
+ elif kind == "fallback":
+ state["fallback"] = event["result"]
+ elif kind == "transport":
+ state["transport"] = {key: event[key] for key in ("transport_degraded", "transport_degraded_reason")}
+ elif kind == "sent":
+ state["phase"] = "fetch"
+ if not state["sent"]:
+ if on_sent is not None:
+ result = on_sent()
+ if inspect.isawaitable(result):
+ await result
+ state["sent"] = True
+ else:
+ return self._failure(state, "fetch_unavailable")
+ process.stdin.write(b"ok\n")
+ await process.stdin.drain()
+ finally:
+ async def cleanup():
+ try:
+ if process is not None:
+ if process.returncode is None:
+ try:
+ process.kill()
+ except ProcessLookupError:
+ pass
+ await process.wait()
+ finally:
+ for task in (reader, monitor):
+ if task:
+ task.cancel()
+ await asyncio.gather(*(task for task in (reader, monitor) if task), return_exceptions=True)
+ # Timeout followed by Stop must not interrupt kill/reap,
+ # strand a host, or leave a monitor reading a dead PID.
+ cleaning = asyncio.create_task(cleanup())
+ try:
+ await asyncio.shield(cleaning)
+ except asyncio.CancelledError:
+ await await_owned_task(cleaning)
+ raise # Even a Stop arriving after a normal result wins.
+
+ @staticmethod
+ async def _monitor(process):
+ try:
+ child = psutil.Process(process.pid)
+ except psutil.NoSuchProcess:
+ await asyncio.Future()
+ while process.returncode is None:
+ try:
+ if (await asyncio.to_thread(child.memory_info)).rss > _MEMORY_LIMIT:
+ return
+ except psutil.NoSuchProcess:
+ await asyncio.sleep(0.1)
+ continue
+ await asyncio.sleep(0.05)
+ await asyncio.Future() # Bounded stdout, not exit timing, owns the result.
diff --git a/core/web_fetch_worker/__init__.py b/core/web_fetch_worker/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/core/web_fetch_worker/extract.py b/core/web_fetch_worker/extract.py
new file mode 100644
index 000000000..d6c30809c
--- /dev/null
+++ b/core/web_fetch_worker/extract.py
@@ -0,0 +1,304 @@
+"""Bounded page extraction, used only in a resource-limited disposable process."""
+from __future__ import annotations
+
+import codecs
+import io
+import json
+import re
+from dataclasses import asdict, dataclass
+from html.parser import HTMLParser
+from urllib.parse import urljoin, urlsplit
+
+from .policy import FetchFailure, metadata_url, parse_url
+
+
+@dataclass
+class Page:
+ content: str
+ content_type: str
+ source_content_type: str
+ title: str | None = None
+ canonical_url: str | None = None
+ follow_url: str | None = None
+ follow_kind: str | None = None
+ charset_fallback: bool = False
+ content_overflow: bool = False
+
+ def payload(self) -> dict:
+ return asdict(self)
+
+
+def _decode(data: bytes, content_type: str) -> tuple[str, bool]:
+ if data.startswith((codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)):
+ return data.decode("utf-32", errors="replace"), False
+ if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
+ return data.decode("utf-16", errors="replace"), False
+ if data.startswith(codecs.BOM_UTF8):
+ return data.decode("utf-8-sig", errors="replace"), False
+ encodings = re.findall(r'charset\s*=\s*[\"\']?([a-zA-Z0-9_.-]+)', content_type, flags=re.I)
+ # Only a bounded HTML prefix may declare a meta charset.
+ if "html" in content_type.lower():
+ for tag in re.findall(rb"<meta\b[^>]{0,1024}>", data[:8192], flags=re.I):
+ encodings += re.findall(r'charset\s*=\s*[\"\']?([a-zA-Z0-9_.-]+)', tag.decode("ascii", "ignore"), flags=re.I)
+ for encoding in encodings:
+ try:
+ codec = codecs.lookup(encoding)
+ # Refuse non-text transforms (e.g. base64) and stateful escape codecs.
+ if codec.name.startswith(("utf-", "iso8859", "cp", "windows", "shift_jis", "euc", "gb", "big5", "ascii", "latin")):
+ return data.decode(encoding, errors="replace"), False
+ except (LookupError, UnicodeError):
+ pass
+ try:
+ return data.decode("utf-8"), False
+ except UnicodeError:
+ return data.decode("utf-8", errors="replace"), True
+
+
+def quoted_text(text: str) -> tuple[str, bool]:
+ """Keep literal text/PDF/JSON intact; never parse it as Markdown or HTML."""
+ overflow = len(text) > 48000
+ text = text[:48000]
+ choices = [(max((len(m.group()) for m in re.finditer(re.escape(char) + "+", text)), default=0), char)
+ for char in ("`", "~")]
+ longest, char = min(choices)
+ fence = char * max(3, longest + 1)
+ return f"{fence}\n{text}\n{fence}", overflow
+
+
+class _VisibleHTML(HTMLParser):
+ """Retain visible quotation text, never active tags or script/form contents."""
+ def __init__(self):
+ super().__init__(convert_charrefs=True)
+ self.hidden = []
+ self.parts = []
+
+ def handle_starttag(self, tag, attrs):
+ if tag in {"script", "style", "form", "iframe", "object", "embed"}:
+ self.hidden.append(tag)
+ if not self.hidden and tag in {"br", "p", "div", "details", "summary", "li", "pre", "blockquote"}:
+ self.parts.append("\n")
+
+ def handle_endtag(self, tag):
+ if tag in self.hidden:
+ del self.hidden[self.hidden.index(tag):]
+ if not self.hidden and tag in {"p", "div", "details", "summary", "li", "pre", "blockquote"}:
+ self.parts.append("\n")
+
+ def handle_data(self, data):
+ if not self.hidden:
+ self.parts.append(re.sub(r"([\\`*_[\]<>])", r"\\\1", data))
+
+ def take(self):
+ text, self.parts = "".join(self.parts), []
+ return text
+
+
+def inert_markdown(text: str, base: str) -> str:
+ """Render parsed Markdown tokens back to inert Markdown, without image loads.
+
+ Parsing instead of regex link replacement handles reference/escaped links.
+ Visible HTML text is quoted without tags, code remains quoted, and only HTTP(S) links survive.
+ """
+ from markdown_it import MarkdownIt
+
+ parser = MarkdownIt("commonmark", {"html": True})
+ tokens = parser.parse(text)
+
+ def inline(children):
+ result, links = [], []
+ html = _VisibleHTML()
+ for token in children or ():
+ if token.type == "html_inline":
+ html.feed(token.content)
+ result.append(html.take())
+ continue
+ if html.hidden:
+ continue
+ if token.type == "text":
+ # Text may itself contain syntax from an invalid/unsafe link.
+ result.append(re.sub(r"([\\`*_[\]<>])", r"\\\1", token.content))
+ elif token.type in {"softbreak", "hardbreak"}:
+ result.append("\n")
+ elif token.type == "code_inline":
+ ticks = "`" * (max((len(m.group()) for m in re.finditer(r"`+", token.content)), default=0) + 1)
+ result.append(f"{ticks} {token.content} {ticks}")
+ elif token.type in {"em_open", "em_close", "strong_open", "strong_close"}:
+ result.append(token.markup)
+ elif token.type == "link_open":
+ href = metadata_url(token.attrGet("href"), base)
+ links.append(href)
+ if href:
+ result.append("[")
+ elif token.type == "link_close":
+ href = links.pop() if links else None
+ if href:
+ result.append(f"](<{href}>)")
+ elif token.type == "image":
+ # Alt text only; no remote-image Markdown survives.
+ result.append(inline(token.children))
+ return "".join(result)
+
+ output, lists = [], []
+ for token in tokens:
+ if token.type == "inline":
+ output.append(inline(token.children))
+ elif token.type == "html_block":
+ html = _VisibleHTML()
+ html.feed(token.content)
+ output.append(html.take() + "\n\n")
+ elif token.type == "heading_open":
+ output.append("\n" + "#" * int(token.tag[1:]) + " ")
+ elif token.type in {"paragraph_close", "heading_close", "blockquote_close"}:
+ output.append("\n\n")
+ elif token.type in {"bullet_list_open", "ordered_list_open"}:
+ lists.append(int(token.attrGet("start") or 1) if token.type == "ordered_list_open" else None)
+ elif token.type in {"bullet_list_close", "ordered_list_close"}:
+ if lists:
+ lists.pop()
+ output.append("\n\n")
+ elif token.type == "list_item_open":
+ marker = "- "
+ if lists and lists[-1] is not None:
+ marker = f"{lists[-1]}. "
+ lists[-1] += 1
+ output.append("\n" + marker)
+ elif token.type == "blockquote_open":
+ output.append("\n> ")
+ elif token.type in {"fence", "code_block"}:
+ ticks = "`" * max(3, max((len(m.group()) + 1 for m in re.finditer(r"`+", token.content)), default=0))
+ output.append(f"\n{ticks}\n{token.content}\n{ticks}\n")
+ elif token.type == "hr":
+ output.append("\n---\n")
+ return "".join(output).strip()
+
+
+def _same_origin_link(value: str, base: str) -> str | None:
+ try:
+ if any(c.isspace() for c in value) or "\\" in value:
+ return None
+ candidate = parse_url(urljoin(base, value)).url
+ a, b = urlsplit(candidate), urlsplit(base)
+ origin = lambda p: (p.scheme.lower(), p.hostname, p.port or (443 if p.scheme == "https" else 80))
+ if origin(a) == origin(b) and not a.username and not a.password and len(candidate) <= 8192:
+ return candidate
+ except (ValueError, FetchFailure):
+ pass
+ return None
+
+
+def extract_page(data: bytes, content_type: str, url: str) -> Page:
+ mime = content_type.partition(";")[0].strip().lower()
+ if mime == "application/pdf":
+ from pypdf import PdfReader
+
+ try:
+ pdf = PdfReader(io.BytesIO(data), strict=False)
+ if pdf.is_encrypted:
+ raise FetchFailure("fetch_target_unreadable")
+ parts, total, overflow = [], 0, False
+ for number, page in enumerate(pdf.pages, 1):
+ text = page.extract_text() or ""
+ if text.strip():
+ parts.append(f"[Page {number}]\n{text}")
+ total += len(text)
+ if total > 48000:
+ overflow = True
+ break
+ content = "\n\n---\n\n".join(parts)
+ title = str(pdf.metadata.title)[:300] if pdf.metadata and pdf.metadata.title else None
+ except FetchFailure:
+ raise
+ except Exception:
+ raise FetchFailure("fetch_target_unreadable") from None
+ if not content.strip():
+ raise FetchFailure("fetch_target_unreadable")
+ # Plain text is fenced so PDF text cannot create active markup.
+ content, cut = quoted_text(content)
+ return Page(content, "text/markdown", mime, title=title, content_overflow=overflow or cut)
+ if mime not in {"text/html", "application/xhtml+xml", "text/markdown", "text/plain", "application/json"} and not mime.endswith("+json"):
+ raise FetchFailure("fetch_unsupported_content")
+ text, fallback = _decode(data, content_type)
+ if "\x00" in text:
+ raise FetchFailure("fetch_unsupported_content")
+ if not text.strip():
+ raise FetchFailure("fetch_target_unreadable")
+ if mime in {"text/html", "application/xhtml+xml"}:
+ import trafilatura
+ from lxml import etree, html
+
+ # lxml's Unicode parser rejects an XML encoding declaration even though
+ # decoding has already honored the HTTP/BOM/meta encoding above.
+ text = re.sub(r"^\s*<\?xml\b[^?]{0,1024}\?>", "", text, count=1, flags=re.I)
+ try:
+ tree = html.fromstring(text, parser=html.HTMLParser(no_network=True, recover=True, remove_comments=True))
+ except (ValueError, TypeError, etree.ParserError):
+ raise FetchFailure("fetch_target_unreadable") from None
+ titles = tree.xpath("//title/text()")
+ title = titles[0].strip()[:300] if titles else None
+ # Structural challenge/login evidence, not phrases in article text.
+ # A login widget beside readable public content is NOT a login wall.
+ password_forms = tree.xpath('//form[.//input[translate(@type,"PASSWORD","password")="password"]]')
+ has_password_form = bool(password_forms)
+ main_login = any(not form.xpath("ancestor::header|ancestor::nav|ancestor::aside") for form in password_forms)
+ if tree.xpath('//*[@id="challenge-form" or @id="cf-challenge-running" or @id="cf-spinner-please-wait"]'):
+ raise FetchFailure("fetch_challenge")
+ page = Page("", "text/markdown", mime, title=title, charset_fallback=fallback)
+ canonical = tree.xpath('//link[contains(concat(" ",normalize-space(@rel)," ")," canonical ")]/@href')
+ page.canonical_url = metadata_url(canonical[0], url) if canonical else None
+ for meta in tree.xpath('//meta[translate(@http-equiv,"REFSH","refsh")="refresh"]/@content'):
+ match = re.fullmatch(r"\s*0(?:\.0+)?\s*;\s*url\s*=\s*(.*?)\s*", meta, flags=re.I)
+ if match and (follow := _same_origin_link(match[1].strip("\"'"), url)):
+ page.follow_url, page.follow_kind = follow, "refresh"
+ break
+ if page.follow_url is None:
+ alternate = tree.xpath('//link[contains(concat(" ",normalize-space(@rel)," ")," alternate ") and @type="text/markdown"]/@href')
+ if alternate and (follow := _same_origin_link(alternate[0], url)):
+ page.follow_url, page.follow_kind = follow, "alternate"
+ has_scripts = bool(tree.xpath("//script"))
+ for element in tree.xpath("//script|//style|//nav|//form|//iframe|//img|//svg|//object|//embed"):
+ element.drop_tree()
+ for anchor in tree.xpath("//*[@href]"):
+ link = metadata_url(anchor.get("href"), url)
+ if link:
+ anchor.set("href", link)
+ else:
+ anchor.attrib.pop("href", None)
+ content = trafilatura.extract(tree, output_format="markdown", include_links=True, include_images=False,
+ include_comments=False, include_tables=True, favor_recall=True) or ""
+ normalized = " ".join(content.split()).strip("# ").lower()
+ if has_scripts and not main_login and (not normalized or normalized in {
+ "loading", "loading...", "please enable javascript", "javascript is required",
+ }) and page.follow_url is None:
+ raise FetchFailure("fetch_js_shell")
+ if has_password_form and (not normalized or normalized in {
+ "sign in", "log in", "login", "please sign in", "sign in to continue", "login required", "log in to continue",
+ }):
+ raise FetchFailure("fetch_refused", terminal=True)
+ if (not normalized or (has_scripts and normalized in {"loading", "loading...", "please enable javascript", "javascript is required"})) and page.follow_url is None:
+ raise FetchFailure("fetch_js_shell" if has_scripts else "fetch_target_unreadable")
+ # Bound token construction before markdown-it, not after its allocation.
+ page.content = inert_markdown(content[:192000], url)
+ page.content_overflow = len(content) > 192000 or len(page.content) > 48000
+ page.content = page.content[:48000]
+ return page
+ if mime == "application/json" or mime.endswith("+json"):
+ try:
+ text = json.dumps(json.loads(text), ensure_ascii=False, indent=2, allow_nan=False)
+ except (ValueError, TypeError, RecursionError):
+ pass
+ content, overflow = quoted_text(text)
+ else:
+ # Recognize only an exact challenge document, never a phrase within text.
+ if text.strip().lower() in {"access denied", "just a moment...", "please enable javascript", "checking your browser..."}:
+ raise FetchFailure("fetch_challenge")
+ if not text.strip():
+ raise FetchFailure("fetch_target_unreadable")
+ if mime == "text/plain":
+ content, overflow = quoted_text(text)
+ else:
+ content = inert_markdown(text[:192000], url)
+ overflow = len(text) > 192000 or len(content) > 48000
+ content = content[:48000]
+ if not content.strip():
+ raise FetchFailure("fetch_target_unreadable")
+ return Page(content, "text/markdown", mime, charset_fallback=fallback, content_overflow=overflow)
diff --git a/core/web_fetch_worker/policy.py b/core/web_fetch_worker/policy.py
new file mode 100644
index 000000000..73c4d2761
--- /dev/null
+++ b/core/web_fetch_worker/policy.py
@@ -0,0 +1,160 @@
+"""Mandatory public-address policy shared by all web_fetch candidates.
+
+DNS is synchronous only inside the disposable fetch worker, never on the
+controller loop. A CheckedTarget is a complete answer-set snapshot, not a
+permission to resolve the hostname again at connect time.
+"""
+from __future__ import annotations
+
+import ipaddress
+import re
+import socket
+import unicodedata
+from dataclasses import dataclass
+from urllib.parse import quote, urlsplit, urlunsplit
+
+import idna
+
+
+class FetchFailure(Exception):
+ def __init__(self, code: str, *, terminal: bool = False, retry_after: str | None = None, cooldown_suppressed: bool = False):
+ super().__init__(code)
+ self.code = code
+ self.terminal = terminal
+ self.retry_after = retry_after
+ self.cooldown_suppressed = cooldown_suppressed
+
+
+# Deliberately explicit: ipaddress.is_global has changed across Python releases.
+_V4_DENY = tuple(ipaddress.ip_network(net) for net in (
+ "0.0.0.0/8", "10.0.0.0/8", "100.64.0.0/10", "127.0.0.0/8", "169.254.0.0/16",
+ "172.16.0.0/12", "192.0.0.0/24", "192.0.2.0/24", "192.88.99.0/24", "192.168.0.0/16",
+ "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24", "224.0.0.0/4", "240.0.0.0/4",
+ "168.63.129.16/32", # Azure platform virtual IP (metadata/WireServer).
+))
+_V6_GLOBAL = ipaddress.ip_network("2000::/3")
+_V6_DENY = tuple(ipaddress.ip_network(net) for net in (
+ "2001::/23", "2001:db8::/32", "2002::/16", "3fff::/20",
+))
+_DNS64 = ipaddress.ip_network("64:ff9b::/96")
+_FAKE_IP = ipaddress.ip_network("198.18.0.0/15")
+_LOCAL_SUFFIXES = (".localhost", ".local", ".localdomain", ".internal", ".lan", ".home", ".home.arpa", ".invalid", ".test")
+
+
+def checked_ip(value: str) -> str:
+ """Return a canonical permitted numeric pin; mapped IPv6 becomes IPv4."""
+ try:
+ if "%" in value:
+ raise ValueError
+ ip = ipaddress.ip_address(value)
+ except ValueError:
+ raise FetchFailure("fetch_dns_unverified", terminal=True) from None
+ if isinstance(ip, ipaddress.IPv6Address) and ip.ipv4_mapped is not None:
+ ip = ip.ipv4_mapped
+ if isinstance(ip, ipaddress.IPv4Address):
+ if ip in _FAKE_IP:
+ raise FetchFailure("fetch_dns_unverified", terminal=True)
+ allowed = not any(ip in net for net in _V4_DENY)
+ elif ip in _DNS64:
+ checked_ip(str(ipaddress.IPv4Address(int(ip) & 0xFFFFFFFF)))
+ allowed = True
+ else:
+ # ISATAP's interface identifier embeds an IPv4 next hop under an
+ # otherwise public IPv6 prefix; it must not bypass the transition ban.
+ is_isatap = ((int(ip) >> 32) & 0xFFFFFFFF) in {0x00005EFE, 0x02005EFE}
+ allowed = ip in _V6_GLOBAL and not is_isatap and not any(ip in net for net in _V6_DENY)
+ if not allowed:
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+ return str(ip)
+
+
+@dataclass(frozen=True)
+class FetchURL:
+ url: str
+ host: str
+ port: int
+ scheme: str
+ literal: bool
+
+ @property
+ def origin(self) -> tuple[str, str, int]:
+ return self.scheme, self.host, self.port
+
+
+@dataclass(frozen=True)
+class CheckedTarget:
+ address: FetchURL
+ ips: tuple[str, ...]
+
+
+def parse_url(value: str) -> FetchURL:
+ """Strict UTS #46 host normalization; never reinterpret ambiguous numbers."""
+ if (not isinstance(value, str) or not value or len(value) > 8192 or "\\" in value
+ or any(c.isspace() or unicodedata.category(c) in {"Cc", "Cf", "Cs"} for c in value)):
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+ try:
+ parts = urlsplit(value)
+ if parts.scheme.lower() not in {"http", "https"} or not parts.netloc or parts.username is not None or parts.password is not None:
+ raise ValueError
+ host = parts.hostname
+ if not host or "%" in host or parts.netloc.endswith(":"):
+ raise ValueError
+ port = parts.port or (443 if parts.scheme.lower() == "https" else 80)
+ if not 1 <= port <= 65535 or parts.port == 0:
+ raise ValueError
+ # One DNS root dot is canonical; repeated dots remain invalid.
+ host = host[:-1] if host.endswith(".") else host
+ if host.endswith("."):
+ raise ValueError
+ try:
+ literal = ipaddress.ip_address(host)
+ except ValueError:
+ literal = None
+ if literal is not None:
+ host = checked_ip(str(literal))
+ else:
+ host = idna.encode(host, uts46=True, transitional=False, std3_rules=True).decode("ascii").lower()
+ host = host[:-1] if host.endswith(".") else host
+ if ("." not in host or host == "localhost" or host.endswith(_LOCAL_SUFFIXES)
+ or re.fullmatch(r"(?:0x[0-9a-f]+|[0-9]+)(?:\.(?:0x[0-9a-f]+|[0-9]+))*", host)
+ or re.fullmatch(r"(?:[0-9]+|0x[0-9a-f]+)", host.rsplit(".", 1)[-1])):
+ raise ValueError
+ authority = f"[{host}]" if ":" in host else host
+ if parts.port is not None:
+ authority += f":{port}"
+ # Leave existing percent escapes and path/query separators untouched.
+ path = quote(parts.path or "/", safe="/%:@!$&'()*+,;=-._~")
+ query = quote(parts.query, safe="/%?:@!$&'()*+,;=-._~")
+ url = urlunsplit((parts.scheme.lower(), authority, path, query, ""))
+ if len(url) > 8192:
+ raise ValueError
+ return FetchURL(url, host, port, parts.scheme.lower(), literal is not None)
+ except (ValueError, UnicodeError, idna.IDNAError):
+ raise FetchFailure("fetch_url_blocked", terminal=True) from None
+
+
+def resolve_target(value: str) -> CheckedTarget:
+ address = parse_url(value)
+ if address.literal:
+ return CheckedTarget(address, (checked_ip(address.host),))
+ try:
+ answers = socket.getaddrinfo(address.host, address.port, type=socket.SOCK_STREAM, proto=socket.IPPROTO_TCP)
+ except OSError:
+ raise FetchFailure("fetch_dns_unverified", terminal=True) from None
+ if not answers or len(answers) > 64:
+ raise FetchFailure("fetch_dns_unverified", terminal=True)
+ # Any bad answer rejects the entire set, even when a good address came first.
+ ips = tuple(dict.fromkeys(checked_ip(answer[4][0]) for answer in answers))
+ return CheckedTarget(address, ips)
+
+
+def metadata_url(value: object, base: str | None = None) -> str | None:
+ """Provider/page-claimed metadata is syntax-checked, never DNS-verified."""
+ from urllib.parse import urljoin
+
+ if not isinstance(value, str) or not value:
+ return None
+ try:
+ return parse_url(urljoin(base, value) if base else value).url
+ except FetchFailure:
+ return None
diff --git a/core/web_fetch_worker/transport.py b/core/web_fetch_worker/transport.py
new file mode 100644
index 000000000..575a63387
--- /dev/null
+++ b/core/web_fetch_worker/transport.py
@@ -0,0 +1,406 @@
+"""Hop-scoped, pinned transports. Called only inside the disposable worker."""
+from __future__ import annotations
+
+import gzip
+import io
+import ipaddress
+import json
+import ssl
+import sys
+import time
+import zlib
+from dataclasses import dataclass, field
+from importlib.metadata import version
+from itertools import zip_longest
+from pathlib import Path
+from typing import Callable
+
+import certifi
+import httpcore
+import httpx
+
+from .policy import CheckedTarget, FetchFailure
+
+
+ACCEPT = "text/markdown, text/html;q=0.95, application/xhtml+xml;q=0.9, text/plain;q=0.8, application/json;q=0.5, */*;q=0.1"
+ENCODING = "gzip, deflate, br, zstd"
+DEGRADED_ENCODING = "gzip, deflate"
+TEXT_LIMIT = 16 * 1024 * 1024
+PDF_LIMIT = 32 * 1024 * 1024
+HEADER_LIMIT = 64 * 1024
+
+
+def browser_profile() -> dict:
+ import vibe
+
+ return json.loads((Path(vibe.__file__).parent / "data" / "web_fetch_browser.json").read_text(encoding="utf-8"))
+
+
+def request_headers(*, degraded: bool, locale: str, previous_origin: tuple | None, target: CheckedTarget) -> dict[str, str]:
+ common = {
+ "Accept": ACCEPT, "Accept-Encoding": DEGRADED_ENCODING if degraded else ENCODING,
+ "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8" if locale.startswith("zh") else "en-US,en;q=0.9",
+ }
+ if degraded:
+ return {"User-Agent": f"Avibe/{version('avibe-os')}", **common}
+ profile = browser_profile()
+ platform = profile["platforms"].get(sys.platform, profile["platforms"]["linux"])
+ headers = {
+ "sec-ch-ua": profile["sec_ch_ua"], "sec-ch-ua-mobile": "?0",
+ "sec-ch-ua-platform": f'"{platform["platform"]}"', "Upgrade-Insecure-Requests": "1",
+ "User-Agent": f'Mozilla/5.0 ({platform["ua_os"]}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
+ **common,
+ "Sec-Fetch-Site": "none" if previous_origin is None else "same-origin" if previous_origin == target.address.origin else "cross-site",
+ "Sec-Fetch-Mode": "navigate", "Sec-Fetch-User": "?1", "Sec-Fetch-Dest": "document",
+ }
+ return {key: headers[key] for key in profile["header_order"]}
+
+
+def native_available() -> tuple[bool, str | None]:
+ """Choose once, before sending. A target failure never changes transports."""
+ try:
+ from curl_cffi import Curl, __version__
+
+ profile = browser_profile()
+ if __version__ != profile["version"]:
+ return False, "native_profile_version_mismatch"
+ curl = Curl()
+ try:
+ if any(codec not in curl.version() for codec in (b" brotli/", b" zstd/")):
+ return False, "native_compression_unavailable"
+ if curl.impersonate(profile["impersonate"]) != 0:
+ return False, "native_profile_unavailable"
+ finally:
+ curl.close()
+ except (ImportError, OSError):
+ return False, "native_library_unavailable"
+ return True, None
+
+
+@dataclass
+class TransferBudget:
+ wire: int = 0
+ decoded: int = 0
+
+
+@dataclass
+class HopResponse:
+ status: int
+ headers: list[tuple[str, str]]
+ body: bytes
+
+ def header(self, name: str) -> str:
+ return next((v for k, v in reversed(self.headers) if k.lower() == name.lower()), "")
+
+
+@dataclass
+class _Receiver:
+ budget: TransferBudget
+ headers: list[tuple[str, str]] = field(default_factory=list)
+ raw: bytearray = field(default_factory=bytearray)
+ limit: int = TEXT_LIMIT
+ status: int | None = None
+ headers_complete: bool = False
+ header_bytes: int = 0
+ native_decoded: bool = False
+
+ def header(self, data: bytes) -> int:
+ self.header_bytes += len(data)
+ if self.header_bytes > HEADER_LIMIT:
+ raise FetchFailure("fetch_target_unreadable")
+ if self.headers_complete:
+ return len(data) # Trailers cannot rewrite MIME, encoding, cookies or limits.
+ if data.startswith(b"HTTP/"):
+ self.headers.clear()
+ self.limit = TEXT_LIMIT
+ try:
+ self.status = int(data.split()[1])
+ except (ValueError, IndexError):
+ raise FetchFailure("fetch_target_unreadable") from None
+ elif b":" in data:
+ k, v = data.decode("latin-1").split(":", 1)
+ self.headers.append((k.lower(), v.strip()))
+ if k.lower() == "content-type":
+ self.limit = PDF_LIMIT if v.strip().split(";", 1)[0].lower() == "application/pdf" else TEXT_LIMIT
+ if k.lower() == "content-length" and self.status in {None, 200}:
+ try:
+ length = int(v.strip())
+ except ValueError:
+ raise FetchFailure("fetch_target_unreadable") from None
+ # Permit a PDF's length before its Content-Type header is received;
+ # the final header terminator enforces the actual format's limit.
+ if length < 0:
+ raise FetchFailure("fetch_target_unreadable")
+ if self.budget.wire + length > PDF_LIMIT:
+ raise FetchFailure("fetch_target_unreadable")
+ if data in (b"\r\n", b"\n"):
+ self.headers_complete = self.status is None or self.status >= 200
+ if self.status in {None, 200}:
+ lengths = [int(v) for k, v in self.headers if k == "content-length"]
+ if len(set(lengths)) > 1 or (lengths and self.budget.wire + lengths[0] > self.limit):
+ raise FetchFailure("fetch_target_unreadable")
+ if self.budget.decoded > self.limit:
+ raise FetchFailure("fetch_target_unreadable")
+ encoding = next((v.lower().strip() for k, v in self.headers if k == "content-encoding"), "identity")
+ allowed = {"identity", "", "gzip", "deflate"} | ({"br", "zstd"} if self.native_decoded else set())
+ if encoding not in allowed:
+ raise FetchFailure("fetch_unsupported_content")
+ return len(data)
+
+ def body(self, data: bytes) -> int:
+ if self.native_decoded:
+ # libcurl emits bounded decoded chunks; count before retaining them.
+ self.budget.decoded += len(data)
+ if self.budget.decoded > self.limit:
+ raise FetchFailure("fetch_target_unreadable")
+ else:
+ self.budget.wire += len(data)
+ if self.budget.wire > self.limit:
+ raise FetchFailure("fetch_target_unreadable")
+ self.raw.extend(data)
+ return len(data)
+
+ def finish(self, status: int) -> HopResponse:
+ if status != 200:
+ # Refusals, redirects and Retry-After are header facts. Never let
+ # a broken/oversized compressed error body overwrite them.
+ return HopResponse(status, self.headers, b"")
+ encoding = next((v.lower().strip() for k, v in self.headers if k == "content-encoding"), "identity")
+ remaining = self.limit - self.budget.decoded
+ if remaining < 0:
+ # A preceding PDF hop may have spent more than this text cap.
+ # Never pass a negative size (read-all) to a decoder.
+ raise FetchFailure("fetch_target_unreadable")
+ raw = bytes(self.raw)
+ if self.native_decoded:
+ return HopResponse(status, self.headers, raw)
+ try:
+ if encoding in ("identity", ""):
+ body = raw
+ elif encoding == "gzip":
+ with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream:
+ body = stream.read(remaining + 1)
+ elif encoding == "deflate":
+ # Accept the RFC zlib wrapper and the common raw-deflate variant,
+ # bounding output at the C decoder before allocating the result.
+ for window in (zlib.MAX_WBITS, -zlib.MAX_WBITS):
+ decoder = zlib.decompressobj(window)
+ try:
+ body = decoder.decompress(raw, remaining + 1)
+ except zlib.error:
+ if window > 0:
+ continue
+ raise
+ if len(body) > remaining or not decoder.eof or decoder.unused_data:
+ raise FetchFailure("fetch_target_unreadable")
+ break
+ else:
+ raise FetchFailure("fetch_unsupported_content")
+ except FetchFailure:
+ raise
+ except Exception:
+ raise FetchFailure("fetch_target_unreadable") from None
+ self.budget.decoded += len(body)
+ if self.budget.decoded > self.limit:
+ raise FetchFailure("fetch_target_unreadable")
+ return HopResponse(status, self.headers, body)
+
+
+def _peer(ip: str) -> str:
+ value = ipaddress.ip_address(ip)
+ return str(value.ipv4_mapped or value) if isinstance(value, ipaddress.IPv6Address) else str(value)
+
+
+class _PinnedStream(httpcore.NetworkStream):
+ def __init__(self, stream, backend):
+ self.stream, self.backend = stream, backend
+
+ def read(self, max_bytes, timeout=None):
+ return self.stream.read(max_bytes, timeout)
+
+ def write(self, buffer, timeout=None):
+ return self.stream.write(buffer, timeout)
+
+ def close(self):
+ self.stream.close()
+
+ def get_extra_info(self, info):
+ return self.stream.get_extra_info(info)
+
+ def start_tls(self, ssl_context, server_hostname=None, timeout=None):
+ if server_hostname != self.backend.target.address.host:
+ self.close()
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+ remaining = self.backend.deadline - time.monotonic()
+ if remaining <= 0:
+ self.close()
+ raise httpcore.ConnectTimeout()
+ return _PinnedStream(self.stream.start_tls(ssl_context, server_hostname, min(timeout or remaining, remaining)), self.backend)
+
+
+class PinnedBackend(httpcore.NetworkBackend):
+ """Only numeric connects; preserve original hostname for Host and TLS/SNI."""
+ def __init__(self, target: CheckedTarget):
+ self.target = target
+ self.deadline = 0.0
+
+ def connect_tcp(self, host, port, timeout=None, local_address=None, socket_options=None):
+ if host != self.target.address.host or port != self.target.address.port or local_address is not None:
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+ self.deadline = time.monotonic() + min(timeout or 5.0, 5.0)
+ # Interleave address families, reserving time for every checked address.
+ v4 = [ip for ip in self.target.ips if ":" not in ip]
+ v6 = [ip for ip in self.target.ips if ":" in ip]
+ ips = [ip for pair in zip_longest(v6, v4) for ip in pair if ip]
+ for index, ip in enumerate(ips):
+ remaining = self.deadline - time.monotonic()
+ if remaining <= 0:
+ break
+ try:
+ stream = httpcore.SyncBackend().connect_tcp(ip, port, remaining / (len(ips) - index), socket_options=socket_options)
+ except (httpcore.ConnectError, httpcore.ConnectTimeout):
+ continue
+ peer = stream.get_extra_info("server_addr")
+ if not peer or _peer(peer[0]) not in {_peer(ip) for ip in self.target.ips}:
+ stream.close()
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+ return _PinnedStream(stream, self)
+ raise httpcore.ConnectTimeout()
+
+ def connect_unix_socket(self, *args, **kwargs):
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+
+
+class _ResponseStream(httpx.SyncByteStream):
+ def __init__(self, stream):
+ self.stream = stream
+
+ def __iter__(self):
+ yield from self.stream
+
+ def close(self):
+ self.stream.close()
+
+
+class PinnedTransport(httpx.BaseTransport):
+ """A new pool for exactly one checked hop. No proxy, retry, or coalescing."""
+ def __init__(self, target: CheckedTarget):
+ self.pool = httpcore.ConnectionPool(
+ ssl_context=ssl.create_default_context(cafile=certifi.where()),
+ network_backend=PinnedBackend(target), http1=True, http2=True,
+ max_connections=1, max_keepalive_connections=0, retries=0,
+ )
+
+ def handle_request(self, request: httpx.Request) -> httpx.Response:
+ response = self.pool.handle_request(httpcore.Request(
+ method=request.method, url=httpcore.URL(scheme=request.url.raw_scheme, host=request.url.raw_host,
+ port=request.url.port, target=request.url.raw_path),
+ headers=request.headers.raw, content=request.stream, extensions=request.extensions,
+ ))
+ return httpx.Response(response.status, headers=response.headers,
+ stream=_ResponseStream(response.stream), extensions=response.extensions)
+
+ def close(self):
+ self.pool.close()
+
+
+def httpx_hop(target: CheckedTarget, headers: dict, budget: TransferBudget, timeout: float, on_sent: Callable) -> HopResponse:
+ receiver = _Receiver(budget)
+
+ def trace(name, info):
+ if name in {"http11.send_request_headers.started", "http2.send_request_headers.started"}:
+ on_sent()
+
+ with httpx.Client(transport=PinnedTransport(target), trust_env=False, follow_redirects=False,
+ timeout=httpx.Timeout(timeout, connect=min(5, timeout)), headers=headers) as client:
+ with client.stream("GET", target.address.url, extensions={"trace": trace}) as response:
+ receiver.status = response.status_code
+ for k, v in response.headers.raw:
+ receiver.header(k + b":" + v + b"\r\n")
+ receiver.header(b"\r\n")
+ if response.status_code != 200:
+ return receiver.finish(response.status_code)
+ for chunk in response.iter_raw(chunk_size=65536):
+ receiver.body(chunk)
+ return receiver.finish(response.status_code)
+
+
+def curl_hop(target: CheckedTarget, headers: dict, budget: TransferBudget, timeout: float, on_sent: Callable) -> HopResponse:
+ from curl_cffi import CurlHttpVersion, CurlOpt, ffi, lib
+ from curl_cffi.curl import CURL_WRITEFUNC_ERROR
+ from curl_cffi.requests import Session
+
+ receiver = _Receiver(budget, native_decoded=True)
+ wire_before = budget.wire
+ pins = ",".join(f"[{ip}]" if ":" in ip else ip for ip in target.ips)
+ errors = []
+
+ def guarded(callback):
+ def call(data):
+ try:
+ return callback(data)
+ except FetchFailure as error:
+ errors.append(error)
+ return CURL_WRITEFUNC_ERROR # Returning zero is NOT an abort in curl_cffi.
+ return call
+
+ def header(data):
+ receiver.header(data)
+ return CURL_WRITEFUNC_ERROR if receiver.headers_complete and receiver.status != 200 else len(data)
+
+ def debug(kind, data):
+ if kind == 2: # CURLINFO_HEADER_OUT: after connect/TLS, before write.
+ on_sent()
+ # Deliberately discard all bytes: never log cookies or headers.
+
+ # curl_cffi's high-level setopt does not wrap XFERINFOFUNCTION. Use the
+ # pinned binding's exported C ABI, retaining this callback through perform.
+ # The transfer counter counts encoded entity bytes, not decoded chunks or
+ # HTTP chunk framing. It also runs when a compressed stream emits no body.
+ @ffi.callback("int(void *, int64_t, int64_t, int64_t, int64_t)", error=1)
+ def progress(_client, _total, downloaded, _upload_total, _uploaded):
+ budget.wire = wire_before + downloaded
+ if receiver.headers_complete and receiver.status == 200 and budget.wire > receiver.limit and not errors:
+ errors.append(FetchFailure("fetch_target_unreadable"))
+ return 1 if errors else 0
+
+ options = {
+ CurlOpt.PROXY: "", CurlOpt.NETRC: 0, CurlOpt.FRESH_CONNECT: 1, CurlOpt.FORBID_REUSE: 1,
+ CurlOpt.HTTP_VERSION: CurlHttpVersion.V2TLS, CurlOpt.HTTP_CONTENT_DECODING: 1,
+ CurlOpt.NOPROGRESS: 0,
+ CurlOpt.CONNECTTIMEOUT_MS: max(1, int(min(5, timeout) * 1000)),
+ CurlOpt.HEADERFUNCTION: guarded(header), CurlOpt.DEBUGFUNCTION: debug, CurlOpt.VERBOSE: 1,
+ # A fresh handle with no ALTSVC/HSTS storage never learns a later-hop
+ # destination. HTTP/3 is excluded above; no shared cache is attached.
+ CurlOpt.HSTS_CTRL: 0,
+ }
+ if not target.address.literal:
+ options[CurlOpt.RESOLVE] = [f"{target.address.host}:{target.address.port}:{pins}"]
+ try:
+ with Session(trust_env=False, curl_options=options, retry=0) as session:
+ if lib._curl_easy_setopt(session.curl._curl, CurlOpt.XFERINFOFUNCTION, progress) != 0:
+ raise FetchFailure("fetch_unavailable")
+ try:
+ response = session.get(
+ target.address.url, headers=headers, impersonate=browser_profile()["impersonate"],
+ allow_redirects=False, verify=certifi.where(), timeout=timeout,
+ content_callback=guarded(receiver.body), accept_encoding=ENCODING,
+ )
+ except Exception as error:
+ # A deliberate header-only abort still carries libcurl's peer
+ # and status snapshot; validate the peer exactly as on success.
+ response = getattr(error, "response", None)
+ if not receiver.headers_complete or receiver.status == 200 or response is None:
+ raise
+ budget.wire = wire_before + response.download_size
+ if errors:
+ raise errors[0]
+ if response.status_code == 200 and budget.wire > receiver.limit:
+ raise FetchFailure("fetch_target_unreadable")
+ if _peer(response.primary_ip) not in {_peer(ip) for ip in target.ips}:
+ raise FetchFailure("fetch_url_blocked", terminal=True)
+ return receiver.finish(response.status_code)
+ except Exception:
+ if errors:
+ raise errors[0] from None
+ raise
diff --git a/core/web_fetch_worker/worker.py b/core/web_fetch_worker/worker.py
new file mode 100644
index 000000000..de587d660
--- /dev/null
+++ b/core/web_fetch_worker/worker.py
@@ -0,0 +1,321 @@
+"""Disposable web_fetch worker: all DNS, sockets and parsers die with this process.
+
+The parent supervises a 30s wall deadline and RSS ceiling. POSIX adds kernel
+CPU/address-space limits; Windows adds a process-memory Job limit. IPC carries
+only bounded facts (never cookies, headers, or credentials).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import time
+from email.utils import parsedate_to_datetime
+from urllib.parse import urljoin, urlsplit
+
+from .policy import FetchFailure, parse_url, resolve_target
+
+
+MEMORY_LIMIT = 768 * 1024 * 1024
+_JOB = None
+
+
+def resource_limits() -> None:
+ global _JOB
+ if os.name == "posix":
+ import resource
+
+ def cap(kind, soft, hard):
+ _, inherited = resource.getrlimit(kind)
+ if inherited != resource.RLIM_INFINITY:
+ soft, hard = min(soft, inherited), min(hard, inherited)
+ resource.setrlimit(kind, (soft, hard))
+
+ cap(resource.RLIMIT_CPU, 30, 31)
+ # macOS has no enforceable per-process address-space limit here; the
+ # parent supervises RSS. Linux additionally enforces this in the kernel.
+ if sys.platform != "darwin":
+ cap(resource.RLIMIT_AS, MEMORY_LIMIT, MEMORY_LIMIT)
+ cap(resource.RLIMIT_FSIZE, 1024 * 1024, 1024 * 1024)
+ elif os.name == "nt":
+ import ctypes
+ from ctypes import wintypes
+
+ class Basic(ctypes.Structure):
+ _fields_ = [("per_process", ctypes.c_int64), ("per_job", ctypes.c_int64),
+ ("flags", wintypes.DWORD), ("min_ws", ctypes.c_size_t), ("max_ws", ctypes.c_size_t),
+ ("active", wintypes.DWORD), ("affinity", ctypes.c_size_t), ("priority", wintypes.DWORD),
+ ("scheduling", wintypes.DWORD)]
+ class Limits(ctypes.Structure):
+ _fields_ = [("basic", Basic), ("io", ctypes.c_uint64 * 6),
+ ("process_memory", ctypes.c_size_t), ("job_memory", ctypes.c_size_t),
+ ("peak_process", ctypes.c_size_t), ("peak_job", ctypes.c_size_t)]
+ kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+ kernel.CreateJobObjectW.restype = wintypes.HANDLE
+ kernel.CreateJobObjectW.argtypes = [ctypes.c_void_p, wintypes.LPCWSTR]
+ kernel.SetInformationJobObject.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD]
+ kernel.GetCurrentProcess.restype = wintypes.HANDLE
+ kernel.AssignProcessToJobObject.argtypes = [wintypes.HANDLE, wintypes.HANDLE]
+ _JOB = kernel.CreateJobObjectW(None, None)
+ limits = Limits()
+ limits.basic.flags = 0x100 # JOB_OBJECT_LIMIT_PROCESS_MEMORY
+ limits.process_memory = MEMORY_LIMIT
+ if (not _JOB or not kernel.SetInformationJobObject(_JOB, 9, ctypes.byref(limits), ctypes.sizeof(limits))
+ or not kernel.AssignProcessToJobObject(_JOB, kernel.GetCurrentProcess())):
+ raise FetchFailure("fetch_unavailable")
+
+
+class OriginCookies:
+ def __init__(self):
+ self.values = {}
+
+ def receive(self, address, headers):
+ for name, value in headers:
+ if name.lower() != "set-cookie" or len(value.encode("utf-8")) > 4096:
+ continue
+ # RFC 6265's response parser has ONE name=value pair. SimpleCookie
+ # parses a Cookie header instead and mistakes unknown attributes for
+ # more cookies (or drops modern Partitioned/Priority cookies).
+ pair, *pieces = value.split(";")
+ if "=" not in pair:
+ continue
+ key, content = (part.strip() for part in pair.split("=", 1))
+ if not re.fullmatch(r"[!#$%&'*+.^_`|~0-9A-Za-z-]+", key) or any(ord(c) < 32 or ord(c) > 126 for c in content):
+ continue
+ attributes = {}
+ for piece in pieces:
+ name, _, attribute = piece.strip().partition("=")
+ attributes[name.lower()] = attribute.strip()
+ secure = "secure" in attributes
+ domain = attributes.get("domain", "").lstrip(".").lower()
+ if (domain and not (address.host == domain or (not address.literal and "." in domain and address.host.endswith("." + domain)))):
+ continue
+ if secure and address.scheme != "https":
+ continue
+ if key.startswith(("__Secure-", "__Host-")) and not secure:
+ continue
+ if key.startswith("__Host-") and (domain or attributes.get("path") != "/"):
+ continue
+ default_path = urlsplit(address.url).path.rpartition("/")[0] or "/"
+ path = attributes.get("path", default_path)
+ if not path.startswith("/"):
+ path = default_path
+ identity = (address.origin, path, key)
+ expiry = float("inf")
+ try:
+ if attributes.get("expires"):
+ expiry = parsedate_to_datetime(attributes["expires"]).timestamp()
+ except (ValueError, TypeError, OverflowError):
+ pass
+ try:
+ if re.fullmatch(r"-?[0-9]+", attributes.get("max-age", "")):
+ expiry = time.time() + int(attributes["max-age"])
+ except (ValueError, OverflowError):
+ pass
+ if expiry <= time.time():
+ self.values.pop(identity, None)
+ elif identity in self.values or len(self.values) < 64:
+ # Domain influences acceptance only, never where a cookie goes.
+ self.values[identity] = (f"{key}={content}", secure, expiry)
+
+ def header(self, address):
+ request_path = urlsplit(address.url).path
+ parts, size = [], 0
+ for (origin, path, key), (value, secure, expiry) in self.values.items():
+ if (origin != address.origin or not (request_path == path or request_path.startswith(path.rstrip("/") + "/"))
+ or (secure and address.scheme != "https") or expiry <= time.time()):
+ continue
+ # Reserve 16 KiB for the URL and fixed headers under the 64 KiB
+ # outgoing-header ceiling. Excess cookies are simply not sent.
+ cost = len(value.encode("utf-8")) + 2
+ if size + cost <= 48 * 1024:
+ parts.append(value)
+ size += cost
+ return "; ".join(parts)
+
+
+def fetch_document(url: str, locale: str, exchange, *, remaining_seconds: float = 30) -> dict:
+ deadline = time.monotonic() + max(0, min(remaining_seconds, 30))
+ # The independent URL/DNS gate must not pay HTTP/parser startup cost or
+ # depend on those packages loading. Imports stay inside the bounded fetch.
+ from .extract import extract_page
+ from .transport import TransferBudget, curl_hop, httpx_hop, native_available, request_headers
+
+ def resolve(value):
+ # A genuine DNS failure/full DNS allowance is terminal. Exhausting the
+ # attempt's smaller remaining budget is admission/timeout, not a refusal;
+ # any next candidate must gate the original URL again. The resolver
+ # thread is confined to this disposable process and dies with it.
+ import queue
+ import threading
+
+ exchange({"event": "phase", "phase": "policy"})
+ if parse_url(value).literal:
+ result = resolve_target(value)
+ else:
+ replies = queue.Queue(maxsize=1)
+ def lookup():
+ try:
+ replies.put((resolve_target(value), None))
+ except Exception as error:
+ replies.put((None, error))
+ threading.Thread(target=lookup, daemon=True).start()
+ window = max(0, min(5, deadline - time.monotonic()))
+ try:
+ result, error = replies.get(timeout=window)
+ except queue.Empty:
+ if window < 5:
+ raise FetchFailure("fetch_timeout" if sent else "service_busy", cooldown_suppressed=True) from None
+ raise FetchFailure("fetch_dns_unverified", terminal=True) from None
+ if error:
+ raise error
+ exchange({"event": "phase", "phase": "fetch"})
+ return result
+
+ budget, cookies, seen = TransferBudget(), OriginCookies(), set()
+ native, reason = native_available()
+ exchange({"event": "transport", "transport_degraded": not native, "transport_degraded_reason": reason})
+ hop = curl_hop if native else httpx_hop
+ original = parse_url(url).url
+ current, previous = original, None
+ used_follow = set()
+ retained = None
+ sent = False
+
+ def on_sent():
+ nonlocal sent
+ if not sent:
+ exchange({"event": "sent"})
+ sent = True
+
+ for index in range(6):
+ # Release/acquire is parent-owned and counted in the attempt deadline.
+ # Re-resolve AFTER the lock wait, immediately before each numeric connect.
+ address = parse_url(current)
+ resolve(current) # Policy precedes even a host-cooldown skip.
+ exchange({"event": "host", "host": address.host})
+ target = resolve(current)
+ if target.address.url in seen:
+ raise FetchFailure("fetch_target_unreadable")
+ seen.add(target.address.url)
+ headers = request_headers(degraded=not native, locale=locale, previous_origin=previous, target=target)
+ if cookie := cookies.header(address):
+ headers["Cookie"] = cookie
+ stage = "fetch"
+ allowance = max(0.01, deadline - time.monotonic())
+ hop_sent = False
+
+ def mark_hop_sent():
+ nonlocal hop_sent
+ on_sent()
+ hop_sent = True
+
+ try:
+ response = hop(target, headers, budget, allowance, mark_hop_sent)
+ cookies.receive(address, response.headers)
+ if response.status == 401:
+ raise FetchFailure("fetch_refused", terminal=True)
+ if response.status == 429:
+ raise FetchFailure("service_rate_limited", retry_after=response.header("retry-after") or None)
+ if response.status in {301, 302, 303, 307, 308}:
+ location = response.header("location")
+ if not location:
+ raise FetchFailure("fetch_target_unreadable")
+ previous, current = address.origin, urljoin(address.url, location)
+ # Always gate the selected redirect, even at the hop bound.
+ resolve(current)
+ continue
+ if response.status in {404, 410, 408}:
+ raise FetchFailure("fetch_target_unreadable")
+ if response.status == 403 or (response.status == 503 and response.header("cf-mitigated").lower() == "challenge"):
+ raise FetchFailure("fetch_challenge")
+ if response.status != 200:
+ raise FetchFailure("fetch_unavailable" if response.status >= 500 else "fetch_target_unreadable",
+ retry_after=response.header("retry-after") or None)
+ stage = "extract"
+ exchange({"event": "phase", "phase": "extract"})
+ page = extract_page(response.body, response.header("content-type"), address.url)
+ if page.follow_url and page.follow_kind not in used_follow:
+ # A forbidden selected alternate/refresh is terminal, not a reason
+ # to return retained HTML or disclose the original to a provider.
+ resolve(page.follow_url)
+ if index < 5:
+ used_follow.add(page.follow_kind)
+ if page.follow_kind == "alternate" and page.content:
+ retained = (page, address.url, len(response.body))
+ exchange({"event": "fallback", "result": {
+ **page.payload(), "final_url": address.url, "source_size_bytes": len(response.body),
+ "transport_degraded": not native, "transport_degraded_reason": reason,
+ }})
+ previous, current = address.origin, page.follow_url
+ continue
+ if not page.content.strip():
+ raise FetchFailure("fetch_target_unreadable")
+ if retained is not None:
+ original_page = retained[0]
+ page.title = page.title or original_page.title
+ page.canonical_url = page.canonical_url or original_page.canonical_url
+ result = {**page.payload(), "final_url": address.url, "source_size_bytes": len(response.body)}
+ break
+ except FetchFailure as error:
+ if error.code == "fetch_timeout" and (hop_sent or allowance < 5):
+ error.cooldown_suppressed = True
+ if error.terminal or retained is None:
+ raise
+ page, final_url, size = retained
+ result = {**page.payload(), "final_url": final_url, "source_size_bytes": size,
+ "cooldown_code": error.code, "retry_after": error.retry_after,
+ "cooldown_suppressed": error.cooldown_suppressed}
+ break
+ except Exception as error:
+ # No target error retries on the other transport. Native-load failure
+ # was the only fallback, chosen before the first socket existed.
+ code = "fetch_target_unreadable" if stage == "extract" else "fetch_timeout" if "timeout" in type(error).__name__.lower() else "fetch_unavailable"
+ # Connect/TLS has an independent 5 s bound. After send, the only
+ # timeout is the remaining attempt budget; a shortened connect
+ # allowance likewise cannot prove this new host is unhealthy.
+ suppressed = code == "fetch_timeout" and (hop_sent or allowance < 5)
+ if retained is not None:
+ page, final_url, size = retained
+ result = {**page.payload(), "final_url": final_url, "source_size_bytes": size,
+ "cooldown_code": code, "cooldown_suppressed": suppressed}
+ break
+ raise FetchFailure(code, cooldown_suppressed=suppressed) from None
+ else:
+ raise FetchFailure("fetch_target_unreadable")
+ for field in ("follow_url", "follow_kind"):
+ result.pop(field, None)
+ return {**result, "transport_degraded": not native, "transport_degraded_reason": reason}
+
+
+def main() -> None:
+ def emit(payload):
+ sys.stdout.write(json.dumps(payload, ensure_ascii=True) + "\n")
+ sys.stdout.flush()
+
+ def exchange(payload):
+ emit(payload)
+ if sys.stdin.readline().strip() != "ok":
+ # Never return control to a native callback after denied admission.
+ os._exit(1)
+
+ try:
+ resource_limits()
+ request = json.loads(sys.stdin.readline(65536))
+ if request["operation"] == "gate":
+ target = resolve_target(request["url"])
+ result = {"url": target.address.url}
+ else:
+ result = fetch_document(request["url"], request.get("locale", "en"), exchange,
+ remaining_seconds=request.get("remaining_seconds", 30))
+ emit({"event": "result", "result": result})
+ except FetchFailure as error:
+ emit({"event": "failure", "error_code": error.code, "terminal": error.terminal,
+ "retry_after": error.retry_after, "cooldown_suppressed": error.cooldown_suppressed})
+ except Exception:
+ emit({"event": "failure", "error_code": "fetch_unavailable", "terminal": False})
+
+
+if __name__ == "__main__":
+ main()
diff --git a/desktop/runtime-sources.json b/desktop/runtime-sources.json
index 43338b052..dec611e90 100644
--- a/desktop/runtime-sources.json
+++ b/desktop/runtime-sources.json
@@ -5,6 +5,10 @@
"claude-agent-sdk",
"http-ece"
],
+ "required_binary_wheels": [
+ "curl-cffi",
+ "lxml"
+ ],
"show_runtime_manifest": {
"url": "https://github.com/avibe-bot/avibe/releases/download/v3.1.3/show-runtime-manifest.json",
"sha256": "c628743535cbf70014fe81c6fd502f26ce24b394f874cf347ed531f97f479cb1"
diff --git a/desktop/scripts/build-runtime-bundle.py b/desktop/scripts/build-runtime-bundle.py
index 02186016f..849c7bce2 100755
--- a/desktop/scripts/build-runtime-bundle.py
+++ b/desktop/scripts/build-runtime-bundle.py
@@ -264,6 +264,44 @@ for name in ("claude", "claude.exe"):
)
+def verify_fetch_dependencies(private_python: Path, work_dir: Path, required_binary_wheels: list[str]) -> None:
+ """Offline release gate on the relocated tree, before hashing/signing.
+
+ Missing native wheels are release errors on our desktop matrix, not silently
+ accepted degraded builds. Runtime import failure still has its safe fallback.
+ """
+ probe = r'''
+import json
+import sys
+from importlib.metadata import distribution
+from pathlib import Path
+import certifi
+import h2.connection
+import pypdf
+from core.web_fetch_worker.transport import native_available
+from core.web_fetch_worker.extract import extract_page
+
+for name in json.loads(sys.argv[1]):
+ dist = distribution(name)
+ wheel = dist.read_text("WHEEL") or ""
+ if "Root-Is-Purelib: false" not in wheel or not any(
+ str(path).endswith((".so", ".pyd", ".dylib", ".dll"))
+ for path in (dist.files or ())
+ ):
+ raise SystemExit(f"Required binary wheel missing: {name}")
+if not Path(certifi.where()).is_file() or "BEGIN CERTIFICATE" not in Path(certifi.where()).read_text():
+ raise SystemExit("curl/httpx CA resources missing")
+if native_available() != (True, None):
+ raise SystemExit("Pinned curl_cffi/chrome150 native profile/codecs unavailable")
+page = extract_page(b"<article><h1>Offline</h1><p>Readable bundled extraction fixture.</p></article>", "text/html", "https://example.com/")
+assert "bundled extraction" in page.content
+'''.strip()
+ subprocess.run(
+ [str(private_python), "-I", "-B", "-c", probe, json.dumps(required_binary_wheels)],
+ cwd=work_dir, check=True,
+ )
+
+
def install_runtime_cli(target_config: dict[str, Any], payload: Path) -> None:
"""Replace build-machine console scripts with one relocatable CLI.
@@ -871,6 +909,9 @@ def main() -> int:
sources = json.loads(SOURCES_PATH.read_text(encoding="utf-8"))
if sources.get("schema_version") != 2:
raise SystemExit("Unsupported runtime-sources.json schema")
+ required_binary_wheels = sources["required_binary_wheels"]
+ if set(required_binary_wheels) & set(sources.get("sdist_build_allowlist", [])):
+ raise SystemExit("Required binary wheels cannot be sdist exceptions")
try:
target_config = sources["targets"][args.target]
except KeyError:
@@ -922,7 +963,8 @@ def main() -> int:
prune_payload(payload)
private_python = payload / target_config["python_entrypoint"]
compile_payload(private_python, python_library(private_python, payload))
- # Probe the tree as it ships, bytecode included.
+ # Probe the tree as it ships, bytecode included, with no network calls.
+ verify_fetch_dependencies(private_python, work_dir, required_binary_wheels)
verify_payload(target_config, payload, work_dir, sources["npm_version"])
output_parent = args.output.parent
diff --git a/docs/plans/web-fetch.md b/docs/plans/web-fetch.md
index 52fd2c09d..8cadd974c 100644
--- a/docs/plans/web-fetch.md
+++ b/docs/plans/web-fetch.md
@@ -194,6 +194,13 @@ initial refusal has zero executor attempts. A safe redirect, one same-origin
zero-delay meta-refresh and one same-origin Markdown alternate all consume the
same local deadline/body/hop budgets. Ignore malformed alternates; an alternate
whose resolution is policy-blocked terminates like any other followed target.
+A genuine DNS failure or expiry of the full 5-second DNS allowance remains
+terminal. Distinguish that from the local attempt deadline being exhausted by
+queueing or earlier work: before any local send it is a `service_busy` skip;
+after a sent local hop it is non-terminal `fetch_timeout`. Neither case cools
+the host. The next candidate receives only the **original `requested_url`**,
+after running the mandatory gate on it again, never an unverified redirect URL
+(owner-approved clarification, 2026-10-25).
**Remote boundary:** API destinations are fixed HTTPS catalog endpoints, no
HTTP redirects or ambient proxies, with an 8 MiB response cap. Avibe validates
@@ -244,7 +251,7 @@ Override only the negotiated representation and bounded encoding policy:
```http
Accept: text/markdown, text/html;q=0.95, application/xhtml+xml;q=0.9, text/plain;q=0.8, application/json;q=0.5, */*;q=0.1
-Accept-Encoding: gzip, br, zstd
+Accept-Encoding: gzip, deflate, br, zstd
```
`Accept-Language` follows Avibe locale. Preserve matching `Sec-Fetch-*`,
@@ -253,9 +260,13 @@ metadata. Request Markdown first; accept a valid HTML response normally. A
single cheap same-origin `<link rel="alternate" type="text/markdown">` is
allowed, with original HTML retained if the alternate is merely unreadable.
This is deliberate agent content negotiation, not a byte-identical browser request.
-The degraded HTTP/2 path sends `User-Agent: Avibe/<version>`, the negotiated
-`Accept`/`Accept-Encoding`/`Accept-Language` headers, and no `sec-ch-*` or
-`Sec-Fetch-*` fingerprint headers. It cannot impersonate Chrome TLS; its
+The degraded HTTP/2 path sends `User-Agent: Avibe/<version>`, negotiated
+`Accept`/`Accept-Language`, **`Accept-Encoding: gzip, deflate`**, and no `sec-ch-*`
+or `Sec-Fetch-*` fingerprint headers. It decodes only gzip/deflate (plus identity)
+with bounded standard-library decoders. Native br/zstd decoding stays inside
+libcurl; do not install Python `brotli` or `zstandard` for this feature, because
+importable codecs change unrelated Sentry/HTTP/Discord defaults. It cannot
+impersonate Chrome TLS; its
`transport_degraded` marker explicitly states that exception and it must not
silently choose another browser profile.
@@ -263,17 +274,22 @@ Repository packaging facts checked at #2924's merge:
| Path / platform | Integration |
| --- | --- |
-| `pyproject.toml`, `uv.lock` | Python >=3.10; add the pinned native dependency with CPython/platform markers, HTTP/2 and Brotli/Zstandard decoders, `trafilatura>=2.3.1` (Apache-2.0) and `pypdf>=6.21.2`; lock the reviewed stable versions. Keep core import lazy. |
+| `pyproject.toml`, `uv.lock` | Python >=3.10; add the pinned native dependency with CPython/platform markers, HTTP/2, `trafilatura>=2.3.1` (Apache-2.0) and `pypdf>=6.21.2`; lock the reviewed stable versions. Native libcurl provides br/zstd without Python codec packages; degraded HTTPX uses stdlib gzip/deflate. Keep core import lazy. |
| macOS x86_64 / arm64 | 0.16.3 publishes `cp310-abi3` wheels tagged macOS 10.9+ / 11.0+. |
| Linux x86_64 / aarch64, including WSL | `cp310-abi3` wheels for glibc 2.17+ and musl 1.2+. No system curl/browser/Homebrew prerequisite. |
| Windows x86_64 / arm64 | Both wheel families exist; `install.ps1` currently chooses x64 CPython 3.12 on Windows Arm for other dependency constraints. Do not claim full native-Arm support. |
| `install.sh`, `install.ps1`, `vibe/upgrade.py` | Normal wheel metadata resolves dependencies in the new install generation before launcher activation. Direct `uv tool install`/pip follows the same metadata; no fetch-time package install. |
-| `desktop/scripts/build-runtime-bundle.py`, `desktop/runtime-sources.json` | Existing macOS arm64/x64 and Windows x64 bundles use CPython 3.12.15, frozen hash-checked exports and binary-only dependency install. Add `lxml` to the bundle's binary-wheel allowlist/check alongside curl resources before bundle signing; no new Linux desktop bundle is implied. |
+| `desktop/scripts/build-runtime-bundle.py`, `desktop/runtime-sources.json` | Existing macOS arm64/x64 and Windows x64 bundles use CPython 3.12.15, frozen hash-checked exports and binary-only dependency install. The `required_binary_wheels` gate requires `curl-cffi` and `lxml` native wheels; these must never enter the separate sdist-exception allowlist. After relocation, verify native imports, the offline `chrome150` preset and built-in br/zstd features, CA resources and extraction before hashing/signing. No new Linux desktop bundle is implied. |
Use dependency markers for the supported CPython/OS/architecture wheel families;
other combinations keep base HTTP/2 without trying to compile libcurl. Within
the supported matrix, missing wheels fail the release packaging gate rather than
-silently breaking installation. Native import/load errors at runtime select the
+silently breaking installation. The disposable entry points live under the lightweight
+`core/web_fetch_worker/` package (whose parent `core/__init__.py` is empty): the gate
+imports only policy/DNS code, while transport and extraction modules load only inside
+the fetch branch. Existing `core.handlers` and `core.handlers.model_hub` package
+initializers retain their established eager exports and import side effects; they are
+not changed to solve worker startup. Native import/load errors at runtime select the
degraded transport **before sending** and record `transport_degraded: true` with
a bounded reason; no target error triggers a second local request. Decode only
advertised encodings on both paths. Verify clean install and upgrade on Python
@@ -287,12 +303,33 @@ One chain deadline: **180 s**; each local/service attempt: **30 s**, including
DNS, lock wait, redirects and extraction; connect/TLS: **5 s** within that.
Local: five redirect hops, 16 MiB HTML/text/JSON or 32 MiB PDF, separately counted
on the wire and after decompression across all hops/alternates. Bound headers
-(64 KiB), URLs and cookies (64 entries, 4 KiB each); reject oversized announced
-lengths and abort streamed unknown lengths at the same cap. Bounded native body
-callbacks/transfer counters prevent an unbounded buffered response. Stop/cancel
-closes sockets; parsers run in a disposable process with hard wall-clock/resource
-bounds, terminated on expiry—not a timed-out thread continuing indefinitely.
-One local fetch in flight per host; its queue wait consumes the attempt deadline.
+(64 KiB per hop, including informational headers/trailers), URLs and cookies (64 entries, 4 KiB each); reject oversized announced
+lengths and abort streamed unknown lengths at the same cap. Native libcurl
+performs decoding; its bounded decoded-body callbacks enforce the decoded cap
+before retaining bytes, while `XFERINFOFUNCTION` tracks the separate encoded
+entity-byte cap even for compressed input that emits no body. HTTPX reads bounded
+raw chunks and uses bounded stdlib gzip/deflate decoding, rejecting br/zstd even
+if another installation happens to supply Python codecs. DNS, sockets,
+decoding and parsing run in one disposable process per fetch. All platforms have
+a 30-second hard wall timeout: Stop/expiry kills and reaps the process, closing
+its sockets rather than leaving a timed-out thread. The parent checks resident
+memory every 50 ms and kills at 768 MiB. Linux additionally applies kernel
+`RLIMIT_AS`/CPU limits; Windows uses a Job process-memory limit. macOS applies
+the kernel CPU limit plus parent RSS supervision only: brief overshoot between
+samples is possible, so this is **not a hard memory sandbox** (owner-approved
+implementation clarification, 2026-10-25). No extra daemon or VM is introduced.
+One local fetch is in flight per host; its queue wait consumes the attempt deadline.
+The parent admits host ownership and a fetch-worker slot atomically before
+spawning (at most eight fetch workers); initial waiters hold neither resource.
+The mandatory gate has its own bounded worker capacity, never a fetch slot. Its
+subprocess starts from the lightweight worker package above, so package/controller
+registration and HTTP/parser imports are outside the gate's five-second budget. An
+isolated subprocess fixture forbids those HTTP and extraction imports while exercising
+a public IP-literal gate. Cleanup survives repeated cancellation and reaps before
+releasing admission.
+The invocation owner publishes settled host health before releasing/notifying
+host waiters, so a queued redirect cannot bypass or clear a new Retry-After.
+Inherited stricter kernel hard limits are retained, never raised.
No browser profile, cookie store, Authorization, client certificate, environment
credential, custom proxy or user secret. A fresh in-memory jar accepts only valid
@@ -539,7 +576,8 @@ is a no-send `service_busy` skip, not a provider fault, cost or shared cooldown.
| Outcome | Chain / settlement |
| --- | --- |
-| Invalid argument / address refusal / unresolved policy gate | terminal, no third-party forwarding; preserve any earlier sent attempts |
+| Invalid argument / address refusal / DNS failure or full DNS allowance expiry | terminal, no third-party forwarding; preserve any earlier sent attempts |
+| Local attempt budget exhausted during admission/revalidation | no-send `service_busy` skip, or `fetch_timeout` after a local send; no cooldown; re-gate only the original requested URL before the next candidate |
| Usable content | end with completed record |
| Local 403/503 challenge, JS shell, empty page, unsupported type | next enabled candidate, no local retry/headless path |
| Local 404/410, connect/TLS/timeout/server failure | next; bounded host cooldown where transient |
diff --git a/install.sh b/install.sh
index 98195cac9..e754940f6 100755
--- a/install.sh
+++ b/install.sh
@@ -543,7 +543,7 @@ uv_tool_install() {
# Suppress package-manager progress only, not activation/retention diagnostics.
if env ${UV_INSTALL_PYTHON_MIRROR:+"UV_PYTHON_INSTALL_MIRROR=$UV_INSTALL_PYTHON_MIRROR"} \
- UV_TOOL_DIR="$generation_tools" UV_TOOL_BIN_DIR="$generation_bin" uv tool install "$@" 2>/dev/null; then
+ UV_TOOL_DIR="$generation_tools" UV_TOOL_BIN_DIR="$generation_bin" uv tool install "$@" --quiet; then
VIBE_CANDIDATE_BIN_PATH="$generation_bin/vibe"
if [ ! -x "$VIBE_CANDIDATE_BIN_PATH" ]; then
warn "uv completed but the candidate vibe launcher was not created"
diff --git a/pyproject.toml b/pyproject.toml
index 946c839a8..84b26e21d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -74,7 +74,13 @@ dependencies = [
"sentry-sdk==2.56.0",
"python-socks[asyncio]>=2.0.0",
"aiohttp-socks>=0.8.0",
- "httpx[socks]>=0.27",
+ "httpx[http2,socks]>=0.27",
+ # WF-2G: update this version only together with the locked chrome150 profile.
+ "curl_cffi==0.16.3; platform_python_implementation == 'CPython' and ((sys_platform == 'darwin' and (platform_machine == 'arm64' or platform_machine == 'x86_64')) or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'ARM64')))",
+ # Keep br/zstd inside libcurl: Python codec imports change other clients'
+ # defaults (Sentry, HTTPX, Discord). The degraded path uses stdlib codecs.
+ "trafilatura>=2.3.1",
+ "pypdf>=6.21.2",
"python-multipart>=0.0.9",
"PyJWT[crypto]>=2.15.0",
"SQLAlchemy>=2.0.0",
diff --git a/tests/conftest.py b/tests/conftest.py
index db5ddfabe..891c0ae74 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -133,7 +133,7 @@ _CALLER_ENV = (
)
# What the run started with, for `uses_real_paths` tests and the tripwire.
_AMBIENT_ENV = {name: os.environ.get(name) for name in (*_HOME_ENV, *_CALLER_ENV)}
-_REAL_PATH_HOME = Path.__dict__["home"]
+_REAL_PATH_HOME = inspect.getattr_static(Path, "home")
def _home_env(home: Path) -> dict[str, str]:
diff --git a/tests/test_desktop_runtime_bundle_builder.py b/tests/test_desktop_runtime_bundle_builder.py
index 924e9186c..5bb3e681f 100644
--- a/tests/test_desktop_runtime_bundle_builder.py
+++ b/tests/test_desktop_runtime_bundle_builder.py
@@ -215,6 +215,8 @@ def test_runtime_sources_schema_two_contains_only_node_and_npm_tools():
assert sources["schema_version"] == 2
assert sources["npm_version"] == "10.9.9"
assert set(sources["sdist_build_allowlist"]) == {"claude-agent-sdk", "http-ece"}
+ assert set(sources["required_binary_wheels"]) == {"curl-cffi", "lxml"}
+ assert not set(sources["required_binary_wheels"]) & set(sources["sdist_build_allowlist"])
assert "codex_version" not in sources
assert "codex_license" not in sources
for target, config in sources["targets"].items():
@@ -224,6 +226,18 @@ def test_runtime_sources_schema_two_contains_only_node_and_npm_tools():
assert not any(key.startswith("codex") for key in config)
+def test_fetch_bundle_offline_native_and_resource_gate(tmp_path):
+ """WF-LOCAL-PACKAGE: the packaged interpreter must load native resources.
+
+ The old bundle gate never imported curl/lxml, so missing wheels could ship
+ unnoticed. This exercises the real offline probe, not a source-text check.
+ """
+ pytest.importorskip("curl_cffi")
+ builder.verify_fetch_dependencies(Path(sys.executable), tmp_path, ["curl-cffi", "lxml"])
+ with pytest.raises(subprocess.CalledProcessError):
+ builder.verify_fetch_dependencies(Path(sys.executable), tmp_path, ["pypdf"])
+
+
def test_python_runtime_verification_checks_bundled_claude_paths(monkeypatch, tmp_path):
calls = []
diff --git a/tests/test_install_script.py b/tests/test_install_script.py
index 317af05b3..c10257377 100644
--- a/tests/test_install_script.py
+++ b/tests/test_install_script.py
@@ -437,6 +437,40 @@ def test_install_script_keeps_vibe_available_on_current_path(tmp_path):
assert uv_log.read_text(encoding="utf-8")
+def test_install_script_preserves_package_manager_failure_diagnostics(tmp_path):
+ """Quiet progress must not erase why a custom wheel failed to install."""
+ home_dir = tmp_path / "home"
+ home_dir.mkdir()
+ path_dir = tmp_path / "path-bin"
+ path_dir.mkdir()
+ _write_executable(
+ path_dir / "uv",
+ """\
+ #!/usr/bin/env bash
+ if [ "$1" = "--version" ]; then
+ echo "uv 0.13.5"
+ exit 0
+ fi
+ echo "error: Failed to build native-dependency: C compiler not found" >&2
+ exit 1
+ """,
+ )
+ env = {
+ **os.environ,
+ "HOME": str(home_dir),
+ "PATH": os.pathsep.join([str(path_dir), "/usr/bin", "/bin"]),
+ "AVIBE_INSTALL_PACKAGE_SPEC": str(tmp_path / "avibe_os-9.9.9-py3-none-any.whl"),
+ }
+
+ result = _install(env)
+
+ assert result.returncode != 0
+ assert "Failed to install avibe-os from custom package spec" in result.stdout
+ assert "Failed to build native-dependency: C compiler not found" in result.stderr
+ assert not (home_dir / ".local/bin/vibe").exists()
+ assert not list((home_dir / ".avibe/runtime/install-generations").glob("*"))
+
+
ASTRAL_PYTHON_INSTALL_MIRROR = "https://releases.astral.sh/github/python-build-standalone/releases/download"
diff --git a/tests/test_model_hub_fetch_policy.py b/tests/test_model_hub_fetch_policy.py
new file mode 100644
index 000000000..6cb602cb8
--- /dev/null
+++ b/tests/test_model_hub_fetch_policy.py
@@ -0,0 +1,99 @@
+"""WF-LOCAL-001: public-target policy is enforced before any executor egress.
+
+The previous readers had no policy owner. These tables protect parser ambiguity,
+all-answer checks, numeric pins, DNS64's embedded boundary, and DNS-free metadata.
+"""
+import socket
+
+import pytest
+
+from core.web_fetch_worker import policy
+
+
[email protected]("ip,code", [
+ ("127.0.0.1", "fetch_url_blocked"), ("10.0.0.1", "fetch_url_blocked"),
+ ("172.16.0.1", "fetch_url_blocked"), ("192.168.1.1", "fetch_url_blocked"),
+ ("100.64.0.0", "fetch_url_blocked"), ("100.127.255.255", "fetch_url_blocked"),
+ ("169.254.169.254", "fetch_url_blocked"), ("168.63.129.16", "fetch_url_blocked"),
+ ("0.0.0.0", "fetch_url_blocked"), ("224.0.0.1", "fetch_url_blocked"),
+ ("255.255.255.255", "fetch_url_blocked"), ("192.0.2.1", "fetch_url_blocked"),
+ ("198.51.100.1", "fetch_url_blocked"), ("203.0.113.1", "fetch_url_blocked"),
+ ("198.18.0.1", "fetch_dns_unverified"), ("198.19.255.255", "fetch_dns_unverified"),
+ ("::", "fetch_url_blocked"), ("::1", "fetch_url_blocked"),
+ ("::ffff:127.0.0.1", "fetch_url_blocked"), ("fe80::1", "fetch_url_blocked"),
+ ("fc00::1", "fetch_url_blocked"), ("ff02::1", "fetch_url_blocked"),
+ ("2001:db8::1", "fetch_url_blocked"), ("2001::1", "fetch_url_blocked"),
+ ("2002:0808:0808::1", "fetch_url_blocked"), ("64:ff9b:1::808:808", "fetch_url_blocked"),
+ ("64:ff9b::7f00:1", "fetch_url_blocked"), ("64:ff9b::c612:1", "fetch_dns_unverified"),
+ ("::8.8.8.8", "fetch_url_blocked"), ("3fff::1", "fetch_url_blocked"),
+ ("2001:4860::5efe:127.0.0.1", "fetch_url_blocked"),
+ ("2001:4860::200:5efe:8.8.8.8", "fetch_url_blocked"),
+])
+def test_denied_address_table(ip, code):
+ with pytest.raises(policy.FetchFailure) as raised:
+ policy.checked_ip(ip)
+ assert (raised.value.code, raised.value.terminal) == (code, True)
+
+
[email protected]("ip,expected", [
+ ("8.8.8.8", "8.8.8.8"), ("100.63.255.255", "100.63.255.255"),
+ ("100.128.0.1", "100.128.0.1"), ("198.20.0.1", "198.20.0.1"),
+ ("2606:4700:4700::1111", "2606:4700:4700::1111"),
+ ("2001:4860:4860::8888", "2001:4860:4860::8888"),
+ ("::ffff:8.8.8.8", "8.8.8.8"), ("64:ff9b::808:808", "64:ff9b::808:808"),
+])
+def test_public_address_table(ip, expected):
+ assert policy.checked_ip(ip) == expected
+
+
+ "file:///etc/passwd", "ftp://example.com/", "https://user:[email protected]/", "https://@example.com/",
+ "https://localhost/", "https://localhost./", "http://metadata.google.internal/", "http://device.local/",
+ "http://router.home.arpa/", "http://localhost.localdomain/",
+ "http://localhost。/", "http://metadata.google.internal。/", "http://router.lan./",
+ "http://2130706433/", "http://127.1/", "http://0177.0.0.1/", "http://0x7f000001/", "http://0x7f.1/",
+ "http://[fe80::1%25en0]/", "http://[::ffff:127.0.0.1]/", "http://example.com:0/",
+ "http://example.com:65536/", "http://example.com:/", "http://example.com\\@8.8.8.8/",
+ "http://example.com/\r\nHost:8.8.8.8", " http://example.com/", "http://example.com/\u200b",
+ "http://example.com../", "http://%31%32%37.0.0.1/", "//example.com", "https:///example.com",
+ "https://example.com/" + "a" * 8192,
+])
+def test_url_ambiguities_refused_before_dns(monkeypatch, url):
+ monkeypatch.setattr(socket, "getaddrinfo", lambda *a, **k: pytest.fail("refused URL reached DNS"))
+ with pytest.raises(policy.FetchFailure) as raised:
+ policy.resolve_target(url)
+ assert raised.value.terminal
+
+
+def test_uts46_normalization_preserves_path_query_and_removes_fragment():
+ address = policy.parse_url("https://BÜCHER.Example.:8443/a%2Fb?q=%2f&raw=a+b#gone")
+ assert address.url == "https://xn--bcher-kva.example:8443/a%2Fb?q=%2f&raw=a+b"
+ assert address.origin == ("https", "xn--bcher-kva.example", 8443)
+
+
[email protected]("answers,expected", [
+ (["8.8.8.8", "2001:4860::1"], ("8.8.8.8", "2001:4860::1")),
+ (["8.8.8.8", "10.0.0.1"], "fetch_url_blocked"),
+ (["8.8.8.8", "::ffff:127.0.0.1"], "fetch_url_blocked"),
+ (["8.8.8.8", "198.18.0.1"], "fetch_dns_unverified"),
+ ([], "fetch_dns_unverified"),
+])
+def test_entire_dns_set_is_checked(monkeypatch, answers, expected):
+ monkeypatch.setattr(socket, "getaddrinfo", lambda *a, **k: [
+ (socket.AF_INET6 if ":" in ip else socket.AF_INET, socket.SOCK_STREAM, 6, "", (ip, 443)) for ip in answers])
+ if isinstance(expected, str):
+ with pytest.raises(policy.FetchFailure, match=expected):
+ policy.resolve_target("https://example.com/")
+ else:
+ assert policy.resolve_target("https://example.com/").ips == expected
+
+
+def test_dns_failure_and_metadata_boundary(monkeypatch):
+ def fail(*args, **kwargs):
+ raise socket.gaierror()
+ monkeypatch.setattr(socket, "getaddrinfo", fail)
+ with pytest.raises(policy.FetchFailure, match="fetch_dns_unverified"):
+ policy.resolve_target("https://example.com/")
+ assert policy.metadata_url("https://reported.example/final") == "https://reported.example/final"
+ for value in ("http://127.0.0.1/", "https://[email protected]/", "file:///x", None):
+ assert policy.metadata_url(value) is None
diff --git a/tests/test_model_hub_fetch_tls.py b/tests/test_model_hub_fetch_tls.py
new file mode 100644
index 000000000..66680cbeb
--- /dev/null
+++ b/tests/test_model_hub_fetch_tls.py
@@ -0,0 +1,96 @@
+"""WF-LOCAL-004: original SNI and real HTTP/2 on both numeric-pinned paths."""
+from datetime import datetime, timedelta, timezone
+import socket
+import ssl
+import threading
+
+import pytest
+
+from core.web_fetch_worker import transport
+from core.web_fetch_worker.policy import CheckedTarget, FetchURL
+
+
+def h2_server(tmp_path, monkeypatch):
+ from cryptography import x509
+ from cryptography.hazmat.primitives import hashes, serialization
+ from cryptography.hazmat.primitives.asymmetric import rsa
+ from cryptography.x509.oid import NameOID
+ from h2.config import H2Configuration
+ from h2.connection import H2Connection
+ from h2.events import RequestReceived, StreamEnded
+
+ key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+ name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "public.example")])
+ now = datetime.now(timezone.utc)
+ cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(key.public_key())
+ .serial_number(x509.random_serial_number()).not_valid_before(now - timedelta(days=1))
+ .not_valid_after(now + timedelta(days=1))
+ .add_extension(x509.SubjectAlternativeName([x509.DNSName("public.example")]), critical=False)
+ .add_extension(x509.BasicConstraints(ca=True, path_length=None), critical=True).sign(key, hashes.SHA256()))
+ cert_path, key_path = tmp_path / "cert.pem", tmp_path / "key.pem"
+ cert_path.write_bytes(cert.public_bytes(serialization.Encoding.PEM))
+ key_path.write_bytes(key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption()))
+ monkeypatch.setattr(transport.certifi, "where", lambda: str(cert_path))
+ context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+ context.load_cert_chain(cert_path, key_path)
+ context.set_alpn_protocols(["h2"])
+ sni, requests, errors = [], [], []
+ context.set_servername_callback(lambda sock, hostname, ctx: sni.append(hostname))
+ listener = socket.socket()
+ listener.bind(("127.0.0.1", 0))
+ listener.listen()
+ listener.settimeout(5)
+ port = listener.getsockname()[1]
+ def serve():
+ responded = False
+ try:
+ raw, _ = listener.accept()
+ with context.wrap_socket(raw, server_side=True) as connection:
+ connection.settimeout(5)
+ assert connection.selected_alpn_protocol() == "h2"
+ h2 = H2Connection(config=H2Configuration(client_side=False))
+ h2.initiate_connection()
+ connection.sendall(h2.data_to_send())
+ while data := connection.recv(65536):
+ for event in h2.receive_data(data):
+ if isinstance(event, RequestReceived):
+ requests.append(dict(event.headers))
+ if isinstance(event, StreamEnded):
+ h2.send_headers(event.stream_id, [(":status", "200"), ("content-type", "text/plain")])
+ h2.send_data(event.stream_id, b"HTTP/2 pinned document", end_stream=True)
+ connection.sendall(h2.data_to_send())
+ responded = True
+ # Drain the client's SETTINGS/window updates until
+ # it closes. Closing with unread TLS bytes can reset
+ # the socket and discard the response on Windows.
+ connection.sendall(h2.data_to_send())
+ except (ConnectionResetError, ssl.SSLEOFError) as error:
+ if not responded:
+ errors.append(error)
+ except Exception as error:
+ errors.append(error)
+ thread = threading.Thread(target=serve)
+ thread.start()
+ try:
+ yield port, sni, requests
+ finally:
+ thread.join(6)
+ listener.close()
+ assert not thread.is_alive()
+ assert not errors
+
+
[email protected]("native", [True, False])
+def test_tls_sni_and_http2_preserve_original_host(request, native):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, sni, requests = request.getfixturevalue("h2_server")
+ address = FetchURL(f"https://public.example:{port}/doc", "public.example", port, "https", False)
+ # Only this fixture may create a loopback CheckedTarget.
+ target = CheckedTarget(address, ("127.0.0.1",))
+ headers = transport.request_headers(degraded=not native, locale="en", previous_origin=None, target=target)
+ result = (transport.curl_hop if native else transport.httpx_hop)(target, headers, transport.TransferBudget(), 4, lambda: None)
+ assert result.body == b"HTTP/2 pinned document"
+ assert sni == ["public.example"]
+ assert requests[0][b":authority"] == f"public.example:{port}".encode()
diff --git a/tests/test_model_hub_fetch_transport.py b/tests/test_model_hub_fetch_transport.py
new file mode 100644
index 000000000..8f3211338
--- /dev/null
+++ b/tests/test_model_hub_fetch_transport.py
@@ -0,0 +1,355 @@
+"""WF-LOCAL-002: actual hop transports must connect only to checked pins.
+
+Fixtures own their loopback pins; production has no policy bypass. These tests
+exercise real libcurl/HTTPcore sockets, not a mock implementing the pin policy.
+"""
+import gzip
+import io
+import zlib
+import socket
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+import httpcore
+import pytest
+
+from core.web_fetch_worker import transport
+from core.web_fetch_worker.policy import CheckedTarget, FetchFailure, FetchURL
+
+
+# Static codec fixtures keep optional Python codecs out of every install/test
+# environment. Both br/zstd payloads expand to exactly b"x" * 4096.
+_COMPRESSED = {
+ "gzip": gzip.compress(b"x" * 4096),
+ "deflate": zlib.compress(b"x" * 4096),
+ "deflate-raw": zlib.compress(b"x" * 4096)[2:-4],
+ "br": bytes.fromhex("1bff0ff825f0e2b14020f70000"),
+ "zstd": bytes.fromhex("28b52ffd60000f4d00001078780100fbf70116"),
+}
+_STREAMED_ZSTD = bytes.fromhex(
+ "28b52ffd0048940100840241207265616461626c652064796e616d6963616c6c7920636f6d7072657373656420706167652e0a"
+ "0100a8fe5fb92a034c000008640100fcff3910024d0000086f0100fc611d0801"
+)
+
+
+def stub():
+ requests = []
+ class Handler(BaseHTTPRequestHandler):
+ def do_GET(self):
+ requests.append((self.path, dict(self.headers)))
+ if self.path.startswith("/encoded/") or self.path == "/wire-padding":
+ if self.path == "/wire-padding":
+ stream = io.BytesIO()
+ with gzip.GzipFile(filename="x" * 4096, mode="wb", fileobj=stream) as compressed:
+ compressed.write(b"tiny")
+ raw, encoding = stream.getvalue(), "gzip"
+ else:
+ encoding = self.path.rsplit("/", 1)[-1]
+ raw = _STREAMED_ZSTD if encoding == "zstd-stream" else _COMPRESSED[encoding]
+ encoding = encoding.removesuffix("-stream").removesuffix("-raw")
+ self.send_response(200)
+ self.send_header("Content-Type", "text/plain")
+ self.send_header("Content-Encoding", encoding)
+ if self.path != "/wire-padding":
+ self.send_header("Content-Length", str(len(raw)))
+ self.end_headers()
+ try:
+ self.wfile.write(raw)
+ except (BrokenPipeError, ConnectionResetError):
+ pass
+ return
+ if self.path.startswith("/status/"):
+ self.send_response(int(self.path.rsplit("/", 1)[-1]))
+ self.send_header("Content-Type", "text/plain")
+ self.send_header("Content-Encoding", "gzip")
+ self.send_header("Content-Length", "8")
+ self.send_header("Retry-After", "3600")
+ self.end_headers()
+ try:
+ self.wfile.write(b"not gzip")
+ except (BrokenPipeError, ConnectionResetError):
+ pass
+ return
+ if self.path == "/trailer":
+ self.protocol_version = "HTTP/1.1"
+ self.send_response(200)
+ self.send_header("Content-Type", "text/plain")
+ self.send_header("Transfer-Encoding", "chunked")
+ self.end_headers()
+ self.wfile.write(b"4\r\nbody\r\n0\r\nContent-Type: application/pdf\r\nContent-Encoding: gzip\r\n\r\n")
+ self.close_connection = True
+ return
+ if self.path.startswith("/oversized"):
+ self.send_response(200)
+ self.send_header("Content-Type", "text/plain")
+ if "announced" in self.path:
+ self.send_header("Content-Length", str(17 * 1024 * 1024))
+ self.end_headers()
+ try:
+ for _ in range(17 * 16):
+ self.wfile.write(b"x" * 65536)
+ except (BrokenPipeError, ConnectionResetError):
+ pass
+ return
+ body = gzip.compress(b"# Pinned document\n\nThe bounded body.")
+ self.send_response(200)
+ self.send_header("Content-Type", "text/markdown")
+ self.send_header("Content-Encoding", "gzip")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+ def log_message(self, *args):
+ pass
+ server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+ thread = threading.Thread(target=server.serve_forever)
+ thread.start()
+ try:
+ yield server.server_port, requests
+ finally:
+ server.shutdown()
+ thread.join()
+ server.server_close()
+
+
[email protected]("native", [True, False])
+def test_real_hop_uses_numeric_pin_original_host_and_no_ambient_credentials(stub, monkeypatch, tmp_path, native):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, requests = stub
+ # Test-owned transport fixture, never a production policy flag.
+ address = FetchURL(f"http://public.example:{port}/doc?q=%2F", "public.example", port, "http", False)
+ target = CheckedTarget(address, ("127.0.0.1",))
+ monkeypatch.setenv("HTTP_PROXY", "http://127.0.0.1:1")
+ monkeypatch.setenv("ALL_PROXY", "socks5://127.0.0.1:1")
+ monkeypatch.setenv("HOME", str(tmp_path))
+ (tmp_path / ".netrc").write_text("machine public.example login secret-user password secret-password\n")
+ original = socket.getaddrinfo
+ def numeric_only(host, *args, **kwargs):
+ assert host == "127.0.0.1", "HTTPcore attempted hostname DNS instead of a numeric pin"
+ return original(host, *args, **kwargs)
+ monkeypatch.setattr(socket, "getaddrinfo", numeric_only)
+ headers = transport.request_headers(degraded=not native, locale="zh", previous_origin=None, target=target)
+ sent = []
+ result = (transport.curl_hop if native else transport.httpx_hop)(target, headers, transport.TransferBudget(), 3, lambda: sent.append(1))
+ assert result.status == 200
+ assert result.body == b"# Pinned document\n\nThe bounded body."
+ assert sent == [1]
+ path, got = requests[0]
+ assert path == "/doc?q=%2F"
+ assert got["Host"] == f"public.example:{port}"
+ lower = {key.lower(): value for key, value in got.items()}
+ assert not ({"authorization", "proxy-authorization", "cookie", "referer"} & lower.keys())
+ assert lower["accept"] == transport.ACCEPT
+ assert lower["accept-encoding"] == ("gzip, deflate, br, zstd" if native else "gzip, deflate")
+ if native:
+ assert "Chrome/150.0.0.0" in lower["user-agent"]
+ assert '"Chromium";v="150"' in lower["sec-ch-ua"]
+ else:
+ assert lower["user-agent"].startswith("Avibe/")
+ assert not any(key.startswith(("sec-ch-", "sec-fetch-")) for key in lower)
+
+
[email protected]("native", [True, False])
[email protected]("announced", [True, False])
+def test_real_transfer_aborts_oversize_instead_of_returning_partial_success(stub, native, announced):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, requests = stub
+ suffix = "-announced" if announced else ""
+ address = FetchURL(f"http://public.example:{port}/oversized{suffix}", "public.example", port, "http", False)
+ target = CheckedTarget(address, ("127.0.0.1",))
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ (transport.curl_hop if native else transport.httpx_hop)(target, {}, transport.TransferBudget(), 4, lambda: None)
+ assert len(requests) == 1
+
+
[email protected]("native", [True, False])
[email protected]("status", [401, 429, 302, 403, 503])
+def test_status_and_retry_after_survive_broken_compressed_error_body(stub, native, status):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, requests = stub
+ target = CheckedTarget(FetchURL(f"http://public.example:{port}/status/{status}", "public.example", port, "http", False), ("127.0.0.1",))
+ response = (transport.curl_hop if native else transport.httpx_hop)(target, {}, transport.TransferBudget(), 3, lambda: None)
+ assert response.status == status and response.header("retry-after") == "3600" and response.body == b""
+ assert len(requests) == 1
+
+
[email protected]("native", [True, False])
+def test_real_chunked_trailers_cannot_change_representation(stub, native):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, _ = stub
+ target = CheckedTarget(FetchURL(f"http://public.example:{port}/trailer", "public.example", port, "http", False), ("127.0.0.1",))
+ response = (transport.curl_hop if native else transport.httpx_hop)(target, {}, transport.TransferBudget(), 3, lambda: None)
+ assert response.body == b"body" and response.header("content-type") == "text/plain"
+ assert not response.header("content-encoding")
+
+
+def test_header_budget_is_per_hop_and_conflicting_length_is_target_scoped():
+ budget = transport.TransferBudget()
+ for _ in range(6):
+ receiver = transport._Receiver(budget)
+ receiver.header(b"X-CSP: " + b"a" * 14000 + b"\r\n")
+ receiver.header(b"\r\n")
+ assert receiver.finish(302).status == 302
+ receiver = transport._Receiver(budget)
+ receiver.header(b"Content-Length: 1\r\n")
+ receiver.header(b"Content-Length: 2\r\n")
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ receiver.header(b"\r\n")
+
+
[email protected]("overage", [1, 2, 512])
+def test_format_downgrade_rejects_spent_decode_budget_before_decoder(monkeypatch, overage):
+ # A PDF on the preceding hop may consume more than the next text hop's cap.
+ # In particular remaining+1 == -1 means an unbounded read to gzip/zstd.
+ reads, original = [], gzip.GzipFile.read
+ def observed(self, size=-1):
+ reads.append(size)
+ return original(self, size)
+ monkeypatch.setattr(gzip.GzipFile, "read", observed)
+ receiver = transport._Receiver(transport.TransferBudget(decoded=1024 + overage), limit=1024)
+ receiver.header(b"Content-Encoding: gzip\r\n")
+ receiver.body(gzip.compress(b"x" * 65536))
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ receiver.finish(200)
+ assert reads == []
+
+
[email protected]("headers", [
+ [b"HTTP/1.1 103 Early Hints\r\n", b"Content-Type: application/pdf\r\n", b"\r\n", b"HTTP/1.1 200 OK\r\n"],
+ [b"Content-Type: application/pdf\r\n"],
+])
+def test_final_content_type_owns_size_limit_not_interim_headers(headers):
+ receiver = transport._Receiver(transport.TransferBudget())
+ for line in [*headers, b"Content-Type: text/plain\r\n", b"\r\n"]:
+ receiver.header(line)
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ receiver.body(b"x" * (transport.TEXT_LIMIT + 1))
+
+
[email protected]("native", [True, False])
[email protected]("encoding", ["gzip", "deflate", "deflate-raw", "br", "zstd"])
+def test_real_codec_contract_counts_wire_and_decoded_bytes_separately(stub, native, encoding):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, _ = stub
+ target = CheckedTarget(FetchURL(f"http://public.example:{port}/encoded/{encoding}", "public.example", port, "http", False), ("127.0.0.1",))
+ budget = transport.TransferBudget()
+ if not native and encoding in {"br", "zstd"}:
+ with pytest.raises(FetchFailure, match="fetch_unsupported_content"):
+ transport.httpx_hop(target, {}, budget, 3, lambda: None)
+ return
+ response = (transport.curl_hop if native else transport.httpx_hop)(target, {}, budget, 3, lambda: None)
+ assert response.body == b"x" * 4096
+ assert budget.wire == len(_COMPRESSED[encoding]) and budget.decoded == 4096
+
+
+def test_native_streamed_zstd_without_content_size(stub):
+ pytest.importorskip("curl_cffi")
+ port, _ = stub
+ target = CheckedTarget(FetchURL(f"http://public.example:{port}/encoded/zstd-stream", "public.example", port, "http", False), ("127.0.0.1",))
+ budget = transport.TransferBudget()
+ response = transport.curl_hop(target, {}, budget, 3, lambda: None)
+ assert response.body == b"A readable dynamically compressed page.\n" * 8000
+ assert budget.wire == len(_STREAMED_ZSTD) and budget.decoded == len(response.body)
+
+
[email protected]("encoding", ["gzip", "deflate", "br", "zstd"])
+def test_native_decode_bomb_aborts_bounded_callback_before_retaining_excess(stub, monkeypatch, encoding):
+ pytest.importorskip("curl_cffi")
+ port, _ = stub
+ target = CheckedTarget(FetchURL(f"http://public.example:{port}/encoded/{encoding}", "public.example", port, "http", False), ("127.0.0.1",))
+ monkeypatch.setattr(transport, "TEXT_LIMIT", 1024)
+ original, calls = transport._Receiver.body, []
+ def observed(receiver, data):
+ try:
+ return original(receiver, data)
+ finally:
+ calls.append((len(data), len(receiver.raw)))
+ monkeypatch.setattr(transport._Receiver, "body", observed)
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ transport.curl_hop(target, {}, transport.TransferBudget(), 3, lambda: None)
+ assert calls and all(size <= 65536 and retained <= 1024 for size, retained in calls)
+
+
[email protected]("native", [True, False])
+def test_wire_budget_aborts_compressed_stream_with_tiny_decoded_body(stub, monkeypatch, native):
+ if native:
+ pytest.importorskip("curl_cffi")
+ port, _ = stub
+ target = CheckedTarget(FetchURL(f"http://public.example:{port}/wire-padding", "public.example", port, "http", False), ("127.0.0.1",))
+ monkeypatch.setattr(transport, "TEXT_LIMIT", 1024)
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ (transport.curl_hop if native else transport.httpx_hop)(target, {}, transport.TransferBudget(), 3, lambda: None)
+
+
+def test_backend_reserves_connect_budget_for_both_families_and_checks_peer(monkeypatch):
+ target = CheckedTarget(FetchURL("https://example.com/", "example.com", 443, "https", False),
+ ("2001:4860::1", "8.8.8.8"))
+ calls = []
+ class Stream:
+ def get_extra_info(self, info):
+ return ("8.8.8.8", 443)
+ def close(self):
+ pass
+ def connect(self, host, port, timeout=None, **kwargs):
+ calls.append((host, timeout))
+ if ":" in host:
+ raise httpcore.ConnectTimeout()
+ return Stream()
+ monkeypatch.setattr(httpcore.SyncBackend, "connect_tcp", connect)
+ backend = transport.PinnedBackend(target)
+ stream = backend.connect_tcp("example.com", 443, timeout=5)
+ assert [host for host, _ in calls] == ["2001:4860::1", "8.8.8.8"]
+ assert 0 < calls[0][1] <= 2.5 and calls[0][1] < calls[1][1] <= 5
+ with pytest.raises(FetchFailure, match="fetch_url_blocked"):
+ stream.start_tls(None, "wrong.example", timeout=5)
+ for host, port in (("other.example", 443), ("example.com", 80)):
+ with pytest.raises(FetchFailure):
+ backend.connect_tcp(host, port)
+ with pytest.raises(FetchFailure):
+ backend.connect_unix_socket("/tmp/socket")
+ monkeypatch.setattr(Stream, "get_extra_info", lambda *a: ("127.0.0.1", 443))
+ with pytest.raises(FetchFailure, match="fetch_url_blocked"):
+ backend.connect_tcp("example.com", 443)
+
+
[email protected]("encoding", ["gzip", "br", "zstd", "deflate"])
+def test_bounded_decoders_reject_bombs_and_unadvertised_encoding(encoding):
+ if encoding in {"gzip", "deflate"}:
+ raw = gzip.compress(b"x" * 2048) if encoding == "gzip" else zlib.compress(b"x" * 2048)
+ else:
+ raw = _COMPRESSED[encoding]
+ receiver = transport._Receiver(transport.TransferBudget(), limit=1024)
+ receiver.header(f"Content-Encoding: {encoding}\r\n".encode())
+ receiver.body(raw)
+ with pytest.raises(FetchFailure):
+ receiver.finish(200)
+
+
+def test_announced_unknown_length_and_cumulative_limits():
+ receiver = transport._Receiver(transport.TransferBudget(), limit=10)
+ receiver.header(b"Content-Length: 11\r\n")
+ with pytest.raises(FetchFailure):
+ receiver.header(b"\r\n")
+ budget = transport.TransferBudget()
+ first = transport._Receiver(budget, limit=10)
+ first.body(b"123456")
+ first.finish(200)
+ second = transport._Receiver(budget, limit=10)
+ with pytest.raises(FetchFailure):
+ second.body(b"12345")
+ with pytest.raises(FetchFailure):
+ transport._Receiver(transport.TransferBudget()).header(b"x:" + b"a" * 65536)
+
+
+def test_browser_catalog_native_preset_and_degraded_profile():
+ pytest.importorskip("curl_cffi")
+ assert transport.native_available() == (True, None)
+ target = CheckedTarget(FetchURL("https://example.com/", "example.com", 443, "https", False), ("8.8.8.8",))
+ headers = transport.request_headers(degraded=False, locale="en", previous_origin=target.address.origin, target=target)
+ assert list(headers) == transport.browser_profile()["header_order"]
+ assert headers["Sec-Fetch-Site"] == "same-origin"
diff --git a/tests/test_model_hub_local_fetch.py b/tests/test_model_hub_local_fetch.py
new file mode 100644
index 000000000..70866c6b2
--- /dev/null
+++ b/tests/test_model_hub_local_fetch.py
@@ -0,0 +1,689 @@
+"""WF-LOCAL-003: extraction and local orchestration have no rendering side effects.
+
+Tables distinguish target failures from policy/credential refusals; fake transports
+are confined to this fixture, while the socket boundary is tested separately.
+"""
+import asyncio
+import io
+import json
+import sys
+import time
+
+import pytest
+
+from core.web_fetch_worker import worker, transport
+from core.handlers.model_hub import local_fetch
+from core.web_fetch_worker.extract import extract_page, inert_markdown
+from core.web_fetch_worker.policy import CheckedTarget, FetchFailure, parse_url
+from core.web_fetch_worker.transport import HopResponse
+
+
[email protected]("body,mime,expected", [
+ (b"# Page\n\nReadable text.", "text/markdown", "Readable text."),
+ (b"plain text", "text/plain", "plain text"),
+ (b'{"hello": [1,2]}', "application/json", '"hello"'),
+ (b"{not json", "application/json", "{not json"),
+ (b"<html><title>Heading</title><article><h1>Heading</h1><p>A complete readable article explains the test document.</p></article></html>", "text/html", "complete readable article"),
+ ("<meta charset='gb18030'><article><p>这是网页的正文,编码由元数据提供。</p></article>".encode("gb18030"), "text/html", "这是网页的正文"),
+])
+def test_formats_are_read_without_network(body, mime, expected):
+ page = extract_page(body, mime, "https://example.com/docs/page")
+ assert expected in page.content
+ assert page.content_type == "text/markdown"
+ assert page.source_content_type == mime
+
+
[email protected]("body,mime,code,terminal", [
+ (b"", "text/plain", "fetch_target_unreadable", False),
+ (b" ", "application/json", "fetch_target_unreadable", False),
+ (b"", "text/html", "fetch_target_unreadable", False),
+ (b" ", "text/html", "fetch_target_unreadable", False),
+ (b"<!-- only a comment -->", "text/html", "fetch_target_unreadable", False),
+ (b"PK...", "application/zip", "fetch_unsupported_content", False),
+ (b"<html><script src='/app.js'></script><div id='app'></div></html>", "text/html", "fetch_js_shell", False),
+ (b"<header><form><input type='password'></form></header><div id='root'></div><script src='/app.js'></script>", "text/html", "fetch_js_shell", False),
+ (b"<form id='challenge-form'>Checking</form>", "text/html", "fetch_challenge", False),
+ (b"<form><input type='password'></form>", "text/html", "fetch_refused", True),
+ (b"Access denied", "text/plain", "fetch_challenge", False),
+])
+def test_unreadable_formats_fail_over_but_login_is_terminal(body, mime, code, terminal):
+ with pytest.raises(FetchFailure) as raised:
+ extract_page(body, mime, "https://example.com/")
+ assert (raised.value.code, raised.value.terminal) == (code, terminal)
+
+
[email protected]("body,mime,expected", [
+ (b"caf\xe9", "text/plain; Charset=ISO-8859-1", "café"),
+ (b"caf\xe9", "TEXT/PLAIN; CHARSET=ISO-8859-1", "café"),
+ (b"<meta charset='ISO-8859-1'><article><p>A readable caf\xe9 article.</p></article>", "TEXT/HTML", "café"),
+])
+def test_charset_declarations_are_case_insensitive(body, mime, expected):
+ page = extract_page(body, mime, "https://example.com/")
+ assert expected in page.content and not page.charset_fallback
+
+
+def test_markdown_html_keeps_visible_text_and_literal_code_without_active_markup():
+ text = '''# Install
+
+<Warning>
+Rotate the key before continuing.
+</Warning>
+
+<details><summary>Reason</summary>The visible explanation.</details>
+
+<script>never_execute()</script>
+
+```html
+<script>literal example</script>
+```
+
+Done.'''
+ content = inert_markdown(text, "https://example.com/")
+ for visible in ("Rotate the key", "Reason", "visible explanation", "<script>literal example</script>", "Done."):
+ assert visible in content
+ assert "<Warning>" not in content and "<details>" not in content and "never_execute" not in content
+
+
[email protected]("hint", ["/bad path.md", "/bad\\path.md", "/bad\npath.md", "https://example.com:/bad"])
+def test_malformed_optional_hint_keeps_readable_html(hint):
+ markup = f'<link rel="alternate" type="text/markdown" href="{hint}"><article><p>The original article remains readable.</p></article>'
+ page = extract_page(markup.encode(), "text/html", "https://example.com/")
+ assert page.follow_url is None and "original article" in page.content
+
+
+def test_public_article_with_login_widget_and_xhtml_declaration_is_readable():
+ text = b'''<?xml version="1.0" encoding="UTF-8"?><html><head><title>Public article</title></head>
+ <body><header><form><input type="password">Sign in</form></header><article><h1>Public article</h1>
+ <p>This complete readable article is available without authentication. Its header includes an unrelated login widget.</p>
+ </article></body></html>'''
+ for mime in ("text/html", "application/xhtml+xml"):
+ assert "without authentication" in extract_page(text, mime, "https://example.com/").content
+
+
[email protected]("mime", ["text/plain", "text/markdown"])
+def test_large_text_is_bounded_before_markdown_token_construction(mime):
+ source = ("A readable paragraph with a [link](https://example.com/).\n\n" * 150000).encode()
+ page = extract_page(source, mime, "https://example.com/")
+ assert page.content_overflow and "readable paragraph" in page.content
+ assert len(page.content) < 50000
+
+
+def test_plain_text_preserves_literal_markup_and_numbered_lines():
+ text = 'Usage: tool <input-file> <output-file>\nstd::vector<int> v;\n\n<div>literal</div>\n\n[1]: https://example.com/ref\n1. One\n2. Two'
+ page = extract_page(text.encode(), "text/plain", "https://example.com/")
+ assert text in page.content
+ numbered = inert_markdown("7. Seven\n8. Eight", "https://example.com/")
+ assert "7. Seven" in numbered and "8. Eight" in numbered
+
+
+def test_pdf_text_is_quoted_not_interpreted_as_markup():
+ from pypdf import PdfWriter
+ from pypdf.generic import DictionaryObject, NameObject, DecodedStreamObject
+ writer = PdfWriter()
+ page = writer.add_blank_page(width=600, height=800)
+ font = DictionaryObject({NameObject("/Type"): NameObject("/Font"), NameObject("/Subtype"): NameObject("/Type1"), NameObject("/BaseFont"): NameObject("/Helvetica")})
+ page[NameObject("/Resources")] = DictionaryObject({NameObject("/Font"): DictionaryObject({NameObject("/F1"): font})})
+ stream = DecodedStreamObject()
+ stream.set_data(b"BT /F1 12 Tf 20 700 Td (tool <input-file> std::vector<int>) Tj ET")
+ page[NameObject("/Contents")] = stream
+ output = io.BytesIO()
+ writer.write(output)
+ result = extract_page(output.getvalue(), "application/pdf", "https://example.com/")
+ assert "[Page 1]" in result.content and "tool <input-file> std::vector<int>" in result.content
+
+
+def test_inert_links_images_html_and_metadata():
+ page = extract_page(b'''<html><title>A title</title><link rel="canonical" href="../canonical">
+ <article><h1>A heading</h1><p>Readable article with <a href="../next">next page</a>
+ and <a href="javascript:alert(1)">unsafe link</a>, and meaningful paragraph text.</p>
+ <script>alert('secret')</script><img src="https://images.example/x"><form>unwanted</form></article></html>''',
+ "text/html", "https://example.com/docs/page")
+ assert page.title == "A title"
+ assert page.canonical_url == "https://example.com/canonical"
+ assert "https://example.com/next" in page.content
+ for unsafe in ("javascript:", "<script", "images.example", "unwanted", "secret"):
+ assert unsafe not in page.content
+ result = inert_markdown("[relative](../x) ![alt](https://img.example/x) <script>bad()</script> [ref][r]\n\n[r]: https://good.example/x", "https://example.com/docs/p")
+ assert "https://example.com/x" in result and "https://good.example/x" in result
+ assert "img.example" not in result and "bad()" not in result
+
+
+def test_exact_challenge_text_inside_document_is_not_a_refusal():
+ page = extract_page(b"This article discusses the message Access denied in a web application.", "text/plain", "https://example.com/")
+ assert "Access denied" in page.content
+
+
+def test_charset_fallback_alternate_and_refresh():
+ assert extract_page(b"text \xff", "text/plain", "https://example.com/").charset_fallback
+ for kind, markup in (("alternate", '<link rel="alternate" type="text/markdown" href="/page.md">'),
+ ("refresh", '<meta http-equiv="refresh" content="0; url=/next">')):
+ page = extract_page((markup + "<article><p>Readable document for the alternative format.</p></article>").encode(),
+ "text/html", "https://example.com/")
+ assert page.follow_kind == kind
+ assert page.follow_url.startswith("https://example.com/")
+ page = extract_page(b'<link rel="alternate" type="text/markdown" href="https://other.example/x"><p>Retained text.</p>',
+ "text/html", "https://example.com/")
+ assert page.follow_url is None
+
+
+def test_encrypted_and_textless_pdf_fail_over():
+ from pypdf import PdfWriter
+ for encrypted in (False, True):
+ writer = PdfWriter()
+ writer.add_blank_page(width=100, height=100)
+ if encrypted:
+ writer.encrypt("not-available")
+ data = io.BytesIO()
+ writer.write(data)
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ extract_page(data.getvalue(), "application/pdf", "https://example.com/document")
+
+
+def local_fixture(monkeypatch):
+ calls, gates, events = [], [], []
+ responses = {}
+ def resolve(url):
+ address = parse_url(url) # Real syntax/literal policy, only DNS is fixture-owned.
+ gates.append(address.url)
+ return CheckedTarget(address, ("8.8.8.8",))
+ def hop(target, headers, budget, timeout, on_sent):
+ on_sent()
+ calls.append((target.address.url, headers))
+ item = responses[target.address.url]
+ if isinstance(item, Exception):
+ raise item
+ return item
+ monkeypatch.setattr(worker, "resolve_target", resolve)
+ monkeypatch.setattr(transport, "native_available", lambda: (True, None))
+ monkeypatch.setattr(transport, "curl_hop", hop)
+ monkeypatch.setattr(transport, "httpx_hop", lambda *a: pytest.fail("sent target failure retried on degraded transport"))
+ return responses, calls, gates, events
+
+
+def test_cookie_jar_bounds_outgoing_header_and_validates_prefixes():
+ jar = worker.OriginCookies()
+ address = parse_url("https://example.com/doc")
+ jar.receive(address, [("set-cookie", f"cookie{i}={'x' * 3900}; Path=/") for i in range(70)])
+ assert len(jar.values) == 64
+ assert len(jar.header(address).encode()) <= 48 * 1024
+ jar = worker.OriginCookies()
+ jar.receive(address, [("set-cookie", "__Host-bad=1; Path=/"),
+ ("set-cookie", "__Secure-bad=1"),
+ ("set-cookie", "good=1; Secure; Path=/")])
+ assert jar.header(address) == "good=1"
+
+
+def test_rfc_response_cookies_ignore_attributes_but_remain_origin_only():
+ jar = worker.OriginCookies()
+ address = parse_url("https://www.example.com/doc")
+ jar.receive(address, [("set-cookie", 'prefs={"a":1}; Domain=.example.com; Path=/; Secure; HttpOnly; Priority=High; foo=bar'),
+ ("set-cookie", "partitioned=yes; Secure; Partitioned; Path=/")])
+ assert jar.header(address) == 'prefs={"a":1}; partitioned=yes'
+ assert jar.header(parse_url("https://other.example.com/doc")) == ""
+ assert jar.header(parse_url("https://example.com/doc")) == ""
+
+
+def test_redirect_cookie_scope_and_one_logical_send(local_fixture):
+ responses, calls, gates, events = local_fixture
+ responses.update({
+ "https://example.com/start": HopResponse(302, [("location", "/next"), ("set-cookie", "visit=1; Path=/; Secure")], b""),
+ "https://example.com/next": HopResponse(302, [("location", "https://other.example/final")], b""),
+ "https://other.example/final": HopResponse(200, [("content-type", "text/markdown")], b"# Document\n\nUseful content."),
+ })
+ result = worker.fetch_document("https://example.com/start", "en", events.append)
+ assert result["final_url"] == "https://other.example/final"
+ assert calls[1][1]["Cookie"] == "visit=1" and "Cookie" not in calls[2][1]
+ assert [e for e in events if e["event"] == "sent"] == [{"event": "sent"}]
+ assert all(url in gates for url, _ in calls)
+ events.clear()
+ worker.fetch_document("https://other.example/final", "en", events.append)
+ assert "Cookie" not in calls[-1][1]
+
+
+def test_native_load_failure_selects_honest_transport_before_send(local_fixture, monkeypatch):
+ responses, calls, gates, events = local_fixture
+ monkeypatch.setattr(transport, "native_available", lambda: (False, "native_library_unavailable"))
+ def degraded(target, headers, budget, timeout, on_sent):
+ assert headers["User-Agent"].startswith("Avibe/")
+ assert not any(key.lower().startswith(("sec-ch-", "sec-fetch-")) for key in headers)
+ on_sent()
+ return HopResponse(200, [("content-type", "text/plain")], b"Readable degraded result.")
+ monkeypatch.setattr(transport, "httpx_hop", degraded)
+ monkeypatch.setattr(transport, "curl_hop", lambda *a: pytest.fail("unavailable native library was used"))
+ result = worker.fetch_document("https://example.com/", "en", events.append)
+ assert result["transport_degraded"] and result["transport_degraded_reason"] == "native_library_unavailable"
+
+
[email protected]("status,code,terminal", [
+ (401, "fetch_refused", True), (403, "fetch_challenge", False),
+ (404, "fetch_target_unreadable", False), (410, "fetch_target_unreadable", False),
+ (429, "service_rate_limited", False), (503, "fetch_unavailable", False),
+])
+def test_local_http_outcome_table(local_fixture, status, code, terminal):
+ responses, calls, gates, events = local_fixture
+ responses["https://example.com/"] = HopResponse(status, [("retry-after", "3600")], b"not content")
+ with pytest.raises(FetchFailure) as raised:
+ worker.fetch_document("https://example.com/", "en", events.append)
+ assert (raised.value.code, raised.value.terminal) == (code, terminal)
+ assert len(calls) == 1
+ if status in {429, 503}:
+ assert raised.value.retry_after == "3600"
+
+
+def test_503_explicit_challenge_has_no_transient_host_class(local_fixture):
+ responses, calls, gates, events = local_fixture
+ responses["https://example.com/"] = HopResponse(503, [("cf-mitigated", "challenge")], b"challenge")
+ with pytest.raises(FetchFailure, match="fetch_challenge"):
+ worker.fetch_document("https://example.com/", "en", events.append)
+
+
+def test_redirect_to_private_terminates_without_second_connect(local_fixture):
+ responses, calls, gates, events = local_fixture
+ responses["https://example.com/"] = HopResponse(302, [("location", "http://169.254.169.254/latest")], b"")
+ with pytest.raises(FetchFailure) as raised:
+ worker.fetch_document("https://example.com/", "en", events.append)
+ assert (raised.value.code, raised.value.terminal) == ("fetch_url_blocked", True)
+ assert len(calls) == 1
+
+
[email protected]("alternate_outcome", ["unreadable", "blocked", "success", "rate_limited"])
+def test_one_markdown_alternate_retains_original_except_policy_refusal(local_fixture, monkeypatch, alternate_outcome):
+ responses, calls, gates, events = local_fixture
+ responses["https://example.com/"] = HopResponse(200, [("content-type", "text/html")],
+ b'<title>Original title</title><link rel="canonical" href="/canonical"><link rel="alternate" type="text/markdown" href="/alternate"><article><p>Original readable HTML article text.</p></article>')
+ responses["https://example.com/alternate"] = (HopResponse(200, [("content-type", "text/markdown")], b"Better Markdown body.")
+ if alternate_outcome == "success" else HopResponse(404, [], b""))
+ if alternate_outcome == "rate_limited":
+ responses["https://example.com/alternate"] = HopResponse(429, [("retry-after", "3600")], b"")
+ if alternate_outcome == "blocked":
+ original = worker.resolve_target
+ def resolve(url):
+ if url.endswith("/alternate"):
+ raise FetchFailure("fetch_dns_unverified", terminal=True)
+ return original(url)
+ monkeypatch.setattr(worker, "resolve_target", resolve)
+ with pytest.raises(FetchFailure, match="fetch_dns_unverified"):
+ worker.fetch_document("https://example.com/", "en", events.append)
+ assert len(calls) == 1
+ else:
+ result = worker.fetch_document("https://example.com/", "en", events.append)
+ assert ("Better Markdown" if alternate_outcome == "success" else "Original readable") in result["content"]
+ if alternate_outcome == "rate_limited":
+ assert result["cooldown_code"] == "service_rate_limited" and result["retry_after"] == "3600"
+ assert result["title"] == "Original title" and result["canonical_url"] == "https://example.com/canonical"
+ assert len(calls) == 2
+
+
[email protected]("shape", ["loop", "missing_location", "hop_limit"])
+def test_redirect_protocol_failure_is_target_scoped(local_fixture, shape):
+ responses, _, _, events = local_fixture
+ if shape == "loop":
+ responses["https://example.com/"] = HopResponse(302, [("location", "/")], b"")
+ elif shape == "missing_location":
+ responses["https://example.com/"] = HopResponse(302, [], b"")
+ else:
+ for n in range(6):
+ url = "https://example.com/" + (str(n) if n else "")
+ responses[url] = HopResponse(302, [("location", f"/{n + 1}")], b"")
+ with pytest.raises(FetchFailure, match="fetch_target_unreadable"):
+ worker.fetch_document("https://example.com/", "en", events.append)
+
+
+def test_short_attempt_dns_deadline_differs_from_real_dns_failure(local_fixture, monkeypatch):
+ _, _, _, events = local_fixture
+ original = worker.resolve_target
+ def slow(url):
+ time.sleep(.04)
+ return original(url)
+ monkeypatch.setattr(worker, "resolve_target", slow)
+ with pytest.raises(FetchFailure) as raised:
+ worker.fetch_document("https://example.com/", "en", events.append, remaining_seconds=.005)
+ assert raised.value.code == "service_busy" and not raised.value.terminal and raised.value.cooldown_suppressed
+ def unavailable(url):
+ raise FetchFailure("fetch_dns_unverified", terminal=True)
+ monkeypatch.setattr(worker, "resolve_target", unavailable)
+ with pytest.raises(FetchFailure) as raised:
+ worker.fetch_document("https://example.com/", "en", events.append)
+ assert raised.value.code == "fetch_dns_unverified" and raised.value.terminal
+
+
+def test_gate_worker_does_not_load_http_or_extraction_stack(tmp_path):
+ """The mandatory gate works even when no local fetch stack can be loaded."""
+ import subprocess
+ from pathlib import Path
+
+ code = '''import importlib.abc,sys
+sys.path.insert(0,sys.argv.pop(1))
+class PolicyOnly(importlib.abc.MetaPathFinder):
+ def find_spec(self,fullname,path=None,target=None):
+ if fullname.rsplit(".",1)[-1] in {"transport","extract"} or fullname.split(".",1)[0] in {"httpx","httpcore","curl_cffi","lxml","trafilatura","pypdf"}:
+ raise AssertionError("gate attempted unrelated import: " + fullname)
+sys.meta_path.insert(0,PolicyOnly())
+from core.web_fetch_worker.worker import main
+main()
+'''
+ result = subprocess.run(
+ [sys.executable, "-I", "-B", "-c", code, str(Path(__file__).resolve().parents[1])],
+ input=json.dumps({"operation": "gate", "url": "https://8.8.8.8/"}) + "\n",
+ capture_output=True, text=True, cwd=tmp_path, timeout=5,
+ )
+ assert result.returncode == 0, result.stderr
+ assert json.loads(result.stdout) == {"event": "result", "result": {"url": "https://8.8.8.8/"}}
+
+
+async def test_gate_worker_and_initial_policy_failure_do_not_send():
+ engine = local_fetch.LocalFetchEngine()
+ assert await engine.check("https://8.8.8.8/", deadline=time.monotonic() + 5) == "https://8.8.8.8/"
+ with pytest.raises(FetchFailure, match="fetch_url_blocked"):
+ await engine.fetch("http://127.0.0.1/", deadline=time.monotonic() + 5)
+
+
+async def test_host_lock_serializes_requests_and_scrubs_worker_environment(monkeypatch):
+ monkeypatch.setenv("OPENAI_API_KEY", "test-owned-value-must-not-be-inherited")
+ script = '''import sys,time,json,os
+assert "OPENAI_API_KEY" not in os.environ
+sys.stdin.readline()
+print(json.dumps({"event":"host","host":"example.com"}),flush=True); sys.stdin.readline()
+print(json.dumps({"event":"sent"}),flush=True); sys.stdin.readline()
+time.sleep(.2)
+print(json.dumps({"event":"result","result":{"content":"done"}}),flush=True)
+'''
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ engine, starts = local_fetch.LocalFetchEngine(), []
+ results = await asyncio.gather(*(engine.fetch("https://example.com/", deadline=time.monotonic() + 5,
+ on_sent=lambda: starts.append(time.monotonic())) for _ in range(2)))
+ assert all(row["sent"] for row in results)
+ assert len(starts) == 2 and starts[1] - starts[0] >= .18
+
+
[email protected]("retained_html", [False, True])
+async def test_local_retry_after_is_host_scoped_and_degraded_failure_is_recorded(monkeypatch, retained_html):
+ script = '''import sys,json
+from urllib.parse import urlsplit
+request=json.loads(sys.stdin.readline())
+for event in [{"event":"transport","transport_degraded":True,"transport_degraded_reason":"native_library_unavailable"},
+ {"event":"host","host":urlsplit(request["url"]).hostname}, {"event":"sent"}]:
+ print(json.dumps(event),flush=True); sys.stdin.readline()
+print(json.dumps({"event":"failure","error_code":"service_rate_limited","retry_after":"3600","terminal":False}),flush=True)
+'''
+ if retained_html:
+ script = script.replace('{"event":"failure","error_code":"service_rate_limited","retry_after":"3600","terminal":False}',
+ '{"event":"result","result":{"content":"retained HTML","cooldown_code":"service_rate_limited","retry_after":"3600"}}')
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ engine, sent = local_fetch.LocalFetchEngine(), []
+ async def fetch(host):
+ return await engine.fetch(f"https://{host}/", deadline=time.monotonic() + 5, on_sent=lambda: sent.append(host))
+ first, second, other = await fetch("example.com"), await fetch("example.com"), await fetch("other.example")
+ assert first["transport_degraded"] and first["transport_degraded_reason"] == "native_library_unavailable"
+ if retained_html:
+ assert first["content"] == "retained HTML" and "error_code" not in first and "cooldown_code" not in first
+ assert engine._cooldowns["example.com"][0] >= time.time() + 3590
+ assert second["skipped"] == "cooling" and not second["sent"]
+ assert other["sent"] and sent == ["example.com", "other.example"]
+
+
[email protected]("retained_html", [False, True])
+async def test_queued_redirect_observes_rate_limit_before_host_is_released(monkeypatch, retained_html):
+ """A queued redirect cannot slip between worker cleanup and health publication."""
+ limited_result = ({"event": "result", "result": {"content": "retained HTML", "cooldown_code": "service_rate_limited", "retry_after": "3600"}}
+ if retained_html else {"event": "failure", "error_code": "service_rate_limited", "retry_after": "3600", "terminal": False})
+ script = '''import sys,json
+from urllib.parse import urlsplit
+request=json.loads(sys.stdin.readline())
+host=urlsplit(request["url"]).hostname
+for event in [{"event":"host","host":host}, {"event":"sent"}]:
+ print(json.dumps(event),flush=True); sys.stdin.readline()
+if host == "limited.example":
+ print(json.dumps(LIMITED_RESULT),flush=True)
+else:
+ print(json.dumps({"event":"host","host":"limited.example"}),flush=True)
+ if sys.stdin.readline():
+ print(json.dumps({"event":"result","result":{"content":"bypassed Retry-After"}}),flush=True)
+'''.replace("LIMITED_RESULT", repr(limited_result))
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ engine = local_fetch.LocalFetchEngine()
+ started, queued = asyncio.Event(), asyncio.Event()
+ change_host = engine._change_host
+ async def observe_redirect(host, state):
+ if host == "limited.example" and state["held_host"] == "other.example":
+ queued.set()
+ await change_host(host, state)
+ monkeypatch.setattr(engine, "_change_host", observe_redirect)
+ async def first_sent():
+ started.set()
+ await queued.wait()
+ first = asyncio.create_task(engine.fetch("https://limited.example/", deadline=time.monotonic() + 5, on_sent=first_sent))
+ second = None
+ try:
+ await asyncio.wait_for(started.wait(), 3)
+ second = asyncio.create_task(engine.fetch("https://other.example/", deadline=time.monotonic() + 5))
+ limited, redirected = await asyncio.gather(first, second)
+ assert limited.get("content") == "retained HTML" if retained_html else limited["error_code"] == "service_rate_limited"
+ assert redirected.get("skipped") == "cooling" and "content" not in redirected
+ assert engine._cooldowns["limited.example"][0] >= time.time() + 3590
+ assert not engine._hosts and engine._workers["fetch"] == 0
+ finally:
+ for task in (first, second):
+ if task is not None:
+ task.cancel()
+ await asyncio.gather(*(task for task in (first, second) if task is not None), return_exceptions=True)
+
+
+async def test_busy_host_does_not_starve_policy_gate_or_other_hosts(monkeypatch):
+ script = '''import sys,time,json
+from urllib.parse import urlsplit
+r=json.loads(sys.stdin.readline())
+if r["operation"] == "gate":
+ print(json.dumps({"event":"result","result":{"url":r["url"]}}),flush=True); sys.exit()
+host=urlsplit(r["url"]).hostname
+print(json.dumps({"event":"host","host":host}),flush=True); sys.stdin.readline()
+print(json.dumps({"event":"sent"}),flush=True); sys.stdin.readline()
+if host == "example.com": time.sleep(60)
+print(json.dumps({"event":"result","result":{"content":"other host"}}),flush=True)
+'''
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ engine, started = local_fetch.LocalFetchEngine(), asyncio.Event()
+ spawned, spawn = [], asyncio.create_subprocess_exec
+ async def capture(*args, **kwargs):
+ spawned.append(1)
+ return await spawn(*args, **kwargs)
+ monkeypatch.setattr(asyncio, "create_subprocess_exec", capture)
+ tasks = [asyncio.create_task(engine.fetch("https://example.com/", deadline=time.monotonic() + 10, on_sent=started.set)) for _ in range(40)]
+ try:
+ await asyncio.wait_for(started.wait(), 5)
+ assert await engine.check("https://other.example/", deadline=time.monotonic() + 2) == "https://other.example/"
+ other = await engine.fetch("https://other.example/", deadline=time.monotonic() + 2)
+ assert other["sent"] and other["content"] == "other host"
+ queued = await engine.fetch("https://example.com/", deadline=time.monotonic() + .3)
+ assert queued["error_code"] == "service_busy" and not queued["sent"]
+ assert not engine._cooldowns
+ assert len(spawned) <= 4 # One same-host worker, independent gate and other host; not 40 parked workers.
+ finally:
+ for task in tasks:
+ task.cancel()
+ await asyncio.gather(*tasks, return_exceptions=True)
+
+
+async def test_parent_memory_limit_kills_worker_and_keeps_known_alternate_fallback(monkeypatch):
+ script = '''import sys,time,json
+sys.stdin.readline()
+print(json.dumps({"event":"sent"}),flush=True); sys.stdin.readline()
+print(json.dumps({"event":"fallback","result":{"content":"original HTML","final_url":"https://example.com/"}}),flush=True); sys.stdin.readline()
+time.sleep(60)
+'''
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ engine = local_fetch.LocalFetchEngine()
+ result = await engine.fetch("https://example.com/", deadline=time.monotonic() + .5)
+ assert result["sent"] and result["content"] == "original HTML" and "error_code" not in result
+ # Separate actual RSS-supervision case: lower only this fixture's threshold.
+ monkeypatch.setattr(local_fetch, "_MEMORY_LIMIT", 1)
+ monkeypatch.setattr(local_fetch, "_WORKER", "import sys,time; sys.stdin.readline(); time.sleep(60)")
+ started = time.monotonic()
+ result = await engine.fetch("https://example.com/", deadline=time.monotonic() + 5)
+ assert result["error_code"] == "fetch_unavailable" and time.monotonic() - started < 3
+
+
[email protected]("sent", [False, True])
[email protected]("phase", ["policy", "fetch"])
+async def test_attempt_expiry_during_revalidation_is_not_a_dns_refusal(monkeypatch, sent, phase):
+ script = '''import sys,time,json
+sys.stdin.readline()
+for event in EVENTS:
+ print(json.dumps(event),flush=True); sys.stdin.readline()
+time.sleep(60)
+'''.replace("EVENTS", repr([{"event": "host", "host": "example.com"}] +
+ ([{"event": "sent"}] if sent else []) + [{"event": "phase", "phase": phase}]))
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ engine = local_fetch.LocalFetchEngine()
+ result = await engine.fetch("https://example.com/", deadline=time.monotonic() + .3)
+ code = "service_busy" if not sent and phase == "policy" else "fetch_timeout"
+ assert result["error_code"] == code and not result["terminal"]
+ assert result["sent"] == sent and not engine._cooldowns
+ if code == "service_busy":
+ assert result["skipped"] == "unavailable"
+ with pytest.raises(FetchFailure, match="fetch_dns_unverified"):
+ await engine.check("https://example.com/", deadline=time.monotonic() + .3)
+
+
[email protected]("remaining,elapsed,sent,timeout_type,suppressed", [
+ (30, 5, False, "connect", False),
+ (1, 1, False, "connect", True),
+ (30, 30, True, "read", True),
+])
+def test_hop_timeout_only_cools_when_it_had_its_own_connect_budget(
+ local_fixture, monkeypatch, remaining, elapsed, sent, timeout_type, suppressed
+):
+ import httpcore
+ from types import SimpleNamespace
+ _, _, _, events = local_fixture
+ clock = SimpleNamespace(now=0)
+ monkeypatch.setattr(worker, "time", SimpleNamespace(monotonic=lambda: clock.now, time=time.time))
+
+ def timed_out(target, headers, budget, timeout, on_sent):
+ if sent:
+ on_sent()
+ clock.now += elapsed
+ raise (httpcore.ReadTimeout if timeout_type == "read" else httpcore.ConnectTimeout)()
+
+ monkeypatch.setattr(transport, "curl_hop", timed_out)
+ with pytest.raises(FetchFailure) as raised:
+ worker.fetch_document("https://example.com/", "en", events.append, remaining_seconds=remaining)
+ assert raised.value.code == "fetch_timeout" and raised.value.cooldown_suppressed == suppressed
+
+async def test_stop_during_success_cleanup_is_rethrown_after_reap(monkeypatch):
+ script = 'import sys; sys.stdin.readline(); print(\'{"event":"result","result":{"content":"page"}}\',flush=True)'
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ cleaning, release = asyncio.Event(), asyncio.Event()
+ async def monitor(process):
+ try:
+ await asyncio.Future()
+ except asyncio.CancelledError:
+ cleaning.set()
+ await release.wait()
+ raise
+ monkeypatch.setattr(local_fetch.LocalFetchEngine, "_monitor", staticmethod(monitor))
+ task = asyncio.create_task(local_fetch.LocalFetchEngine().fetch("https://example.com/", deadline=time.monotonic() + 5))
+ await asyncio.wait_for(cleaning.wait(), 5)
+ task.cancel()
+ await asyncio.sleep(0)
+ assert not task.done()
+ release.set()
+ with pytest.raises(asyncio.CancelledError):
+ await task
+
+
+async def test_active_worker_cap_and_cancellation_safe_host_release(monkeypatch):
+ script = '''import sys,time,json
+from urllib.parse import urlsplit
+request=json.loads(sys.stdin.readline())
+print(json.dumps({"event":"host","host":urlsplit(request["url"]).hostname}),flush=True); sys.stdin.readline()
+print('{"event":"sent"}',flush=True); sys.stdin.readline()
+time.sleep(60)
+'''
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ children, spawn = [], asyncio.create_subprocess_exec
+ reaping, release = asyncio.Event(), asyncio.Event()
+ async def capture(*args, **kwargs):
+ child = await spawn(*args, **kwargs)
+ children.append(child)
+ if len(children) == 1:
+ wait = child.wait
+ async def delayed_reap():
+ reaping.set()
+ await release.wait()
+ return await wait()
+ monkeypatch.setattr(child, "wait", delayed_reap)
+ return child
+ monkeypatch.setattr(asyncio, "create_subprocess_exec", capture)
+ engine, began = local_fetch.LocalFetchEngine(), asyncio.Event()
+ first = asyncio.create_task(engine.fetch("https://example.com/", deadline=time.monotonic() + 10, on_sent=began.set))
+ await asyncio.wait_for(began.wait(), 5)
+ first.cancel()
+ await asyncio.wait_for(reaping.wait(), 5)
+ first.cancel() # Stop arriving during timeout/Stop cleanup must not strand admission.
+ release.set()
+ with pytest.raises(asyncio.CancelledError):
+ await first
+ assert children[0].returncode is not None
+ began.clear()
+ again = asyncio.create_task(engine.fetch("https://example.com/", deadline=time.monotonic() + 10, on_sent=began.set))
+ try:
+ await asyncio.wait_for(began.wait(), 2)
+ finally:
+ again.cancel()
+ await asyncio.gather(again, return_exceptions=True)
+ children.clear()
+ # Distinct hosts still have one aggregate process cap.
+ tasks = [asyncio.create_task(engine.fetch(f"https://host{i}.example/", deadline=time.monotonic() + 10)) for i in range(20)]
+ try:
+ await asyncio.sleep(.3)
+ assert 1 <= len(children) <= 8
+ finally:
+ for task in tasks:
+ task.cancel()
+ await asyncio.gather(*tasks, return_exceptions=True)
+ assert all(child.returncode is not None for child in children)
+
+
[email protected](sys.platform == "win32", reason="POSIX inherited rlimits")
+def test_worker_respects_stricter_inherited_kernel_limits():
+ import subprocess
+ from pathlib import Path
+ code = '''import resource,sys,json
+sys.path.insert(0,sys.argv[1])
+from core.web_fetch_worker.worker import resource_limits
+resource.setrlimit(resource.RLIMIT_CPU,(20,20))
+resource.setrlimit(resource.RLIMIT_FSIZE,(65536,65536))
+resource_limits()
+print(json.dumps([resource.getrlimit(resource.RLIMIT_CPU),resource.getrlimit(resource.RLIMIT_FSIZE)]))
+'''
+ result = subprocess.run([sys.executable, "-I", "-B", "-c", code, str(Path(__file__).resolve().parents[1])],
+ capture_output=True, text=True, check=True, timeout=30)
+ assert json.loads(result.stdout) == [[20, 20], [65536, 65536]]
+
+
+async def test_timeout_and_stop_kill_and_reap_worker(monkeypatch):
+ # A test-owned worker simulates a parser that cannot yield to cancellation.
+ # The real parent must terminate it; no production network override exists.
+ script = "import sys,time; sys.stdin.readline(); print('{\"event\":\"sent\"}',flush=True); sys.stdin.readline(); time.sleep(60)"
+ monkeypatch.setattr(local_fetch, "_WORKER", script)
+ children = []
+ spawn = asyncio.create_subprocess_exec
+ async def capture(*args, **kwargs):
+ child = await spawn(*args, **kwargs)
+ children.append(child)
+ return child
+ monkeypatch.setattr(asyncio, "create_subprocess_exec", capture)
+ engine = local_fetch.LocalFetchEngine()
+ sent = []
+ result = await engine.fetch("https://example.com/", deadline=time.monotonic() + 0.5, on_sent=lambda: sent.append(1))
+ assert result["error_code"] == "fetch_timeout" and result["sent"]
+ assert sent == [1] and children[0].returncode is not None
+ called = asyncio.Event()
+ task = asyncio.create_task(engine.fetch("https://example.com/", deadline=time.monotonic() + 30, on_sent=called.set))
+ await asyncio.wait_for(called.wait(), 5)
+ task.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await task
+ assert children[1].returncode is not None
diff --git a/tests/test_sentry_integration.py b/tests/test_sentry_integration.py
index e149d8a2d..22228336e 100644
--- a/tests/test_sentry_integration.py
+++ b/tests/test_sentry_integration.py
@@ -719,9 +719,18 @@ def test_init_sentry_disables_spotlight_env_bypass(monkeypatch, tmp_path):
sentry_sdk.get_global_scope().set_client(None)
+def _decode_sentry_wire_body(body, headers):
+ if headers["Content-Encoding"] == "br":
+ import brotli
+ return brotli.decompress(body)
+ import gzip
+
+ assert headers["Content-Encoding"] == "gzip"
+ return gzip.decompress(body)
+
+
def test_performance_transactions_are_scrubbed_like_events(monkeypatch, tmp_path):
"""Transactions skip ``before_send``; their spans must not carry what events may not."""
- import gzip
import sentry_sdk
from sentry_sdk.envelope import Envelope
@@ -761,7 +770,7 @@ def test_performance_transactions_are_scrubbed_like_events(monkeypatch, tmp_path
sentry_sdk.get_global_scope().set_client(None)
(body, headers), = sent
- raw = gzip.decompress(body) if headers.get("Content-Encoding") == "gzip" else body
+ raw = _decode_sentry_wire_body(body, headers)
envelope = Envelope.deserialize(raw)
payload = next(item.get_bytes().decode("utf-8") for item in envelope.items if item.type == "transaction")
assert "s3cret" not in payload
@@ -769,7 +778,6 @@ def test_performance_transactions_are_scrubbed_like_events(monkeypatch, tmp_path
def test_real_sdk_event_shapes_preserve_protocol_ownership(monkeypatch, tmp_path):
- import gzip
import json
import sentry_sdk
@@ -822,7 +830,7 @@ def test_real_sdk_event_shapes_preserve_protocol_ownership(monkeypatch, tmp_path
sentry_sdk.get_global_scope().set_client(None)
(body, headers), = sent
- raw = gzip.decompress(body) if headers.get("Content-Encoding") == "gzip" else body
+ raw = _decode_sentry_wire_body(body, headers)
envelope = Envelope.deserialize(raw)
payload = json.loads(next(item.get_bytes() for item in envelope.items if item.type == "event"))
assert payload["logentry"]["message"] == "failure"
@@ -833,7 +841,6 @@ def test_real_sdk_event_shapes_preserve_protocol_ownership(monkeypatch, tmp_path
def test_worker_scrub_retains_rotated_secret_after_enqueue(monkeypatch, tmp_path):
"""A value queued before rotation remains covered by the process-lifetime union."""
- import gzip
import threading
import sentry_sdk
@@ -888,7 +895,7 @@ def test_worker_scrub_retains_rotated_secret_after_enqueue(monkeypatch, tmp_path
try:
(body, headers), = sent
- raw = gzip.decompress(body) if headers.get("Content-Encoding") == "gzip" else body
+ raw = _decode_sentry_wire_body(body, headers)
assert "old-worker-s3cret" not in raw.decode("utf-8")
finally:
sentry_sdk.get_client().close(timeout=0)
diff --git a/uv.lock b/uv.lock
index f142fbefa..400e33d5d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -3,14 +3,14 @@ revision = 5
requires-python = ">=3.10"
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
"python_full_version < '3.11' and sys_platform == 'win32'",
"python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
@@ -378,9 +378,10 @@ dependencies = [
{ name = "claude-agent-sdk", version = "0.2.162", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'win32'" },
{ name = "cryptography", version = "48.0.1", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine == 'x86_64' and sys_platform == 'darwin'" },
{ name = "cryptography", version = "50.0.2", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine != 'x86_64' or sys_platform != 'darwin'" },
+ { name = "curl-cffi", marker = "(platform_machine == 'arm64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32')" },
{ name = "discord-py" },
{ name = "fastapi" },
- { name = "httpx", extra = ["socks"] },
+ { name = "httpx", extra = ["http2", "socks"] },
{ name = "idna" },
{ name = "ijson" },
{ name = "imagesize" },
@@ -394,6 +395,7 @@ dependencies = [
{ name = "psutil" },
{ name = "pycryptodome" },
{ name = "pyjwt", extra = ["crypto"] },
+ { name = "pypdf" },
{ name = "python-multipart" },
{ name = "python-socks", extra = ["asyncio"] },
{ name = "pywebpush" },
@@ -406,6 +408,7 @@ dependencies = [
{ name = "starlette", version = "1.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
{ name = "starlette", version = "1.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
{ name = "tomli", marker = "python_full_version < '3.11'" },
+ { name = "trafilatura" },
{ name = "typing-extensions" },
{ name = "uvicorn", extra = ["standard"] },
]
@@ -428,9 +431,10 @@ requires-dist = [
{ name = "claude-agent-sdk", marker = "sys_platform == 'win32'", specifier = ">=0.2.158,<0.2.160" },
{ name = "cryptography", marker = "platform_machine != 'x86_64' or sys_platform != 'darwin'", specifier = ">=50.0.2" },
{ name = "cryptography", marker = "platform_machine == 'x86_64' and sys_platform == 'darwin'", specifier = "==48.0.1" },
+ { name = "curl-cffi", marker = "(platform_machine == 'arm64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32')", specifier = "==0.16.3" },
{ name = "discord-py", specifier = ">=2.4.0" },
{ name = "fastapi", specifier = ">=0.110" },
- { name = "httpx", extras = ["socks"], specifier = ">=0.27" },
+ { name = "httpx", extras = ["http2", "socks"], specifier = ">=0.27" },
{ name = "idna", specifier = ">=3.4" },
{ name = "ijson", specifier = ">=3.5.1" },
{ name = "imagesize", specifier = ">=1.4.1" },
@@ -443,6 +447,7 @@ requires-dist = [
{ name = "psutil", specifier = ">=7.1.0" },
{ name = "pycryptodome", specifier = ">=3.20" },
{ name = "pyjwt", extras = ["crypto"], specifier = ">=2.15.0" },
+ { name = "pypdf", specifier = ">=6.21.2" },
{ name = "python-multipart", specifier = ">=0.0.9" },
{ name = "python-socks", extras = ["asyncio"], specifier = ">=2.0.0" },
{ name = "pywebpush", specifier = ">=2.0.3" },
@@ -453,6 +458,7 @@ requires-dist = [
{ name = "sqlalchemy", specifier = ">=2.0.0" },
{ name = "starlette", specifier = ">=1.3.1" },
{ name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=2.0.1" },
+ { name = "trafilatura", specifier = ">=2.3.1" },
{ name = "typing-extensions", specifier = ">=4.12.2" },
{ name = "uvicorn", extras = ["standard"], specifier = ">=0.27" },
]
@@ -464,6 +470,15 @@ dev = [
{ name = "pytest-asyncio", specifier = ">=1.4.0" },
]
+[[package]]
+name = "babel"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
+]
+
[[package]]
name = "backports-asyncio-runner"
version = "1.2.0"
@@ -566,91 +581,165 @@ wheels = [
[[package]]
name = "charset-normalizer"
-version = "3.4.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1d/35/02daf95b9cd686320bb622eb148792655c9412dbb9b67abb5694e5910a24/charset_normalizer-3.4.5.tar.gz", hash = "sha256:95adae7b6c42a6c5b5b559b1a99149f090a57128155daeea91732c8d970d8644", size = 134804, upload-time = "2026-03-06T06:03:19.46Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/a7/21/a2b1505639008ba2e6ef03733a81fc6cfd6a07ea6139a2b76421230b8dad/charset_normalizer-3.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4167a621a9a1a986c73777dbc15d4b5eac8ac5c10393374109a343d4013ec765", size = 283319, upload-time = "2026-03-06T06:00:26.433Z" },
- { url = "https://files.pythonhosted.org/packages/70/67/df234c29b68f4e1e095885c9db1cb4b69b8aba49cf94fac041db4aaf1267/charset_normalizer-3.4.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f64c6bf8f32f9133b668c7f7a7cbdbc453412bc95ecdbd157f3b1e377a92990", size = 189974, upload-time = "2026-03-06T06:00:28.222Z" },
- { url = "https://files.pythonhosted.org/packages/df/7f/fc66af802961c6be42e2c7b69c58f95cbd1f39b0e81b3365d8efe2a02a04/charset_normalizer-3.4.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:568e3c34b58422075a1b49575a6abc616d9751b4d61b23f712e12ebb78fe47b2", size = 207866, upload-time = "2026-03-06T06:00:29.769Z" },
- { url = "https://files.pythonhosted.org/packages/c9/23/404eb36fac4e95b833c50e305bba9a241086d427bb2167a42eac7c4f7da4/charset_normalizer-3.4.5-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:036c079aa08a6a592b82487f97c60b439428320ed1b2ea0b3912e99d30c77765", size = 203239, upload-time = "2026-03-06T06:00:31.086Z" },
- { url = "https://files.pythonhosted.org/packages/4b/2f/8a1d989bfadd120c90114ab33e0d2a0cbde05278c1fc15e83e62d570f50a/charset_normalizer-3.4.5-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:340810d34ef83af92148e96e3e44cb2d3f910d2bf95e5618a5c467d9f102231d", size = 196529, upload-time = "2026-03-06T06:00:32.608Z" },
- { url = "https://files.pythonhosted.org/packages/a5/0c/c75f85ff7ca1f051958bb518cd43922d86f576c03947a050fbedfdfb4f15/charset_normalizer-3.4.5-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:cd2d0f0ec9aa977a27731a3209ebbcacebebaf41f902bd453a928bfd281cf7f8", size = 184152, upload-time = "2026-03-06T06:00:33.93Z" },
- { url = "https://files.pythonhosted.org/packages/f9/20/4ed37f6199af5dde94d4aeaf577f3813a5ec6635834cda1d957013a09c76/charset_normalizer-3.4.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0b362bcd27819f9c07cbf23db4e0e8cd4b44c5ecd900c2ff907b2b92274a7412", size = 195226, upload-time = "2026-03-06T06:00:35.469Z" },
- { url = "https://files.pythonhosted.org/packages/28/31/7ba1102178cba7c34dcc050f43d427172f389729e356038f0726253dd914/charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:77be992288f720306ab4108fe5c74797de327f3248368dfc7e1a916d6ed9e5a2", size = 192933, upload-time = "2026-03-06T06:00:36.83Z" },
- { url = "https://files.pythonhosted.org/packages/4b/23/f86443ab3921e6a60b33b93f4a1161222231f6c69bc24fb18f3bee7b8518/charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:8b78d8a609a4b82c273257ee9d631ded7fac0d875bdcdccc109f3ee8328cfcb1", size = 185647, upload-time = "2026-03-06T06:00:38.367Z" },
- { url = "https://files.pythonhosted.org/packages/82/44/08b8be891760f1f5a6d23ce11d6d50c92981603e6eb740b4f72eea9424e2/charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ba20bdf69bd127f66d0174d6f2a93e69045e0b4036dc1ca78e091bcc765830c4", size = 209533, upload-time = "2026-03-06T06:00:41.931Z" },
- { url = "https://files.pythonhosted.org/packages/3b/5f/df114f23406199f8af711ddccfbf409ffbc5b7cdc18fa19644997ff0c9bb/charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:76a9d0de4d0eab387822e7b35d8f89367dd237c72e82ab42b9f7bf5e15ada00f", size = 195901, upload-time = "2026-03-06T06:00:43.978Z" },
- { url = "https://files.pythonhosted.org/packages/07/83/71ef34a76fe8aa05ff8f840244bda2d61e043c2ef6f30d200450b9f6a1be/charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8fff79bf5978c693c9b1a4d71e4a94fddfb5fe744eb062a318e15f4a2f63a550", size = 204950, upload-time = "2026-03-06T06:00:45.202Z" },
- { url = "https://files.pythonhosted.org/packages/58/40/0253be623995365137d7dc68e45245036207ab2227251e69a3d93ce43183/charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c7e84e0c0005e3bdc1a9211cd4e62c78ba80bc37b2365ef4410cd2007a9047f2", size = 198546, upload-time = "2026-03-06T06:00:46.481Z" },
- { url = "https://files.pythonhosted.org/packages/ed/5c/5f3cb5b259a130895ef5ae16b38eaf141430fa3f7af50cd06c5d67e4f7b2/charset_normalizer-3.4.5-cp310-cp310-win32.whl", hash = "sha256:58ad8270cfa5d4bef1bc85bd387217e14ff154d6630e976c6f56f9a040757475", size = 132516, upload-time = "2026-03-06T06:00:47.924Z" },
- { url = "https://files.pythonhosted.org/packages/a5/c3/84fb174e7770f2df2e1a2115090771bfbc2227fb39a765c6d00568d1aab4/charset_normalizer-3.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:02a9d1b01c1e12c27883b0c9349e0bcd9ae92e727ff1a277207e1a262b1cbf05", size = 142906, upload-time = "2026-03-06T06:00:49.389Z" },
- { url = "https://files.pythonhosted.org/packages/d7/b2/6f852f8b969f2cbd0d4092d2e60139ab1af95af9bb651337cae89ec0f684/charset_normalizer-3.4.5-cp310-cp310-win_arm64.whl", hash = "sha256:039215608ac7b358c4da0191d10fc76868567fbf276d54c14721bdedeb6de064", size = 133258, upload-time = "2026-03-06T06:00:51.051Z" },
- { url = "https://files.pythonhosted.org/packages/8f/9e/bcec3b22c64ecec47d39bf5167c2613efd41898c019dccd4183f6aa5d6a7/charset_normalizer-3.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:610f72c0ee565dfb8ae1241b666119582fdbfe7c0975c175be719f940e110694", size = 279531, upload-time = "2026-03-06T06:00:52.252Z" },
- { url = "https://files.pythonhosted.org/packages/58/12/81fd25f7e7078ab5d1eedbb0fac44be4904ae3370a3bf4533c8f2d159acd/charset_normalizer-3.4.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60d68e820af339df4ae8358c7a2e7596badeb61e544438e489035f9fbf3246a5", size = 188006, upload-time = "2026-03-06T06:00:53.8Z" },
- { url = "https://files.pythonhosted.org/packages/ae/6e/f2d30e8c27c1b0736a6520311982cf5286cfc7f6cac77d7bc1325e3a23f2/charset_normalizer-3.4.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b473fc8dca1c3ad8559985794815f06ca3fc71942c969129070f2c3cdf7281", size = 205085, upload-time = "2026-03-06T06:00:55.311Z" },
- { url = "https://files.pythonhosted.org/packages/d0/90/d12cefcb53b5931e2cf792a33718d7126efb116a320eaa0742c7059a95e4/charset_normalizer-3.4.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d4eb8ac7469b2a5d64b5b8c04f84d8bf3ad340f4514b98523805cbf46e3b3923", size = 200545, upload-time = "2026-03-06T06:00:56.532Z" },
- { url = "https://files.pythonhosted.org/packages/03/f4/44d3b830a20e89ff82a3134912d9a1cf6084d64f3b95dcad40f74449a654/charset_normalizer-3.4.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bcb3227c3d9aaf73eaaab1db7ccd80a8995c509ee9941e2aae060ca6e4e5d81", size = 193863, upload-time = "2026-03-06T06:00:57.823Z" },
- { url = "https://files.pythonhosted.org/packages/25/4b/f212119c18a6320a9d4a730d1b4057875cdeabf21b3614f76549042ef8a8/charset_normalizer-3.4.5-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:75ee9c1cce2911581a70a3c0919d8bccf5b1cbc9b0e5171400ec736b4b569497", size = 181827, upload-time = "2026-03-06T06:00:59.323Z" },
- { url = "https://files.pythonhosted.org/packages/74/00/b26158e48b425a202a92965f8069e8a63d9af1481dfa206825d7f74d2a3c/charset_normalizer-3.4.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d1401945cb77787dbd3af2446ff2d75912327c4c3a1526ab7955ecf8600687c", size = 191085, upload-time = "2026-03-06T06:01:00.546Z" },
- { url = "https://files.pythonhosted.org/packages/c4/c2/1c1737bf6fd40335fe53d28fe49afd99ee4143cc57a845e99635ce0b9b6d/charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a45e504f5e1be0bd385935a8e1507c442349ca36f511a47057a71c9d1d6ea9e", size = 190688, upload-time = "2026-03-06T06:01:02.479Z" },
- { url = "https://files.pythonhosted.org/packages/5a/3d/abb5c22dc2ef493cd56522f811246a63c5427c08f3e3e50ab663de27fcf4/charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e09f671a54ce70b79a1fc1dc6da3072b7ef7251fadb894ed92d9aa8218465a5f", size = 183077, upload-time = "2026-03-06T06:01:04.231Z" },
- { url = "https://files.pythonhosted.org/packages/44/33/5298ad4d419a58e25b3508e87f2758d1442ff00c2471f8e0403dab8edad5/charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d01de5e768328646e6a3fa9e562706f8f6641708c115c62588aef2b941a4f88e", size = 206706, upload-time = "2026-03-06T06:01:05.773Z" },
- { url = "https://files.pythonhosted.org/packages/7b/17/51e7895ac0f87c3b91d276a449ef09f5532a7529818f59646d7a55089432/charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:131716d6786ad5e3dc542f5cc6f397ba3339dc0fb87f87ac30e550e8987756af", size = 191665, upload-time = "2026-03-06T06:01:07.473Z" },
- { url = "https://files.pythonhosted.org/packages/90/8f/cce9adf1883e98906dbae380d769b4852bb0fa0004bc7d7a2243418d3ea8/charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a374cc0b88aa710e8865dc1bd6edb3743c59f27830f0293ab101e4cf3ce9f85", size = 201950, upload-time = "2026-03-06T06:01:08.973Z" },
- { url = "https://files.pythonhosted.org/packages/08/ca/bce99cd5c397a52919e2769d126723f27a4c037130374c051c00470bcd38/charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d31f0d1671e1534e395f9eb84a68e0fb670e1edb1fe819a9d7f564ae3bc4e53f", size = 195830, upload-time = "2026-03-06T06:01:10.155Z" },
- { url = "https://files.pythonhosted.org/packages/87/4f/2e3d023a06911f1281f97b8f036edc9872167036ca6f55cc874a0be6c12c/charset_normalizer-3.4.5-cp311-cp311-win32.whl", hash = "sha256:cace89841c0599d736d3d74a27bc5821288bb47c5441923277afc6059d7fbcb4", size = 132029, upload-time = "2026-03-06T06:01:11.706Z" },
- { url = "https://files.pythonhosted.org/packages/fe/1f/a853b73d386521fd44b7f67ded6b17b7b2367067d9106a5c4b44f9a34274/charset_normalizer-3.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:f8102ae93c0bc863b1d41ea0f4499c20a83229f52ed870850892df555187154a", size = 142404, upload-time = "2026-03-06T06:01:12.865Z" },
- { url = "https://files.pythonhosted.org/packages/b4/10/dba36f76b71c38e9d391abe0fd8a5b818790e053c431adecfc98c35cd2a9/charset_normalizer-3.4.5-cp311-cp311-win_arm64.whl", hash = "sha256:ed98364e1c262cf5f9363c3eca8c2df37024f52a8fa1180a3610014f26eac51c", size = 132796, upload-time = "2026-03-06T06:01:14.106Z" },
- { url = "https://files.pythonhosted.org/packages/9c/b6/9ee9c1a608916ca5feae81a344dffbaa53b26b90be58cc2159e3332d44ec/charset_normalizer-3.4.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed97c282ee4f994ef814042423a529df9497e3c666dca19be1d4cd1129dc7ade", size = 280976, upload-time = "2026-03-06T06:01:15.276Z" },
- { url = "https://files.pythonhosted.org/packages/f8/d8/a54f7c0b96f1df3563e9190f04daf981e365a9b397eedfdfb5dbef7e5c6c/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0294916d6ccf2d069727d65973c3a1ca477d68708db25fd758dd28b0827cff54", size = 189356, upload-time = "2026-03-06T06:01:16.511Z" },
- { url = "https://files.pythonhosted.org/packages/42/69/2bf7f76ce1446759a5787cb87d38f6a61eb47dbbdf035cfebf6347292a65/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dc57a0baa3eeedd99fafaef7511b5a6ef4581494e8168ee086031744e2679467", size = 206369, upload-time = "2026-03-06T06:01:17.853Z" },
- { url = "https://files.pythonhosted.org/packages/10/9c/949d1a46dab56b959d9a87272482195f1840b515a3380e39986989a893ae/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ed1a9a204f317ef879b32f9af507d47e49cd5e7f8e8d5d96358c98373314fc60", size = 203285, upload-time = "2026-03-06T06:01:19.473Z" },
- { url = "https://files.pythonhosted.org/packages/67/5c/ae30362a88b4da237d71ea214a8c7eb915db3eec941adda511729ac25fa2/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ad83b8f9379176c841f8865884f3514d905bcd2a9a3b210eaa446e7d2223e4d", size = 196274, upload-time = "2026-03-06T06:01:20.728Z" },
- { url = "https://files.pythonhosted.org/packages/b2/07/c9f2cb0e46cb6d64fdcc4f95953747b843bb2181bda678dc4e699b8f0f9a/charset_normalizer-3.4.5-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:a118e2e0b5ae6b0120d5efa5f866e58f2bb826067a646431da4d6a2bdae7950e", size = 184715, upload-time = "2026-03-06T06:01:22.194Z" },
- { url = "https://files.pythonhosted.org/packages/36/64/6b0ca95c44fddf692cd06d642b28f63009d0ce325fad6e9b2b4d0ef86a52/charset_normalizer-3.4.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:754f96058e61a5e22e91483f823e07df16416ce76afa4ebf306f8e1d1296d43f", size = 193426, upload-time = "2026-03-06T06:01:23.795Z" },
- { url = "https://files.pythonhosted.org/packages/50/bc/a730690d726403743795ca3f5bb2baf67838c5fea78236098f324b965e40/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0c300cefd9b0970381a46394902cd18eaf2aa00163f999590ace991989dcd0fc", size = 191780, upload-time = "2026-03-06T06:01:25.053Z" },
- { url = "https://files.pythonhosted.org/packages/97/4f/6c0bc9af68222b22951552d73df4532b5be6447cee32d58e7e8c74ecbb7b/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c108f8619e504140569ee7de3f97d234f0fbae338a7f9f360455071ef9855a95", size = 185805, upload-time = "2026-03-06T06:01:26.294Z" },
- { url = "https://files.pythonhosted.org/packages/dd/b9/a523fb9b0ee90814b503452b2600e4cbc118cd68714d57041564886e7325/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d1028de43596a315e2720a9849ee79007ab742c06ad8b45a50db8cdb7ed4a82a", size = 208342, upload-time = "2026-03-06T06:01:27.55Z" },
- { url = "https://files.pythonhosted.org/packages/4d/61/c59e761dee4464050713e50e27b58266cc8e209e518c0b378c1580c959ba/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:19092dde50335accf365cce21998a1c6dd8eafd42c7b226eb54b2747cdce2fac", size = 193661, upload-time = "2026-03-06T06:01:29.051Z" },
- { url = "https://files.pythonhosted.org/packages/1c/43/729fa30aad69783f755c5ad8649da17ee095311ca42024742701e202dc59/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4354e401eb6dab9aed3c7b4030514328a6c748d05e1c3e19175008ca7de84fb1", size = 204819, upload-time = "2026-03-06T06:01:30.298Z" },
- { url = "https://files.pythonhosted.org/packages/87/33/d9b442ce5a91b96fc0840455a9e49a611bbadae6122778d0a6a79683dd31/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a68766a3c58fde7f9aaa22b3786276f62ab2f594efb02d0a1421b6282e852e98", size = 198080, upload-time = "2026-03-06T06:01:31.478Z" },
- { url = "https://files.pythonhosted.org/packages/56/5a/b8b5a23134978ee9885cee2d6995f4c27cc41f9baded0a9685eabc5338f0/charset_normalizer-3.4.5-cp312-cp312-win32.whl", hash = "sha256:1827734a5b308b65ac54e86a618de66f935a4f63a8a462ff1e19a6788d6c2262", size = 132630, upload-time = "2026-03-06T06:01:33.056Z" },
- { url = "https://files.pythonhosted.org/packages/70/53/e44a4c07e8904500aec95865dc3f6464dc3586a039ef0df606eb3ac38e35/charset_normalizer-3.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:728c6a963dfab66ef865f49286e45239384249672cd598576765acc2a640a636", size = 142856, upload-time = "2026-03-06T06:01:34.489Z" },
- { url = "https://files.pythonhosted.org/packages/ea/aa/c5628f7cad591b1cf45790b7a61483c3e36cf41349c98af7813c483fd6e8/charset_normalizer-3.4.5-cp312-cp312-win_arm64.whl", hash = "sha256:75dfd1afe0b1647449e852f4fb428195a7ed0588947218f7ba929f6538487f02", size = 132982, upload-time = "2026-03-06T06:01:35.641Z" },
- { url = "https://files.pythonhosted.org/packages/f5/48/9f34ec4bb24aa3fdba1890c1bddb97c8a4be1bd84ef5c42ac2352563ad05/charset_normalizer-3.4.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac59c15e3f1465f722607800c68713f9fbc2f672b9eb649fe831da4019ae9b23", size = 280788, upload-time = "2026-03-06T06:01:37.126Z" },
- { url = "https://files.pythonhosted.org/packages/0e/09/6003e7ffeb90cc0560da893e3208396a44c210c5ee42efff539639def59b/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:165c7b21d19365464e8f70e5ce5e12524c58b48c78c1f5a57524603c1ab003f8", size = 188890, upload-time = "2026-03-06T06:01:38.73Z" },
- { url = "https://files.pythonhosted.org/packages/42/1e/02706edf19e390680daa694d17e2b8eab4b5f7ac285e2a51168b4b22ee6b/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:28269983f25a4da0425743d0d257a2d6921ea7d9b83599d4039486ec5b9f911d", size = 206136, upload-time = "2026-03-06T06:01:40.016Z" },
- { url = "https://files.pythonhosted.org/packages/c7/87/942c3def1b37baf3cf786bad01249190f3ca3d5e63a84f831e704977de1f/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d27ce22ec453564770d29d03a9506d449efbb9fa13c00842262b2f6801c48cce", size = 202551, upload-time = "2026-03-06T06:01:41.522Z" },
- { url = "https://files.pythonhosted.org/packages/94/0a/af49691938dfe175d71b8a929bd7e4ace2809c0c5134e28bc535660d5262/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0625665e4ebdddb553ab185de5db7054393af8879fb0c87bd5690d14379d6819", size = 195572, upload-time = "2026-03-06T06:01:43.208Z" },
- { url = "https://files.pythonhosted.org/packages/20/ea/dfb1792a8050a8e694cfbde1570ff97ff74e48afd874152d38163d1df9ae/charset_normalizer-3.4.5-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:c23eb3263356d94858655b3e63f85ac5d50970c6e8febcdde7830209139cc37d", size = 184438, upload-time = "2026-03-06T06:01:44.755Z" },
- { url = "https://files.pythonhosted.org/packages/72/12/c281e2067466e3ddd0595bfaea58a6946765ace5c72dfa3edc2f5f118026/charset_normalizer-3.4.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e6302ca4ae283deb0af68d2fbf467474b8b6aedcd3dab4db187e07f94c109763", size = 193035, upload-time = "2026-03-06T06:01:46.051Z" },
- { url = "https://files.pythonhosted.org/packages/ba/4f/3792c056e7708e10464bad0438a44708886fb8f92e3c3d29ec5e2d964d42/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e51ae7d81c825761d941962450f50d041db028b7278e7b08930b4541b3e45cb9", size = 191340, upload-time = "2026-03-06T06:01:47.547Z" },
- { url = "https://files.pythonhosted.org/packages/e7/86/80ddba897127b5c7a9bccc481b0cd36c8fefa485d113262f0fe4332f0bf4/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:597d10dec876923e5c59e48dbd366e852eacb2b806029491d307daea6b917d7c", size = 185464, upload-time = "2026-03-06T06:01:48.764Z" },
- { url = "https://files.pythonhosted.org/packages/4d/00/b5eff85ba198faacab83e0e4b6f0648155f072278e3b392a82478f8b988b/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5cffde4032a197bd3b42fd0b9509ec60fb70918d6970e4cc773f20fc9180ca67", size = 208014, upload-time = "2026-03-06T06:01:50.371Z" },
- { url = "https://files.pythonhosted.org/packages/c8/11/d36f70be01597fd30850dde8a1269ebc8efadd23ba5785808454f2389bde/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2da4eedcb6338e2321e831a0165759c0c620e37f8cd044a263ff67493be8ffb3", size = 193297, upload-time = "2026-03-06T06:01:51.933Z" },
- { url = "https://files.pythonhosted.org/packages/1a/1d/259eb0a53d4910536c7c2abb9cb25f4153548efb42800c6a9456764649c0/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:65a126fb4b070d05340a84fc709dd9e7c75d9b063b610ece8a60197a291d0adf", size = 204321, upload-time = "2026-03-06T06:01:53.887Z" },
- { url = "https://files.pythonhosted.org/packages/84/31/faa6c5b9d3688715e1ed1bb9d124c384fe2fc1633a409e503ffe1c6398c1/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7a80a9242963416bd81f99349d5f3fce1843c303bd404f204918b6d75a75fd6", size = 197509, upload-time = "2026-03-06T06:01:56.439Z" },
- { url = "https://files.pythonhosted.org/packages/fd/a5/c7d9dd1503ffc08950b3260f5d39ec2366dd08254f0900ecbcf3a6197c7c/charset_normalizer-3.4.5-cp313-cp313-win32.whl", hash = "sha256:f1d725b754e967e648046f00c4facc42d414840f5ccc670c5670f59f83693e4f", size = 132284, upload-time = "2026-03-06T06:01:57.812Z" },
- { url = "https://files.pythonhosted.org/packages/b9/0f/57072b253af40c8aa6636e6de7d75985624c1eb392815b2f934199340a89/charset_normalizer-3.4.5-cp313-cp313-win_amd64.whl", hash = "sha256:e37bd100d2c5d3ba35db9c7c5ba5a9228cbcffe5c4778dc824b164e5257813d7", size = 142630, upload-time = "2026-03-06T06:01:59.062Z" },
- { url = "https://files.pythonhosted.org/packages/31/41/1c4b7cc9f13bd9d369ce3bc993e13d374ce25fa38a2663644283ecf422c1/charset_normalizer-3.4.5-cp313-cp313-win_arm64.whl", hash = "sha256:93b3b2cc5cf1b8743660ce77a4f45f3f6d1172068207c1defc779a36eea6bb36", size = 133254, upload-time = "2026-03-06T06:02:00.281Z" },
- { url = "https://files.pythonhosted.org/packages/43/be/0f0fd9bb4a7fa4fb5067fb7d9ac693d4e928d306f80a0d02bde43a7c4aee/charset_normalizer-3.4.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8197abe5ca1ffb7d91e78360f915eef5addff270f8a71c1fc5be24a56f3e4873", size = 280232, upload-time = "2026-03-06T06:02:01.508Z" },
- { url = "https://files.pythonhosted.org/packages/28/02/983b5445e4bef49cd8c9da73a8e029f0825f39b74a06d201bfaa2e55142a/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2aecdb364b8a1802afdc7f9327d55dad5366bc97d8502d0f5854e50712dbc5f", size = 189688, upload-time = "2026-03-06T06:02:02.857Z" },
- { url = "https://files.pythonhosted.org/packages/d0/88/152745c5166437687028027dc080e2daed6fe11cfa95a22f4602591c42db/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a66aa5022bf81ab4b1bebfb009db4fd68e0c6d4307a1ce5ef6a26e5878dfc9e4", size = 206833, upload-time = "2026-03-06T06:02:05.127Z" },
- { url = "https://files.pythonhosted.org/packages/cb/0f/ebc15c8b02af2f19be9678d6eed115feeeccc45ce1f4b098d986c13e8769/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d77f97e515688bd615c1d1f795d540f32542d514242067adcb8ef532504cb9ee", size = 202879, upload-time = "2026-03-06T06:02:06.446Z" },
- { url = "https://files.pythonhosted.org/packages/38/9c/71336bff6934418dc8d1e8a1644176ac9088068bc571da612767619c97b3/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01a1ed54b953303ca7e310fafe0fe347aab348bd81834a0bcd602eb538f89d66", size = 195764, upload-time = "2026-03-06T06:02:08.763Z" },
- { url = "https://files.pythonhosted.org/packages/b7/95/ce92fde4f98615661871bc282a856cf9b8a15f686ba0af012984660d480b/charset_normalizer-3.4.5-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:b2d37d78297b39a9eb9eb92c0f6df98c706467282055419df141389b23f93362", size = 183728, upload-time = "2026-03-06T06:02:10.137Z" },
- { url = "https://files.pythonhosted.org/packages/1c/e7/f5b4588d94e747ce45ae680f0f242bc2d98dbd4eccfab73e6160b6893893/charset_normalizer-3.4.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e71bbb595973622b817c042bd943c3f3667e9c9983ce3d205f973f486fec98a7", size = 192937, upload-time = "2026-03-06T06:02:11.663Z" },
- { url = "https://files.pythonhosted.org/packages/f9/29/9d94ed6b929bf9f48bf6ede6e7474576499f07c4c5e878fb186083622716/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4cd966c2559f501c6fd69294d082c2934c8dd4719deb32c22961a5ac6db0df1d", size = 192040, upload-time = "2026-03-06T06:02:13.489Z" },
- { url = "https://files.pythonhosted.org/packages/15/d2/1a093a1cf827957f9445f2fe7298bcc16f8fc5e05c1ed2ad1af0b239035e/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d5e52d127045d6ae01a1e821acfad2f3a1866c54d0e837828538fabe8d9d1bd6", size = 184107, upload-time = "2026-03-06T06:02:14.83Z" },
- { url = "https://files.pythonhosted.org/packages/0f/7d/82068ce16bd36135df7b97f6333c5d808b94e01d4599a682e2337ed5fd14/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:30a2b1a48478c3428d047ed9690d57c23038dac838a87ad624c85c0a78ebeb39", size = 208310, upload-time = "2026-03-06T06:02:16.165Z" },
- { url = "https://files.pythonhosted.org/packages/84/4e/4dfb52307bb6af4a5c9e73e482d171b81d36f522b21ccd28a49656baa680/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d8ed79b8f6372ca4254955005830fd61c1ccdd8c0fac6603e2c145c61dd95db6", size = 192918, upload-time = "2026-03-06T06:02:18.144Z" },
- { url = "https://files.pythonhosted.org/packages/08/a4/159ff7da662cf7201502ca89980b8f06acf3e887b278956646a8aeb178ab/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c5af897b45fa606b12464ccbe0014bbf8c09191e0a66aab6aa9d5cf6e77e0c94", size = 204615, upload-time = "2026-03-06T06:02:19.821Z" },
- { url = "https://files.pythonhosted.org/packages/d6/62/0dd6172203cb6b429ffffc9935001fde42e5250d57f07b0c28c6046deb6b/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1088345bcc93c58d8d8f3d783eca4a6e7a7752bbff26c3eee7e73c597c191c2e", size = 197784, upload-time = "2026-03-06T06:02:21.86Z" },
- { url = "https://files.pythonhosted.org/packages/c7/5e/1aab5cb737039b9c59e63627dc8bbc0d02562a14f831cc450e5f91d84ce1/charset_normalizer-3.4.5-cp314-cp314-win32.whl", hash = "sha256:ee57b926940ba00bca7ba7041e665cc956e55ef482f851b9b65acb20d867e7a2", size = 133009, upload-time = "2026-03-06T06:02:23.289Z" },
- { url = "https://files.pythonhosted.org/packages/40/65/e7c6c77d7aaa4c0d7974f2e403e17f0ed2cb0fc135f77d686b916bf1eead/charset_normalizer-3.4.5-cp314-cp314-win_amd64.whl", hash = "sha256:4481e6da1830c8a1cc0b746b47f603b653dadb690bcd851d039ffaefe70533aa", size = 143511, upload-time = "2026-03-06T06:02:26.195Z" },
- { url = "https://files.pythonhosted.org/packages/ba/91/52b0841c71f152f563b8e072896c14e3d83b195c188b338d3cc2e582d1d4/charset_normalizer-3.4.5-cp314-cp314-win_arm64.whl", hash = "sha256:97ab7787092eb9b50fb47fa04f24c75b768a606af1bcba1957f07f128a7219e4", size = 133775, upload-time = "2026-03-06T06:02:27.473Z" },
- { url = "https://files.pythonhosted.org/packages/c5/60/3a621758945513adfd4db86827a5bafcc615f913dbd0b4c2ed64a65731be/charset_normalizer-3.4.5-py3-none-any.whl", hash = "sha256:9db5e3fcdcee89a78c04dffb3fe33c79f77bd741a624946db2591c81b2fc85b0", size = 55455, upload-time = "2026-03-06T06:03:17.827Z" },
+version = "3.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/98/77/46e87bcfc45d25ab4db7cfc9bb544bfa3ffd302289ed31ae93f5433eb899/charset_normalizer-3.5.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:195c26fb65950f8fce54e26349852b7bdd7c5f120aeefbcc440b8a20faaed4a3", size = 373348, upload-time = "2026-09-30T04:34:42.843Z" },
+ { url = "https://files.pythonhosted.org/packages/52/fc/e518013affcc43c9f919c3ba41bffe9b4ee4aceb0a6462a6243efcca5f2d/charset_normalizer-3.5.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9373ad13ef0d2c0fb761e04e55bfdee5a08b52cef2c882c8fbe9935b1517152e", size = 260860, upload-time = "2026-09-30T04:34:44.817Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/ad/2a895c945ee61988dfd9ccee64f0b78dc09f29c9b34d1dd545246d78e0ad/charset_normalizer-3.5.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ddf19c062bea7a0cc80f519243d2c01dd091be0cf952a0750d4ad576709559f5", size = 246491, upload-time = "2026-09-30T04:34:46.227Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/05/5d958bc8ea503e26be25ada5430fd409cfb45dc22ff33f9f96e649613c99/charset_normalizer-3.5.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3d14b50de6bf4d0edf857a9386836846f982b8f524e188e2e68b96d702bcf4aa", size = 290875, upload-time = "2026-09-30T04:34:47.691Z" },
+ { url = "https://files.pythonhosted.org/packages/55/e2/06bad57dfdb49cad92c0ba85b6b4fa5827a67df37897287cfef0553843c2/charset_normalizer-3.5.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:28a15fdad492a99b6eccfaaed66ef3f74050680545ea61ec8b2f4c538f1f1320", size = 286987, upload-time = "2026-09-30T04:34:49.356Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/9f/9f52d2886d52645987d603425482c63c5045a3005db1354a7097e5ed1ae9/charset_normalizer-3.5.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a893cc101149f80a653f82062ebc95b34525a2614382e1da5458fe7c6997249", size = 271105, upload-time = "2026-09-30T04:34:50.957Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/41/e05e19578b7b87e7db2c3ecb884bd09d065274ab41e1f535542e8bae9b06/charset_normalizer-3.5.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:619799369eeef6366ed3e8755a5670f4f2f0fb6b30a0fd7264dc0fdc2357058e", size = 269833, upload-time = "2026-09-30T04:34:52.623Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/cd/fc7152414561ff78f9c61a4a627025f65fd244abaefc99ac4e75c6169b33/charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:447441e76ec720b15e64418d32e092297340387053047c7c694f579efb0ee1d9", size = 263048, upload-time = "2026-09-30T04:34:54.013Z" },
+ { url = "https://files.pythonhosted.org/packages/71/71/fb379e399b1013962716a059d551e03bd80b3e02f05d81246886af6c0958/charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:62588a277bfb59def052abd940703fa35107152bf479781a878617d60faf8fb5", size = 249237, upload-time = "2026-09-30T04:34:55.373Z" },
+ { url = "https://files.pythonhosted.org/packages/33/4f/aeadccd6d20882909eb2597ec40eccc05d505e2262f14dc76d7620700657/charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:44bd4fbb29dfbeba60e7d2bd000c59e4b21ddb3cc53912b14048d37092706d7c", size = 290756, upload-time = "2026-09-30T04:34:56.867Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/7b/e8a92613236b257d3b75d532496eb21f68ad8231d7d56df94497e460112e/charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:30fcd120b732aa79317f08dee04d7de0847822e4cf7ee0e9f445bb958832252c", size = 269026, upload-time = "2026-09-30T04:34:58.278Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/ac/21d5c6b972285c5f095ff78afdc99f3539e3985dfcf7ff1cfbe9e772f529/charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:50e3adfb96fc189eb27b1cf62d3b598b89b4bb0420d93a3d3e42e137409011be", size = 287601, upload-time = "2026-09-30T04:34:59.703Z" },
+ { url = "https://files.pythonhosted.org/packages/59/72/263491ec1494a194b16fcbff88a0220f2af633738c79e92b4d7189226322/charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b736353c0a625bbd5fcec108576e2385db3496f4f771f785ff32e108d3c3bc45", size = 272660, upload-time = "2026-09-30T04:35:01.26Z" },
+ { url = "https://files.pythonhosted.org/packages/38/7a/81f1186c57e406233969ae96b5fd0c907254ab8b6e47da8ae24cd20fb9d7/charset_normalizer-3.5.2-cp310-cp310-win32.whl", hash = "sha256:f5833ad231be5eb6553de524a70f48d71b2c8563101750531e0b80184e175cd4", size = 187301, upload-time = "2026-09-30T04:35:02.659Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/ab/fb8b5178fdf7bf68efa61cbe892286bc9f73846f26147d4725fb89388475/charset_normalizer-3.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:1461ac396c4fdb983a675f20aa555624f0ee18ac83d832b9244ffff3d8055275", size = 215446, upload-time = "2026-09-30T04:35:04.011Z" },
+ { url = "https://files.pythonhosted.org/packages/36/40/e270b74e0d3f583d78d902960845a149e80eb7c737ee5613ccc6efc7264b/charset_normalizer-3.5.2-cp310-cp310-win_arm64.whl", hash = "sha256:c6708715abcf3c73b99508253e961a9967f02fe536532834149574eda6de0d1c", size = 203389, upload-time = "2026-09-30T04:35:05.577Z" },
+ { url = "https://files.pythonhosted.org/packages/22/67/6a0b94a7960d5e1b5eacd2fb529f3fccc47db4644f7f0a7cfdcfc3be578a/charset_normalizer-3.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d21b8b13c7592db2ac5e544a6d83187b995257472b0c9e8351b6d507ae37ed6", size = 370642, upload-time = "2026-09-30T04:35:06.91Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/94/01009e13b94041599004edf32e56e382c24e570f60f79bab8efe45cfe1eb/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d760fe2a4d7c3b226cb9026d6a842868d52a7901bd98420e1baf14e80da85cf5", size = 259280, upload-time = "2026-09-30T04:35:08.448Z" },
+ { url = "https://files.pythonhosted.org/packages/66/85/3b5358f60a13210f0b67d3755c168ef758701b021e655d88d4da28554467/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c9790464842f85f437dbbb54417eda1e0e6bfc52dd8d22d6fd1c994b73b2dc74", size = 245335, upload-time = "2026-09-30T04:35:10.104Z" },
+ { url = "https://files.pythonhosted.org/packages/74/75/77c1c479b09ecd751d1e767b251ea5c14d4d50ff757bf404afab2692f600/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4685902cf26edf013ed7a3da0f426ebba7a00ebb9541386d835afbf002c11cab", size = 291707, upload-time = "2026-09-30T04:35:11.575Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/0d/363f78cacb70f58f15f4b083961bbd9d292f335d3f5c66fc4f1cfe69cb90/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4495c5002a7b28557e7e222e77e0b661183e432b7d6d2e788101e3f240e05b8c", size = 286747, upload-time = "2026-09-30T04:35:13.022Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/ed/cf505d3011ffceb12c2067a7a5d3cfe92b875d4d44bb0ff0d69375e2c184/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:211d5a3eb6af8f513b8d4ca19a8c1b7accab1b5f0d3175f9826b03c1a920dc1f", size = 269972, upload-time = "2026-09-30T04:35:14.606Z" },
+ { url = "https://files.pythonhosted.org/packages/15/d8/f0a93a431d170e7ca681d4f6650fee3de934d18560e474e7267eb4b0f987/charset_normalizer-3.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef4fcbf3327382cd4c9f540babd61248208af7b93eec4de397b4d5f58a09e288", size = 269339, upload-time = "2026-09-30T04:35:16.087Z" },
+ { url = "https://files.pythonhosted.org/packages/86/bd/9b2bd1c5b7af02462c9752d33994834ff972a96b4c483eefde9e594488e2/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd16aabe4a02a297c23417aa17ac6299dbd8c49f673bcd645b4929b11f5a4400", size = 261683, upload-time = "2026-09-30T04:35:17.488Z" },
+ { url = "https://files.pythonhosted.org/packages/76/a5/cac540ab0fd61f3fec88ad3dbb64509e71424593d73cfdfff5ab3e4db279/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:fb9e68df06293761f9fe66ade60a9bc6d0f5e42b8acf2939a9158af86ab0e5bd", size = 248143, upload-time = "2026-09-30T04:35:18.849Z" },
+ { url = "https://files.pythonhosted.org/packages/71/7a/ff467301deef2089fad87f72df9e000a26a78fec7acbb18e1999371b8369/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:59f63901b0031c3136cf64704dcb21de0bbae62ce2c9529bc39d27665463de37", size = 292358, upload-time = "2026-09-30T04:35:20.326Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/77/22d7e785d1e210afc2e2f58600dd1799d17a35665faf84383f002826c5f8/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:304d5463e65a35d7bb0850550e0780395395f6fcf452f04db7d5ca7cecc425ac", size = 268766, upload-time = "2026-09-30T04:35:21.72Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/91/e8e946267f1c2d9e2bd651726e2fbd2addf02c4d36cea5069e32ca9d7bb5/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9cf9b1a857e25c4baceeb3624e92a56df3668f398c4acba74e174d81fb4d1d3a", size = 287432, upload-time = "2026-09-30T04:35:23.273Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/88/7561d8a88d555e7df6623abe7c0070b4baf47549b9408783a2ae0a1a6cf7/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:114e4d0c92d618409ed82a99e22b5c5e768fe995f2973f78265f4524f49d4640", size = 272470, upload-time = "2026-09-30T04:35:24.655Z" },
+ { url = "https://files.pythonhosted.org/packages/35/7e/578c702301ec036f01455f30744a08d2b42f6ab35b9b2d4bf8cae0ef2a80/charset_normalizer-3.5.2-cp311-cp311-win32.whl", hash = "sha256:2625388c6c754520c37abaf3b41eb34d1cc4a373f457898f08606c8e362b891d", size = 186688, upload-time = "2026-09-30T04:35:26.225Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/fc/fdf8cf52ff21cd5bf158f20978991cf985325842f74283eb6df26c8a39d8/charset_normalizer-3.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:87e50a3e7cb90af586b6c5faf23e302a970415ac73bd7bd90a515a04b427ef96", size = 214932, upload-time = "2026-09-30T04:35:27.796Z" },
+ { url = "https://files.pythonhosted.org/packages/97/66/3e45a506d8110b632541faf9a9470185aa9878f1ed44020f31346c1c5e5b/charset_normalizer-3.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:254eb48b9fa5ee9898a3c445825a1f340fe53712a098904b39b0bddba8ea3cb1", size = 202828, upload-time = "2026-09-30T04:35:29.259Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/c8/693809898870237d82785a03f3b2b58fe4c9f14669f84a7d4e623c92a59e/charset_normalizer-3.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed2a239c0ea213acc1908150a3037257083c7c083128f1a4cec2ec4b97dca491", size = 367780, upload-time = "2026-09-30T04:35:30.888Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/87/2fea8c13dc24b3ca9c6f803a5b2dfdeae73eb4f9e12c7885ed908ff0433c/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b91363207bd9dc966a691e959bb47f64b30f7ac4b072be9968b366982f7db77c", size = 246730, upload-time = "2026-09-30T04:35:32.286Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/9e/09efac30b937722f46d3110ba30b875b24b2e3a266ed746cc4e376a94d80/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:38a873987f3be698494da8b2e3085e29da02da7b633dce73e79c699a113d7bf0", size = 237707, upload-time = "2026-09-30T04:35:33.709Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/18/70d76670b13686237863a379928d60bd10e021f17d243ab3d7014c4a5f4e/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:355ad8011081dec5412240c087a9a0c9d4d5039f3ed11a3f13e18c2b29b56c51", size = 273050, upload-time = "2026-09-30T04:35:35.138Z" },
+ { url = "https://files.pythonhosted.org/packages/54/e2/77a8b09d5adc013ed07b95b01b8b8fa5441c4e810e83ee7e4aae2fa4d91a/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ee21e28f0430bd6dc9086c6e525d5e818a44a5ad19720c8a0ef766792f3eb5e5", size = 270345, upload-time = "2026-09-30T04:35:36.502Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/c5/38806a25ab5e65fc178f39affeda20858efafede2fce1ffc2556cfc9fe73/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649", size = 257601, upload-time = "2026-09-30T04:35:37.919Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/8d/213565184708fdb263ae55e2c04ee1ff748129dd65d48ed0e3502da9c85a/charset_normalizer-3.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5cde776b7cc66e4f6c99612cea4aa7269aa65863f7a15841b2c264f103822f4e", size = 252222, upload-time = "2026-09-30T04:35:39.544Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/24/76d2cefc25472531e4c5c7dfff68865eb1c39b78482f0fdc15b46f047830/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae4f5fea5b8b8ccff88238cc8569303e5ee95efae67fa62922a311397a71f346", size = 248482, upload-time = "2026-09-30T04:35:41.088Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/dc/65a801b66ab4c197e22c433ab25e7ac24324ac6f45a2269aca42cce309bf/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f7d486c83842422badd511868fd8a9a20e9407ace71564b6af47ce7e60a336c1", size = 241206, upload-time = "2026-09-30T04:35:42.59Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/95/ca9b5eabde673002c6f1e7ada1b223916fe18f6d661da7aabd4d643718f1/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11a4d68a6ecda3292cb1e50239e111543ba5d709bb62a6b4ea1afcfa729d8875", size = 273190, upload-time = "2026-09-30T04:35:44.347Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/8b/803b4d2a3f6e1740f63f1e87b04d14b42f3d4fdfe6ed7d4db2d34102b14f/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d6734d2ef8a50fbf8445c139477da401f50d62a0606bf00e20ec6d87773fefb1", size = 253527, upload-time = "2026-09-30T04:35:45.915Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/55/93c0e5dbd085ae0471346026abbe7e0db9ea2d6fea74e51f0b5a46f233a7/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a815775b6c38d4e0ff7bcffbeba67feded90202bb6a226b8dd35f1c855217413", size = 271285, upload-time = "2026-09-30T04:35:47.49Z" },
+ { url = "https://files.pythonhosted.org/packages/95/69/0dbd0e0b9b16cfa816cdfcb3e2e3854a1f680dc07fb1245ea125e7448060/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869", size = 260010, upload-time = "2026-09-30T04:35:48.996Z" },
+ { url = "https://files.pythonhosted.org/packages/58/9d/e7b88e7b1bf403590c3b573277b5e1e488c68c7a6fbacca310a2c324e90c/charset_normalizer-3.5.2-cp312-cp312-win32.whl", hash = "sha256:db19d07e2e0129e974a0e65d0064fc222a446cd5122c2fd4184d2af9fc734a9e", size = 184125, upload-time = "2026-09-30T04:35:50.777Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/e6/e6e083884cbcfd49c64865af05027fe7011be7b2d9179524f099a1b611f3/charset_normalizer-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:780fbe7cab297b81dad9fb8dc5eb003c0468ffb0d9e5f65068c53a34661a96bc", size = 207486, upload-time = "2026-09-30T04:35:52.194Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/e3/017aea0911ada7405a825c7d937eb3a13009664e2f5b38e8c4bbf2abf894/charset_normalizer-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:e2af3aad578aa6bd1384bcf4750fc285e5a9de53f40b7d41e5a0bf748edeb2b3", size = 196734, upload-time = "2026-09-30T04:35:53.636Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/34/68292d68512768591aaff07c59bb53ee31341c87759433a859c4641a50c2/charset_normalizer-3.5.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:ed905975ab14056a2e5eb1c376cb2e1ebc5396baf84163939c518556fccde9f5", size = 225946, upload-time = "2026-09-30T04:35:55.313Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/80/bee0b01b90ccd5322ae1d0abb33fab1bd95b7c2eadaf02aeccf22e04ee83/charset_normalizer-3.5.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a66c3bc5ab1f0ff2164fc9965ddd611ff0802173f4b9d24554c563f6ab7e1d6e", size = 238619, upload-time = "2026-09-30T04:35:56.863Z" },
+ { url = "https://files.pythonhosted.org/packages/78/6e/60ce52a85a7fd631ae8482ae6d74521014ca2f255892679484dc04d7ef56/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2374b62878abb00cd8309b32af6c0b715cd02dec0ca74ef12e5069bdc64144a", size = 206701, upload-time = "2026-09-30T04:35:58.639Z" },
+ { url = "https://files.pythonhosted.org/packages/36/8c/71aafad23f971afc84c2b295bc0c560739ce1dac558aad9fec22e39f3639/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d376bbd28b3a8999db1a103b3b388aee6f1ddeb3e51bc2172993efdcd86e064d", size = 210506, upload-time = "2026-09-30T04:36:00.147Z" },
+ { url = "https://files.pythonhosted.org/packages/91/da/3c5a7798c046df7d2d68ad653cf5b6c5a8bfee225055a843c6f2f42aac1a/charset_normalizer-3.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6045373d5a89a5ec71afde535db987ca28e76dfa276c2d4c818265b375d4b055", size = 366626, upload-time = "2026-09-30T04:36:01.77Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/16/710ac3de2ee354e2bd1a9c94efe45a2d27b5c6ad39b2d6a905be2c094b6c/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849df64e889b2e17230d58410a03dba311a65b163508fd33679b2b737d4b7858", size = 244624, upload-time = "2026-09-30T04:36:03.389Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/39/45c7439f5b63d24f7d5b2a1d760f34af7628782d7144b4cc8ded45c2d4bc/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15c44f7edfd477b06f517a5cc317fc1707edb9de2c865f43d4b6513907473234", size = 235731, upload-time = "2026-09-30T04:36:04.987Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/34/38f3154785ce92e9f56eb226f4d35bdfae6b008480dd055f58837a89c810/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a89012d6d5476ee112d20d998570ed58df2260a852afb1758809cd6900411d21", size = 270352, upload-time = "2026-09-30T04:36:06.412Z" },
+ { url = "https://files.pythonhosted.org/packages/04/f3/859f74e7babc977705026b30593b3be04049632a522fb7000f83c033d747/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0c951d5e6dd9c2ff60609476752bee49da4206adde960ebc247766937f72e718", size = 267393, upload-time = "2026-09-30T04:36:07.865Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4", size = 254660, upload-time = "2026-09-30T04:36:09.248Z" },
+ { url = "https://files.pythonhosted.org/packages/58/ca/5d1a997587febe5b26d8daffe363b5c1a091cece19828eec6502fd09c5ef/charset_normalizer-3.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19a731138fc27d5682277d3b9df22855cea1239bce7fcec5f78f42ef2d1f3c3", size = 249996, upload-time = "2026-09-30T04:36:10.73Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/1f/d1e78246f7ed60c8c8d606b4ac27f66ce49cc3e95f24893ccbeba9f77302/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62603db9a7caa0802eaa28c1c46fecd7b3a263a774069c24c3c28c302448721c", size = 247028, upload-time = "2026-09-30T04:36:12.294Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/37/eba316edd4f0c4d3a5d945924c4eeeae59abac4056aa815d8a4268f863a2/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b6856554c4f44d79fc2307d5768854310a8f0096e501c75637542c82292b0429", size = 240562, upload-time = "2026-09-30T04:36:13.887Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/8e/aaa037d40ca9ef045977f1a661048b1aa33f223adfce3452fe9be9f79d14/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1bc0baf5ef96b6ede57d47f4b8fe4d9d84019c3bfcbeb20a41edc6a6ee341f1f", size = 271699, upload-time = "2026-09-30T04:36:15.41Z" },
+ { url = "https://files.pythonhosted.org/packages/26/19/1c1c9f75974adf523b87f34b8a2adc5a435cd65916812bcbd0dfa45f9a29/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:56bc200a365efb37383b7852e4cc5898d3b2da5987289b543956cf8cad71018a", size = 252030, upload-time = "2026-09-30T04:36:16.839Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/90/0660ef18e18df0a4d2a1a0edff7dfbba42d4e50ef2425557a5bb7051f77b/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2c9ad19a6cfcd5ea5c0d41161d22f9df1dcc277e9bef2751391334546a314c00", size = 268565, upload-time = "2026-09-30T04:36:18.468Z" },
+ { url = "https://files.pythonhosted.org/packages/79/ba/57adc269824e8658f1a0f97a9e514c247445a9632b3419b97e0ba37f16dc/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e243bd13217235fc7290c621941c3f5cc8b66e4872495be821d7436ba2fb838d", size = 257627, upload-time = "2026-09-30T04:36:19.938Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/85/33abd4315c052d3d4f54c92b1ee49bfbc0dc7115a981e462a793b6d2ab87/charset_normalizer-3.5.2-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:a090bb2c68df85450502e3e20d665e3a5af9c65a84d6508ed477badd49166fd3", size = 143407, upload-time = "2026-09-30T04:36:21.376Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/de/6435e18d1aaa5d910b896d551411c96af1f42a0c56c29afc2016c61ccc2e/charset_normalizer-3.5.2-cp313-cp313-win32.whl", hash = "sha256:2b7b3bbfb4fe8ef40600792d762fbaa9057559f9d3fad209525b7a22b99e91fd", size = 183207, upload-time = "2026-09-30T04:36:22.776Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/76/b8ec57f4e9ee3253541abf95e4a462c0175fe8032dcd070f1f2421240942/charset_normalizer-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:78456a747de8dc58360ffa581f30a002baf5aa28cb262536545e91f113ed7639", size = 206489, upload-time = "2026-09-30T04:36:24.306Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/60/c647c6ae47480221e875ea5d743ff94946f7416e3c69415ab772928e8d32/charset_normalizer-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:11912e4bb14baae7c5d8791aa55ba0a3a03ec6729073307b0f57270abaa713d3", size = 195501, upload-time = "2026-09-30T04:36:25.846Z" },
+ { url = "https://files.pythonhosted.org/packages/58/ca/7aa91362a2f77ac8e9e28a9b902a74f7d0e11a851ef0d27a74308da8cd90/charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187", size = 226010, upload-time = "2026-09-30T04:36:27.669Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/cf/ac8878d0322cf88a1aad4c7b147db32ca0bd806eb0060957b2e31486dbe6/charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad", size = 239266, upload-time = "2026-09-30T04:36:29.434Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/6d/9a08d7e0b29b7208e2c6c01dc56c8e0520e7c7beadbbfb024b58fd69c8a5/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf", size = 206783, upload-time = "2026-09-30T04:36:30.872Z" },
+ { url = "https://files.pythonhosted.org/packages/82/44/b0aa350280e6ff5a5492d17cf10460dd39d5ee848f872f7ba2df10607f60/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995", size = 210449, upload-time = "2026-09-30T04:36:32.625Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/8a/40db9aa9f5907bb0e6f8b6d64064bf8852fb33d4b813ff9414911df7647c/charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424", size = 367815, upload-time = "2026-09-30T04:36:34.197Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/72/9c5e7707b57c8ddfa9ddf7b0b1d009d7fbab9e9e887d5b721060f37e307d/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13", size = 247095, upload-time = "2026-09-30T04:36:35.803Z" },
+ { url = "https://files.pythonhosted.org/packages/83/09/71e453691e927de4ddf792770cfaab3f49d494e222f66ea5e404bbd5e39c/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d", size = 233942, upload-time = "2026-09-30T04:36:37.407Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/86/85c84e4da8b27dd409577d9437926ff581c5f9d3c66038dc68c1a526de51/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4", size = 273762, upload-time = "2026-09-30T04:36:38.904Z" },
+ { url = "https://files.pythonhosted.org/packages/92/08/564955a4b5f2ccb410ab480bbe8c6a18063ff27f2d35458731c4a5335df9/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438", size = 269514, upload-time = "2026-09-30T04:36:40.469Z" },
+ { url = "https://files.pythonhosted.org/packages/18/24/bad3ac4271589df29cf5ce2f5ae490518a5739358052bd0d61209e6fea54/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a", size = 255056, upload-time = "2026-09-30T04:36:42.02Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/3e/350d89ad49916b86554d6f5f2d03ec1152148f87e5ff735106c6a03b1a36/charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56", size = 251311, upload-time = "2026-09-30T04:36:43.577Z" },
+ { url = "https://files.pythonhosted.org/packages/56/5b/4970a2d154df502e133402906dd04e3ae7cada7b3011283c88d0479a2585/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd", size = 250190, upload-time = "2026-09-30T04:36:45.185Z" },
+ { url = "https://files.pythonhosted.org/packages/88/8c/f1a91bddc8fb47c2889e29ea7ea49a194eb0d9868675d786806519c00d76/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204", size = 237098, upload-time = "2026-09-30T04:36:46.689Z" },
+ { url = "https://files.pythonhosted.org/packages/24/0e/bb5dace3cc7e79068425386a6589c19b5a2ab5fefc2a46abea6919683332/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7", size = 274228, upload-time = "2026-09-30T04:36:48.31Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/79/b849ad523017ea9f5a45581bbebed91439e0cf42fd2860a6f64e358eb5a6/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd", size = 252401, upload-time = "2026-09-30T04:36:50.091Z" },
+ { url = "https://files.pythonhosted.org/packages/89/8c/75469d690cf47200bce8f6cad7655724fc23148e147abfc5ce78b5f65863/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc", size = 271846, upload-time = "2026-09-30T04:36:51.719Z" },
+ { url = "https://files.pythonhosted.org/packages/26/cd/6d52d3c7437cdcf2e310ce9f28f282e733d4ef60ed19105d1819c356255f/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874", size = 258151, upload-time = "2026-09-30T04:36:53.234Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/4c/070b38bdb5f49a70199fce923ec0726a49536a63ab262abbfcaaf351110b/charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655", size = 143570, upload-time = "2026-09-30T04:36:54.816Z" },
+ { url = "https://files.pythonhosted.org/packages/81/84/9ebfc8ed6c8c4fcd8e726ff6bf220cc8deb3966e31dce9be8dd8aa017e64/charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0", size = 186412, upload-time = "2026-09-30T04:36:56.643Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/78/5ed86f743d4bc350db307e7636419a0a5ee1d91806d30c7f667bd5c80dae/charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c", size = 210965, upload-time = "2026-09-30T04:36:58.205Z" },
+ { url = "https://files.pythonhosted.org/packages/53/94/a3a7698e9b1a395e1eb99ccd9a324be9347973bff4e72db2a06496d7cd27/charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253", size = 200406, upload-time = "2026-09-30T04:36:59.764Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/48/c5dd00d5ef7791f02666de250a5bb6071e29b7e133cf4b835800b6d3bc27/charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709", size = 396871, upload-time = "2026-09-30T04:37:01.543Z" },
+ { url = "https://files.pythonhosted.org/packages/12/c8/8379554b42e8368161d898476686947a0fdbd3e8865170d7909dcabfdee8/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084", size = 249711, upload-time = "2026-09-30T04:37:03.111Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/eb/2ddb1035d17320caa9f41682935123a9a250277b261c3efc86b2d2a21343/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb", size = 231146, upload-time = "2026-09-30T04:37:04.721Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/24/2ecb4bde104322cd7859d6594fcfa74649f8d90b3221c9feecbef149875b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f", size = 271552, upload-time = "2026-09-30T04:37:06.295Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/98/9d5f6ebc3aee9fef5d30b4aff11fb2ab7a1222b4064f8ef2c7c87cde217a/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09", size = 269810, upload-time = "2026-09-30T04:37:07.905Z" },
+ { url = "https://files.pythonhosted.org/packages/09/e1/a3b06a10461b1b7628853c934c644e03bc28e42767116afb52f19a56519b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80", size = 259845, upload-time = "2026-09-30T04:37:09.554Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/d3/6f561f74a296cf27d61775a1dc665ad13f3bff6a798810ca05907f37a7c4/charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c", size = 252825, upload-time = "2026-09-30T04:37:11.274Z" },
+ { url = "https://files.pythonhosted.org/packages/26/9f/69e13ca3b18f43e0eafcd34c04a45b732ae22a43b54a5fc9e119103356eb/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f", size = 252659, upload-time = "2026-09-30T04:37:12.941Z" },
+ { url = "https://files.pythonhosted.org/packages/73/a9/ace29806a0dae18939919c76ba526472d83214afa101105fabff2cf30625/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03", size = 238819, upload-time = "2026-09-30T04:37:14.659Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/c1/6116d52a2e3311ec80f21f5fb5e17b27405f10b9608af8f6e69516841a1b/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604", size = 272973, upload-time = "2026-09-30T04:37:16.346Z" },
+ { url = "https://files.pythonhosted.org/packages/19/aa/9955c7e93bba10a9c7e8f7a5031b7ced66f3a1883a55c00712b8d5850ff3/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8", size = 253692, upload-time = "2026-09-30T04:37:18.212Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/33/2a6ae7fdc1b10cb581cef91addd8cdfc5f40d50abb5702309369d5834579/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93", size = 268757, upload-time = "2026-09-30T04:37:19.877Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/22/80992720a0282cd39bba1db35868e6b9c22f41281160143a836544bc1d8a/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915", size = 262220, upload-time = "2026-09-30T04:37:21.583Z" },
+ { url = "https://files.pythonhosted.org/packages/92/9f/181fd07e1bffea1d95cd80c84ac537354f50699c22cfc4d3c02b6fc16208/charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5", size = 197797, upload-time = "2026-09-30T04:37:23.235Z" },
+ { url = "https://files.pythonhosted.org/packages/49/1c/25d8415ec1c4f2f41f1680435e4c87cfb378ff2f677d950946f2a45d0632/charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc", size = 222765, upload-time = "2026-09-30T04:37:24.891Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/b4/46b48f013dadfc0d0d33b375438e31bdf5a989dc68389c6bf627054d4df9/charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105", size = 210985, upload-time = "2026-09-30T04:37:26.634Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/e9/34e597dee616d0b8ee4b34d29399e85c2204ade174157a48505d42baa4ff/charset_normalizer-3.5.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:87475fabc8d9996fd9c27debb395e642e8c838d78a00b6e932227a0e06b81e26", size = 367676, upload-time = "2026-09-30T04:37:28.329Z" },
+ { url = "https://files.pythonhosted.org/packages/60/9f/a5d1c91c0263745e2cd344c5a4415d787c575501ab1d449f1148ac6b495d/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9409a8bf35cf78353942504b24a57de3d75b708997a1e4bd8db71ac8633ce364", size = 248414, upload-time = "2026-09-30T04:37:30.167Z" },
+ { url = "https://files.pythonhosted.org/packages/26/79/e697f77464748a3ee3cf490c83d592459400d4898380d66c38366b03080c/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:498dc3188ca05a68231ac3fdbfc7f57eb67e1343c30e0fea17f8218c1599b253", size = 244775, upload-time = "2026-09-30T04:37:31.964Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/87/3d42a42e18ea066e2513936fd678a00696e77878b5ae04528976abdbcb83/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e242bb1c5e76e97dfa9e7f209a71e93a01d7f19ffdd5cfbb2e2d55b4f08f8ab0", size = 273877, upload-time = "2026-09-30T04:37:33.661Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/76/8a28136f3938ba9836f84280ce0c4d61ed1cf15a036b2034900c62634162/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def79fa35ef0cef8d2accec024f4fdc7ead3012ff02f5215c783f39f03ef8cfc", size = 269455, upload-time = "2026-09-30T04:37:35.573Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/a1/4fbf5d0f0f1b2a080474c1cf9a2f12c4c6531bb0e8ba591055e846d2b4e9/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df041de8887954562c9b261cba85ca0e9ded74048daf125f45edcfaa4832229", size = 257336, upload-time = "2026-09-30T04:37:37.397Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/a2/8b50aa320adb880ad579518e6f718f24944804b42a88b83d267d5d444125/charset_normalizer-3.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04851f73ae72b8413dddadb16a49dfee95263553741fd42d546f7d66907e6be5", size = 257584, upload-time = "2026-09-30T04:37:39.522Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/57/50e3fed84e175f40349bd0da7a4fce94c87f0378f52d74f511d89e0bdc20/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:183b88127acdb4fabe59d951ab424faf1af7b63cdbb5f776186c1ea2ffcaed98", size = 251854, upload-time = "2026-09-30T04:37:41.23Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/54/f7fbb3493c9f49091213b9c2d6dd65800696f1ce1a3f196a4205f50417b1/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:16fa0eccf81304b79c5cd87f9271c3b85dd9dd99245e4422ae9c0dd45e0f99d3", size = 248767, upload-time = "2026-09-30T04:37:42.883Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/37/b3a6385acc5a1e45b39ae9c90bfb9cf838a09b9dd37ef2740ab4c6b4a2eb/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:7441d755b7ab94f8d4eb3e43ec05482d760842fd263d003a99102d742cd835e2", size = 274479, upload-time = "2026-09-30T04:37:44.658Z" },
+ { url = "https://files.pythonhosted.org/packages/89/44/809913e2cfd279e635a9294fdbbfb1b1dc62a8189d473d561f649fce98d8/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:ca403d7e4798f525fdfc78e258820419cbbd0f0ecbab9de7840e3c017cf6b8cf", size = 258310, upload-time = "2026-09-30T04:37:46.529Z" },
+ { url = "https://files.pythonhosted.org/packages/af/a2/f28400ab13359d91bd39179df8e149376b9bf36588e739a3a4f9de2b84b2/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:df29a0a7107f7011e77f4eebdddec4c7331e24d787a0b21a46d63bdf7445da95", size = 271100, upload-time = "2026-09-30T04:37:48.399Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/89/9bab37955edf0adb3b66f8a3a6617d9f2f487e0d56f295a6a286cb640aa6/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f3c96f633825733f735c5a9cf21d21a257d8e1edf0b1cee0a064b9c424ca0f7d", size = 259936, upload-time = "2026-09-30T04:37:50.023Z" },
+ { url = "https://files.pythonhosted.org/packages/23/b5/4459e08d45a679f903d50fea08bc52cfa728cca4d7bd02c757b5e5abda2e/charset_normalizer-3.5.2-cp315-cp315-win32.whl", hash = "sha256:281cb91036248400f4cc957495cccd44c275c2e0c5854f7e45ac5cf7dc193847", size = 186301, upload-time = "2026-09-30T04:37:51.722Z" },
+ { url = "https://files.pythonhosted.org/packages/98/e8/55d5fd3935b4bce6da4fe0df61898e8c82653e317e677bd58aceb9c60f13/charset_normalizer-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:89b53f3cda69831909888e0494f4fa0bcd3537e3e138dabeb620bd6ad946bae8", size = 210858, upload-time = "2026-09-30T04:37:53.427Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/5b/974423c2fd8e524c7a7f64318c1e02240ef954912fa2b4d70344107b9c68/charset_normalizer-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:6be488a102b8cf28d0391d8c4ba7748938ae28b78ad901f8585520fca33ead1a", size = 200309, upload-time = "2026-09-30T04:37:55.015Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/f9/00ee0195db1013d8f7c416fd770fbeb560bb46eb2e36b054d05cb56f6cfa/charset_normalizer-3.5.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:915563965d418f986e7e145accc592eae9e1a1be3566ff98a05d7a9ec42a76e1", size = 395343, upload-time = "2026-09-30T04:37:56.743Z" },
+ { url = "https://files.pythonhosted.org/packages/04/3a/c00b50e94c964cf934c7899cd47c97952fc11dad71cc5884b3c61795b09b/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65cd72beeeca9d3aaea1201e5923859f308f952f9c71de93f06063c79f0f7a3b", size = 250114, upload-time = "2026-09-30T04:37:58.607Z" },
+ { url = "https://files.pythonhosted.org/packages/50/27/d102dc880bbcffd0479ab64dfc1fb96777a854355a55e2bda72a71efadcb/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b7fd005a73d9e657273b7a10dc71a9e03c8fb9ee6999798d6918ce095b81ac7f", size = 239997, upload-time = "2026-09-30T04:38:00.511Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/4a/bf7ef45794dd293fab5f98a9309817977fbb845b9998f171b8cc5d8437a3/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e54da4baf05720032d527874d40b65fa4d7e5c6c6a43d0c3adbeffcaf275a2b3", size = 272313, upload-time = "2026-09-30T04:38:02.509Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/ee/008a2837737991474c5754bb3191010007663860979701990982a502cbaf/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:124fbf1a8ff966d87ae05bb8bd45a71f966055ed8bba320d0c7cf450bc5f4d0e", size = 269986, upload-time = "2026-09-30T04:38:04.435Z" },
+ { url = "https://files.pythonhosted.org/packages/93/ad/bd74a283940dc910c5b14f8e4f80a248082bc9c0fcbe1f54530cb6d9cc5e/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28b4f0d66fb834ff90f28209ac7bce77868c45d8c93e26f906709d9b7c2e1af9", size = 260202, upload-time = "2026-09-30T04:38:06.549Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/7b/ed341c66f69f688723501fac752be3d63c7159ca0d0d4174fc611e5710bb/charset_normalizer-3.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58ca3755ee7ff7f59b57789ec9833c9de9ea275405cdd240eda1f193112e398a", size = 259083, upload-time = "2026-09-30T04:38:08.311Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/9d/e41588b777965e5031a43128a1e96173ebb35ac75fc53ec3b517e7c21cd4/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:443eae2bf318abeaf6f15d785138f71fd6de770e99a92158b8b814265e079115", size = 253081, upload-time = "2026-09-30T04:38:10.402Z" },
+ { url = "https://files.pythonhosted.org/packages/81/35/b761eb6d8c1eb218b9b42b9b4d5ac902afdc399fb6dac6f9a9aac7bda589/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:58f361dcbab699cf8f42db3f47c8e7fd1036f138c23a5d08de9fde5f425a730c", size = 248712, upload-time = "2026-09-30T04:38:12.317Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/2c/147169a041b747759f37405c0a97157e8e92de967968373101ff14915cba/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b4cbc7c3491ccb4aa17fcd8165649d01cf39f76de1696da8631b5f71b85401d", size = 274176, upload-time = "2026-09-30T04:38:14.138Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/2d/0ff8db0d373ba8538db686db11cd7e8912031490b9e4f383b41912e8d594/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ba0b1d2620edf869789c3879223f52bf2afc5d31b3cb47cc57b3a12c05e2aa9d", size = 259413, upload-time = "2026-09-30T04:38:15.841Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/8e/b4a085fb47c9d3a7e43576a4784fdd8fe23f907514a972de8086edaf7a48/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:5e2b6b57e9733d39f0c9fd3185efa6b8e29652c4cd8fe94180272cf6ed9a78c4", size = 269434, upload-time = "2026-09-30T04:38:17.626Z" },
+ { url = "https://files.pythonhosted.org/packages/83/1c/d8d8d7322a7c3eecdf3237a4a419cf41d2eaad8e006ce7dfdd9d4c8fa2eb/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:51cf45226a9b588d0d2b4880c62d686934b63ab0bd79ca23ab0e9762eb27441b", size = 262716, upload-time = "2026-09-30T04:38:19.214Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/16/0e4c6ba9b44e97a2da150e52d331e8f9c968b21b358fbffa6c856cebcd89/charset_normalizer-3.5.2-cp315-cp315t-win32.whl", hash = "sha256:5fb29fb8cd1a46c27a1bf9613ad5ec2599310d46b4025d9556404a6b6a292800", size = 197159, upload-time = "2026-09-30T04:38:21.037Z" },
+ { url = "https://files.pythonhosted.org/packages/be/33/e90bc2b1374f7f36ef106f56620de5a783907e19ca857efe2277e31cac3e/charset_normalizer-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a192e2c40070d92c3ccf777e3a5c4ff515573cd2bb7ed0c537fdadbbec5bbf21", size = 221322, upload-time = "2026-09-30T04:38:22.886Z" },
+ { url = "https://files.pythonhosted.org/packages/66/89/dfa6dcb08c200b7830ab56439e8c1890f2971d51aafbb3937894a2e7fcfc/charset_normalizer-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:749e97e1b32313717a565abbe321bc2190bc8b35f1a67e4cdbc7c56c8d8ffe58", size = 209192, upload-time = "2026-09-30T04:38:24.648Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/ab/176fbfd5b64939c55d652366aa5b9ef1d767af207a3aa6ebeb0d226c484d/charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd", size = 331815, upload-time = "2026-09-30T04:38:26.216Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" },
+ { url = "https://files.pythonhosted.org/packages/43/6f/c4fbae58febff71709c51bc7e18fdfa55341dc382704740f9f0cbf03817b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f", size = 241239, upload-time = "2026-09-30T04:38:29.732Z" },
+ { url = "https://files.pythonhosted.org/packages/61/71/458c3f42164a07d0c5210798e9e704b39e540a6793b05aba67f3a35243a9/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93", size = 231121, upload-time = "2026-09-30T04:38:31.462Z" },
+ { url = "https://files.pythonhosted.org/packages/09/54/ab9e89367076f6331bb6c65c4bf14a5361fa5191cb6561bf534f18504e1b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade", size = 260350, upload-time = "2026-09-30T04:38:33.239Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/c1/061431ecc688d9d76602502cb57cc01e691e682c18f1beb45f9673b5bbd2/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0", size = 255430, upload-time = "2026-09-30T04:38:34.865Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/1f/20c8949f0676f7ab811abdeb7f4d7f1cbc6e61ff20bef08b44edeb092bc8/charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26", size = 250612, upload-time = "2026-09-30T04:38:36.649Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/9e/46f2fa4c431fc98c4ae76a8cb5bdca54e0341e3cfc3fcfd8e82740250818/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011", size = 242083, upload-time = "2026-09-30T04:38:38.26Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/39/559be29a0c0f086e0bba6922babd38916cc5e0b58ced4de13ee01ea05508/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621", size = 232738, upload-time = "2026-09-30T04:38:39.81Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/6c/387b0e4f756a282831c1d9fc6aeb6c51ca4507ca202767c8de15ce9b12e2/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4", size = 260703, upload-time = "2026-09-30T04:38:41.346Z" },
+ { url = "https://files.pythonhosted.org/packages/96/92/1fdf015f09ef449f50d3ac4b67c90887c9c318b727daa95cc4f866e6521d/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e", size = 247622, upload-time = "2026-09-30T04:38:42.937Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/3c/8e7b8a5671ad5d433669fb2a76f1a0164df2d9b1718b0206bc2a16d840cc/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c", size = 257500, upload-time = "2026-09-30T04:38:44.604Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" },
+ { url = "https://files.pythonhosted.org/packages/31/68/fdec18a343f5fb3f310588dd478b09ac4799e0b187dbade3a8cd776f03ef/charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf", size = 174499, upload-time = "2026-09-30T04:38:47.999Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/8a/b618149cc5207943a0242068d7a27897f56a62947b5a039085f2a22029f8/charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036", size = 200092, upload-time = "2026-09-30T04:38:49.707Z" },
+ { url = "https://files.pythonhosted.org/packages/03/cf/4c66866fa9e2b1c78e3c911516d1de497a677b7ac60f1eceda74ce777ca3/charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e", size = 294363, upload-time = "2026-09-30T04:38:51.312Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" },
]
[[package]]
@@ -681,11 +770,11 @@ version = "0.2.162"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
- "python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"python_full_version == '3.12.*' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
"python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version < '3.11' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'win32')",
@@ -726,6 +815,20 @@ 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 = "courlan"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "babel" },
+ { name = "tld" },
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/16/2a771612ee0b3acaa95ac21cc7e8a3319e815d6360f8ffc5987d1ce28499/courlan-1.4.0.tar.gz", hash = "sha256:fbbac7b7fcde2195ea08e707609503c81cf39c891e8d26cdb1fed4585782d63d", size = 208997, upload-time = "2026-06-01T17:30:17.306Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1f/38/ce65091ff20a16e06d17418c4353af5f56d3190821b1a06983c79ae79274/courlan-1.4.0-py3-none-any.whl", hash = "sha256:ad1dbdefd912ca7238d4607dc855df5df097f56bac175dd662c84eed3802f49e", size = 34193, upload-time = "2026-06-01T17:30:14.984Z" },
+]
+
[[package]]
name = "cryptography"
version = "48.0.1"
@@ -753,11 +856,11 @@ version = "50.0.2"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
- "python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version == '3.12.*' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
"python_full_version < '3.11' and sys_platform == 'win32'",
"(python_full_version < '3.11' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'win32')",
@@ -828,6 +931,49 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/ca/1d/1271f287ff7170ddafc2aad36260c4eec20ccd2fea70f38455e9d56d427b/cryptography-50.0.2-pp311-pypy311_pp80-win_amd64.whl", hash = "sha256:7b75de3c8b3be1cdb1052747c929440c3eea46c1bc2cb8a6e3a48388e9b7b452", size = 3805376, upload-time = "2026-09-30T15:29:58.729Z" },
]
+[[package]]
+name = "curl-cffi"
+version = "0.16.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/e1/730125c43e3e331d98e17af3cb310ba526b3f1101b7635ca23d976ebfcf5/curl_cffi-0.16.3.tar.gz", hash = "sha256:d15d0c2a35f2d75bec430c28946c2a833f421c85773bdb0795182cc5c515665b", size = 239020, upload-time = "2026-09-02T11:58:23.266Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/79/7a/ec08ef0665c4ef4ea76b47042eb1c043e4afb374d8b9218e00272c9e73a2/curl_cffi-0.16.3-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:0f1f6878863fba393801e4d59b2f2766d1983b5c9d9dfa11d4becfd6a74cc937", size = 3025646, upload-time = "2026-09-02T11:57:39.326Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/86/e21b8ed384db26401a4438f20f01c7bcd9c3a6f8ceede458344e2d62775c/curl_cffi-0.16.3-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:f3b63da797912bc82911e34dfe449725514e4281527fb516931fc457087cfb44", size = 2784023, upload-time = "2026-09-02T11:57:40.986Z" },
+ { url = "https://files.pythonhosted.org/packages/97/2d/25b106e64178829be1ce171b6cd45ba354ab7a2a5169001866b38d4c440f/curl_cffi-0.16.3-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d5a4103f2baa1fcf619ec3101b419827d367044ba106b206228137cc71a5a9c5", size = 12834219, upload-time = "2026-09-02T11:57:42.711Z" },
+ { url = "https://files.pythonhosted.org/packages/72/01/2bbf141baa0fc3921d31a90de5465b7a94188845a8fe84dee86bf7bd90f1/curl_cffi-0.16.3-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a875a661e2f9a949be29454880bbb9553307a487c4c08819738298cf5c1622e2", size = 13484311, upload-time = "2026-09-02T11:57:47.58Z" },
+ { url = "https://files.pythonhosted.org/packages/36/cf/2fdaff71fd6f39c5994495af8378e6e26bca8e447d94d2f75a76337908c8/curl_cffi-0.16.3-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:60621b3f561346046dd62be33abfb50c8b88a8007699d6b11d39ad4755312c4a", size = 12588697, upload-time = "2026-09-02T11:57:55.138Z" },
+ { url = "https://files.pythonhosted.org/packages/74/55/68c399019bc24ea6ac783c98139a2555f88589631f3d127fe6b9073f019b/curl_cffi-0.16.3-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:20a7b1b473371cfaf2118958034977e457c6fa279fbd11543c9e0ab58be9eedd", size = 13253555, upload-time = "2026-09-02T11:57:57.524Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/72/1732a24ef4a2aeba994b80ec163debe8deda403c07e4abbc0443bca078b8/curl_cffi-0.16.3-cp310-abi3-win_amd64.whl", hash = "sha256:fe87b66e324ed7318166698e02169f3208dbda32b872a27d2bc61a9c19b335eb", size = 1978602, upload-time = "2026-09-02T11:58:00.033Z" },
+ { url = "https://files.pythonhosted.org/packages/45/bb/67bec3132aeabac99dfe2f299a9b43dcb5de23ad96219ee98516d177fc9c/curl_cffi-0.16.3-cp310-abi3-win_arm64.whl", hash = "sha256:5a2ba880019f9e5a9e8f38ae22de6e4ea4c8d34a51ae4f1a2fce962c7b632006", size = 1713140, upload-time = "2026-09-02T11:58:01.558Z" },
+ { url = "https://files.pythonhosted.org/packages/73/b7/99708ed83c11132ec0311a28ed46fe1cd10e8cb6ecd3c82f01f1f80c3c2c/curl_cffi-0.16.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8055ec9d7c15237747be254739c40057e3684f56854e95c12aaf3c95838ba2d6", size = 3026149, upload-time = "2026-09-02T11:58:06.973Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/d5/6c0400fb64097c4662da4e5d2d1e7daa8027d1431b1c8880c0f8f2051ae1/curl_cffi-0.16.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:391096e903ec98b909bb355e008ec7c211d710b6a23663a7f1f10aa54a027538", size = 2784153, upload-time = "2026-09-02T11:58:08.726Z" },
+ { url = "https://files.pythonhosted.org/packages/87/a4/3c8702d25e21f420e88707701af15006e72a2a2b9f3fa419c7c80ce7451c/curl_cffi-0.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6cef43f248b3635de9b82337e0ed2c7403aa1506e51587144d552702eb9d0775", size = 12839612, upload-time = "2026-09-02T11:58:10.745Z" },
+ { url = "https://files.pythonhosted.org/packages/be/bf/44a7e7a1e309136a1b086332feb03c7718169af550bdbf7eab52ae0497e0/curl_cffi-0.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e1fffac4b5a02c5ec74d184d668c5b882f80fa1d961e7adba6e1755877af41e1", size = 13488945, upload-time = "2026-09-02T11:58:13.15Z" },
+ { url = "https://files.pythonhosted.org/packages/52/83/5321d5fb67ff16195fb0c3bd5434be4532c85967c80546092a1cf3654cc9/curl_cffi-0.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:849026be5b36cf7b95d5fce63a84aa7b17248e83b4374e67715e7387ca2be50c", size = 12592235, upload-time = "2026-09-02T11:58:15.58Z" },
+ { url = "https://files.pythonhosted.org/packages/12/aa/0b4e110729a86b434196d15e2e2839d992a9b8f3003f0569c77e27a9faca/curl_cffi-0.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82cc688349c8e8955d346cc5cc7759b68742edc587ae47ba5783a096502a7a92", size = 13259593, upload-time = "2026-09-02T11:58:17.971Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/3a/e4f199cfc9f131411543aacdf6811d8b72b81ce6ac6e9f6ddffecfc31e54/curl_cffi-0.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:72376595490c4822ad1a5360adb568660ca66dff4ba2c2de2912778c15f43edb", size = 2031033, upload-time = "2026-09-02T11:58:19.949Z" },
+ { url = "https://files.pythonhosted.org/packages/18/8f/9354e5552982d38abd3ce2db859f049fee6bff0eee4e25aacaaa2b29f0b4/curl_cffi-0.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b450fad876aa9f9ed3edfb6e3a48a8c28eafa66aae634eff17800a8b5006568d", size = 1782234, upload-time = "2026-09-02T11:58:21.629Z" },
+]
+
+[[package]]
+name = "dateparser"
+version = "1.4.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "python-dateutil" },
+ { name = "pytz" },
+ { name = "regex" },
+ { name = "tzlocal" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/5d/bd21ba1519b6b1e222b29878301d2e1fb928e890dc7d085fa4222ac5671b/dateparser-1.4.3.tar.gz", hash = "sha256:bab8c43a746266e68142f4926e69438ce551441aa88e54e78bb6410bf3ee7000", size = 362152, upload-time = "2026-09-03T10:07:54.545Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/30/5f/63f927b5ffd1cc2c030fc2bd362bf920890e8806cf42f701198de5b3f9c7/dateparser-1.4.3-py3-none-any.whl", hash = "sha256:cbce86c64e0cea5c54c84c015d34c903d46c51bfad50632bf2f05a6141d10c05", size = 322384, upload-time = "2026-09-03T10:07:52.913Z" },
+]
+
[[package]]
name = "discord-py"
version = "2.7.1"
@@ -1055,6 +1201,44 @@ 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 = "h2"
+version = "4.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "hpack" },
+ { name = "hyperframe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e7/85/7c366e69d84c17bb778fe41419e1fbcce3033d5b7ce29bbffff0a98b859f/h2-4.4.1.tar.gz", hash = "sha256:4e866ffb1a869ae14dd9b5e6beb5c24a13da0495ad72b65925ded182521c1516", size = 2157281, upload-time = "2026-08-03T11:45:09.509Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7e/22/e85faf23bd72a92d1921e37d674ca56eb298a3c8be31fdecef0ff2b3aaac/h2-4.4.1-py3-none-any.whl", hash = "sha256:0e25f1462b23c9cb82d9eb02e28bc706dac2a68cb457c6a0d74d63c8a2a5d0e6", size = 62636, upload-time = "2026-08-03T11:44:59.164Z" },
+]
+
+[[package]]
+name = "hpack"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/5b/fcabf6028144a8723726318b07a32c2f3314acdff6265743cf08a344b18e/hpack-4.2.0.tar.gz", hash = "sha256:0895cfa3b5531fc65fe439c05eb65144f123bf7a394fcaa56aa423548d8e45c0", size = 51300, upload-time = "2026-06-23T18:34:46.667Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/71/b4/4a9fcfb2aef6ba44d9073ecd301443aa00b3dac95de5619f2a7de7ec8a91/hpack-4.2.0-py3-none-any.whl", hash = "sha256:858ac0b02280fa582b5080d68db0899c62a80375e0e5413a74970c5e518b6986", size = 34246, upload-time = "2026-06-23T18:34:45.472Z" },
+]
+
+[[package]]
+name = "htmldate"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "charset-normalizer" },
+ { name = "dateparser" },
+ { name = "lxml" },
+ { name = "python-dateutil" },
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/44/4d/3303caa82c75cd81e43d81906fa0f57c02c1e2e92ef9a3709cfe57fa678a/htmldate-1.11.0.tar.gz", hash = "sha256:e099a58143d5ff32471f2aa8770247e12f0f5bdff62f2df74f833277fd0071b6", size = 52776, upload-time = "2026-10-02T14:24:47.381Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/42/f8/6139fc95b889f44e9a4b373778f10315ade81b395a6298adf3c08415de64/htmldate-1.11.0-py3-none-any.whl", hash = "sha256:2a5a0d80cce38d3f986a64bb9ab64ba03e5953159b38fd78a841492131ead348", size = 33365, upload-time = "2026-10-02T14:24:45.42Z" },
+]
+
[[package]]
name = "http-ece"
version = "1.2.1"
@@ -1102,10 +1286,10 @@ version = "2.16.0"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
"python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
@@ -1179,6 +1363,9 @@ wheels = [
]
[package.optional-dependencies]
+http2 = [
+ { name = "h2" },
+]
socks = [
{ name = "socksio" },
]
@@ -1210,14 +1397,14 @@ version = "2.16.0"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
]
dependencies = [
@@ -1242,6 +1429,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/9b/43/832f631d32e4f1211caa2ba368317739fe71f0b8530e4c9d15dc454bac2a/httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32", size = 6382, upload-time = "2026-08-07T00:13:06.567Z" },
]
+[[package]]
+name = "hyperframe"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566, upload-time = "2025-01-22T21:41:49.302Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" },
+]
+
[[package]]
name = "idna"
version = "3.20"
@@ -1406,6 +1602,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
]
+[[package]]
+name = "justext"
+version = "3.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "lxml", extra = ["html-clean"] },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/f3/45890c1b314f0d04e19c1c83d534e611513150939a7cf039664d9ab1e649/justext-3.0.2.tar.gz", hash = "sha256:13496a450c44c4cd5b5a75a5efcd9996066d2a189794ea99a49949685a0beb05", size = 828521, upload-time = "2025-02-25T20:21:49.934Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f2/ac/52f4e86d1924a7fc05af3aeb34488570eccc39b4af90530dd6acecdf16b5/justext-3.0.2-py2.py3-none-any.whl", hash = "sha256:62b1c562b15c3c6265e121cc070874243a443bfd53060e869393f09d6b6cc9a7", size = 837940, upload-time = "2025-02-25T20:21:44.179Z" },
+]
+
[[package]]
name = "lark-oapi"
version = "1.7.5"
@@ -1422,6 +1630,177 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/21/7b/54d1df1f73ac1339b7df051982d386223202add5560a97839cf6326e6adc/lark_oapi-1.7.5-py3-none-any.whl", hash = "sha256:ff70fd5cdf436e26d80bf903fdd7a80cbdbd71981b87ce4c2aa49bb95fc96020", size = 7711907, upload-time = "2026-10-15T08:49:16.653Z" },
]
+[[package]]
+name = "lxml"
+version = "6.1.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/ad/28ecd7cb894d172f3c9c80a075eeeb2017ac62e3632cee05a5f9493547eb/lxml-6.1.3.tar.gz", hash = "sha256:45222d94ddd511536f3b2f7d9deae3b2339b4ce0f075f1ca25703b07cad9dd21", size = 4211198, upload-time = "2026-09-02T14:48:02.287Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/29/6b/a7d5c08e19a8e69887ed722fffaefdbaffc8959d5ef5c370a65e52c895ac/lxml-6.1.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:40bcbd9f94166ffe925811e730607385cec959f42fb1bb7dad83748680465221", size = 8575497, upload-time = "2026-09-02T14:46:05.131Z" },
+ { url = "https://files.pythonhosted.org/packages/96/dd/c25a32f9f6039a96cfd52296a4630075868aa16e71858b3076699a059201/lxml-6.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:05f5bce9af14fd1506997594bd81cee6d9c6b58ea80a39c058327aa6371ed9e9", size = 4619233, upload-time = "2026-09-02T14:46:08.898Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/f0/d49375a47644369d84f90a9fe4ff1924faad58d4f95563831eca84ca29ae/lxml-6.1.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff88a92cafde90888511242d1c54afcc1a8adbb6dc0a88fa7f87e29e92400d4a", size = 5015387, upload-time = "2026-09-02T14:46:10.797Z" },
+ { url = "https://files.pythonhosted.org/packages/76/0f/d1b1f52925442f7b4b1abd81a41905987322f6df6a5dd42fab8579415828/lxml-6.1.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c00e26288784460885fe76e4d4b293573e0f791f52e6d60e27b42edf005922eb", size = 5168571, upload-time = "2026-09-02T14:46:12.989Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/13/e5d8291a68a27e564e4e1eefba08c3844c6800bcb43f3e72a32b20971132/lxml-6.1.3-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:773062aec2f2e56b2b22d37054123f0de8a22a4688a0c3376c3fe42685f975cf", size = 5068024, upload-time = "2026-09-02T14:46:15.325Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/ce/dbea34cd115ae9b8ef53816daa912563615adf4daed42531878a2fb29c77/lxml-6.1.3-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f6449672f9c93316deb5e2839e18931f468670e44d5bd9b1301a5a9655d45c07", size = 5296830, upload-time = "2026-09-02T14:46:17.52Z" },
+ { url = "https://files.pythonhosted.org/packages/20/f6/12a2ab6e8c8afecb82a3f0e9a518952b6a1cddf405ad8542883bd71e6096/lxml-6.1.3-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:ec295280f4b37769256da025acf5890370355ac589c27e89caae0b5e9eedc702", size = 5424696, upload-time = "2026-09-02T14:46:19.706Z" },
+ { url = "https://files.pythonhosted.org/packages/02/3f/5670e198266c764595687a234fdaed33837f487b95a596262b2548e48933/lxml-6.1.3-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:5929d9df5e7e3379183be0e21f7d559618a5b61cb63280df6164019242e337ed", size = 4783635, upload-time = "2026-09-02T14:46:21.63Z" },
+ { url = "https://files.pythonhosted.org/packages/70/24/007ce6b7bffb61a6ca88c3a8f21b26f3f0aa3b3f6bb648a56e328c994a14/lxml-6.1.3-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6e1eb8a4cbffd5553680ad96be6680e364710656eced73d1dc90ec489df599a3", size = 5373212, upload-time = "2026-09-02T14:46:23.572Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/00/cf09f38cf9005bd5cfa4fd452b03b290b1c48c403fe0319a8013f4b3cae0/lxml-6.1.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:16148acd77ed1d8836a56db883af2f5eed720f9723088110b16a0d08582130a6", size = 5116476, upload-time = "2026-09-02T14:46:26.262Z" },
+ { url = "https://files.pythonhosted.org/packages/15/83/eb021e5db4336f0bb1438cba6f053ea135aa00b9f4ef0439473d6b986308/lxml-6.1.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:23c366231259cd75ad06495174701afb3fcb36a92917fa47de2d1f1bd9d95739", size = 4814172, upload-time = "2026-09-02T14:46:28.3Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/4e/147b6f9088cc191713249ac547b0af2fece489c8cdff1f2801ab47dda8a9/lxml-6.1.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:da85db328e507da922d586c3c7416ec360ec22e9cd9e0700691afacde0c81f53", size = 5361711, upload-time = "2026-09-02T14:46:31.035Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/d9/8cfdac0d7d771e25af2c1f4bc874032f025a4b59e0b6917c3c7858070795/lxml-6.1.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0f17d83c48ee9dfd96abae3ac3e2108c76d2fc86ce96355e37b8da9f7f4ecc08", size = 5321598, upload-time = "2026-09-02T14:46:33.165Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/5b/d2413c71f312dccdd07ed985be356657fc624d822ba7e2c87e8722646156/lxml-6.1.3-cp310-cp310-win32.whl", hash = "sha256:7dd624c1eaa629ad44b59a1a0145fdf2d67895592dce94c9358b938b3d075e65", size = 3604471, upload-time = "2026-09-02T14:46:35.245Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/bf/74b6785beac6488fd395e78796339bc197fbad6fd6103b41b15a4009dc4b/lxml-6.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:18a4db52b5a7b53a3540b0b0f4123319334621ee8083d496de314d0bf06ff59a", size = 4029086, upload-time = "2026-09-02T14:46:37.744Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/a5/ddf6e1744cd76fc9f0ce11cb16b117d6eaac46ebaeca01968e9014e8770c/lxml-6.1.3-cp310-cp310-win_arm64.whl", hash = "sha256:0feebef8d0521188d0157f758356072e840173aa61ca45b8b3f87959ac283dd5", size = 3674608, upload-time = "2026-09-02T14:46:39.802Z" },
+ { url = "https://files.pythonhosted.org/packages/96/f1/95133bde7af7afb1f5ba6090b674d826b7a518318bba54bbbb633b27865a/lxml-6.1.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c66f858b82497173f73366795fc6ee8171620e75a338506d6b2e7bc16f5fca11", size = 8563141, upload-time = "2026-09-02T14:46:42.334Z" },
+ { url = "https://files.pythonhosted.org/packages/80/54/5a79ee2181ac773ee13e48205411845feec69e1c3d097e985c1343171712/lxml-6.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:032a0a97eed428bd143c75a11118238546424ceb2fa311cca5f073aa44658dc4", size = 4613690, upload-time = "2026-09-02T14:46:45.253Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/29/8c24672f56807f119312f073f24204368574bd16b384ede861b5104b3a2b/lxml-6.1.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4a579dfb9c835f8ab47f4b8ed33440cbc75b806b73297208e6ec2a33e903740b", size = 4935630, upload-time = "2026-09-02T14:46:48.071Z" },
+ { url = "https://files.pythonhosted.org/packages/71/69/ce2436d854c848c19fc9287143991f3fc76b8b4e9a0dbba8452e51dff264/lxml-6.1.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:49fbc2682a9306135b7ec49e93f97f9c26689b9b7f96ed2742d8d6497e994d13", size = 5079033, upload-time = "2026-09-02T14:46:50.483Z" },
+ { url = "https://files.pythonhosted.org/packages/91/ec/b66f66f6499ad800265d57540b51e6632e3232d3526f42f2f8fd4b14e0ea/lxml-6.1.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ea2c01cdb16dc12156e455007c406dfaaece0c89aa4ba0e3b47586779f951d41", size = 5012298, upload-time = "2026-09-02T14:46:52.603Z" },
+ { url = "https://files.pythonhosted.org/packages/94/2a/25d128872f4d51753542bfc3feb482c2ea7c8a2d6d81a0bc5c6a00779ed4/lxml-6.1.3-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:527195c188d7d0af748cd48d220ab8cdc5cb99be3d49ac4d9be7324d8abf9bc0", size = 5211431, upload-time = "2026-09-02T14:46:54.722Z" },
+ { url = "https://files.pythonhosted.org/packages/75/b2/0a41bbef074a556110f84fafb6d8c2998293c7d3bfbe1ce74515bc65393b/lxml-6.1.3-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:20384c2bbcbf87180c8c61eb60869699c1ec0cd09b62cfd13804022d860b0867", size = 5343417, upload-time = "2026-09-02T14:46:57.46Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/cd/16116c3f91791aeeeab1cbe6e7eb6e646f127be7b0158b262eb526a21a0c/lxml-6.1.3-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:424aa5657141d306ba9ad1baab4b2c0a0719040075ee6c66aee9bb2dea2b5054", size = 4673219, upload-time = "2026-09-02T14:46:59.604Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/bb/4dff849f443ef70221676aec938bc41e8bae6430aa2ca13b041319e14b98/lxml-6.1.3-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4736e6c87e603146d8949d8501da621ad20c31015060d3fcf95ace2859f3e3e6", size = 5281246, upload-time = "2026-09-02T14:47:02.375Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/ac/4aa7dd059420bfd35278c7fe819e9d319ee36a0453b7bbde1907a7832d91/lxml-6.1.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6374e9e382e5a98c9c5e66d41b357b470da1c54bce30f17f9dc4bcc58436cc1c", size = 5055451, upload-time = "2026-09-02T14:47:05.883Z" },
+ { url = "https://files.pythonhosted.org/packages/de/44/20d90cf6f4234de9cd9eeb4f519419885fdb087fa80d073c7b57be342021/lxml-6.1.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:22eec57e26c418cde02c051ce9914a365e52a7f135a565c6f0480242aeebab48", size = 4722694, upload-time = "2026-09-02T14:47:08.461Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/0e/6bee12325e53dd6613fe1e107def07583b6182ade03e94bfef8976622e44/lxml-6.1.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8753b8d51dbc86fd335ee31fcf7f3658e9f5c016d4edfb23f76ad295f4b8c9d0", size = 5269179, upload-time = "2026-09-02T14:47:10.647Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/5d/54d269ce5cd0787c0424d9cef449ee794d4097725d13dd2acd6181c44e9c/lxml-6.1.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:207dfc3d47cf0e575e643bbc140dacc8863b39abaa1e5307cd64c7f2365b8a12", size = 5235559, upload-time = "2026-09-02T14:47:13.932Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/f7/5a3095f187f1bec293591616a1677781acc265c5b313c009f8a19c471a09/lxml-6.1.3-cp311-cp311-win32.whl", hash = "sha256:18293f8a8d8b6a8e71ef37706b659e3846a4261232158167b1ddf35f6994f633", size = 3600377, upload-time = "2026-09-02T14:47:15.957Z" },
+ { url = "https://files.pythonhosted.org/packages/45/5a/15531a0d307c96282fe8b639b3d74e8bd783e4ab4cb2b0781146ac4161b8/lxml-6.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:7ae4949f212a53b007dbc355884fda122545c5764a54256c9217e419a62a6559", size = 4032700, upload-time = "2026-09-02T14:47:18.566Z" },
+ { url = "https://files.pythonhosted.org/packages/12/f9/8de76314955545ceaaa7c0305017b8aaa217905dee59c62c0e2c1e44a68f/lxml-6.1.3-cp311-cp311-win_arm64.whl", hash = "sha256:2123e5aa075ac20d23c7af489255efd129cbfe190dbe88fd42598cc9df3199b6", size = 3674431, upload-time = "2026-09-02T14:47:22.186Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/1f/a180b57d9eeabaab77f9d5aa30356898ea749c4795596a8f66d1eb6bef2e/lxml-6.1.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c0710ac085a157b593c38fbcacd950f15c4afa8e2057527185875ab302752bc", size = 8602094, upload-time = "2026-09-02T14:47:26.054Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/25/070c92013a1c029a602b03560d68772313d918268667fa993da7961759c9/lxml-6.1.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:623c8799c17128753c65699f1c3aa32402657393a9ad6db09ed8b98ddf76611d", size = 4638308, upload-time = "2026-09-02T14:47:29.587Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/1c/722e88883173097a1a375153e3c2447eba3060d0231522cf6596e99f4195/lxml-6.1.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f683dc6300317700025e41d89a43e0276692ded16113a3c43eab704d605c58e5", size = 4939696, upload-time = "2026-09-02T14:47:32.997Z" },
+ { url = "https://files.pythonhosted.org/packages/db/36/aa413bc214dc4f785ad2b2ddd8cc99aae7062d49ab155e91e6011af00daf/lxml-6.1.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:379f8a75cf6eb7eef0af074b55f49ab73b868388a98de14646abcdfa4564bb11", size = 5105247, upload-time = "2026-09-02T14:47:36.734Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/a0/a1f7f1313795bfec67b77f01ef3b1128d49f2d7f66a8413fa55d47f4e25f/lxml-6.1.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b37772102d44bb6628186accca3a121b1fa3a6b3d97518a8c29a5229ca4c0d0a", size = 5011915, upload-time = "2026-09-02T14:47:39.846Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/78/840e7e3f1d0cc7a5cfac5d8505b97e25b6427fd774ac4bae672aaebfb4b5/lxml-6.1.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ddcf547bea2aee967d6a77779376a45e77e610e8465147a1f3d7e20d539d6e32", size = 5638175, upload-time = "2026-09-02T14:47:43.644Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/20/e022dbc6b4753a9bc9fc5fb28a27163430c1731b9913997f6544c1b2518c/lxml-6.1.3-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:909f4e927bb051f7740d6367285fc60cdcfdaf0258c2dba4ff5ba7eadadc250c", size = 5244675, upload-time = "2026-09-02T14:47:47.635Z" },
+ { url = "https://files.pythonhosted.org/packages/99/83/82cde81d2b5eb38d1539fdfdf318abdd014a7e604f4df01c9cd3deb18f2a/lxml-6.1.3-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:a5c18810318303ce9afb3f95e2ddb54834f96fa699a8600433fd5a93dcf44c56", size = 5358205, upload-time = "2026-09-02T14:47:50.306Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/a1/f3b057371c8cb29f2a9c9c44ea320592446e40b74a4b0af68c3d8e65bc73/lxml-6.1.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:3e42265103fb385d8642a78672edf376c6f7e1d3598a7a4f9cb1278f2f6b5f6f", size = 4704495, upload-time = "2026-09-02T14:47:53.251Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/a4/230eb28be5d412152ffc3c679b51fe1aeede5a53f3a8eb6e9748f2f4754f/lxml-6.1.3-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:21402998e4b78e7cce237d2788841aaa21ac9a4d1574d04dc2d12ee41ae807b5", size = 5255117, upload-time = "2026-09-02T14:47:55.963Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/18/1969f56763af24ce42ea156007b0b2d73fddea552e283b2010416394f0f4/lxml-6.1.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:38fc4e4e4e084e0bd491949482527d406788045c546d4f8789e93fc527b91385", size = 5054424, upload-time = "2026-09-02T14:47:58.131Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/d4/2a90acc1f6fabaa3a8db9340437822bd8d041b205d626a4b3e8621aaa390/lxml-6.1.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5609efdb0d3c95499c00046bc53648b3482ec2175b5503d6e611b3f0555dc71d", size = 4785572, upload-time = "2026-09-02T14:48:01.029Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/1e/b90e845b1dcd0f2f3f26b98283d857f25909223aacd265eee032c34ab8b1/lxml-6.1.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:97ce49699d87ebf8aad631b55d65b33219a4f1bfefbbf5bff19dc9af160aeaf9", size = 5656516, upload-time = "2026-09-02T14:48:03.419Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/ab/0a1b802c57f3fba5c4efd77d5c6b78adaa8f7b681f0c90456b140fe8bf6c/lxml-6.1.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:48542c9acba9ff9450bd18d871d2c2c8787fdb283572b623d206f1b927cd7d9e", size = 5245982, upload-time = "2026-09-02T14:48:06.109Z" },
+ { url = "https://files.pythonhosted.org/packages/da/ee/2c016fbceb3778137459292538d9dfa7e3ad9070fe409c15254ddd90d2cc/lxml-6.1.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c55e71a9b1db1f107efb60da49c093689b74c5c31a708e5379e2fd9439d4fbb5", size = 5267340, upload-time = "2026-09-02T14:48:08.374Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/b1/736d18fd6f0835761923b7bac1f0c27d60c1200384e9093f05d8c5100525/lxml-6.1.3-cp312-cp312-win32.whl", hash = "sha256:b3ff39654f0ce6ebd4db154211136dbe7e8157bcc3bed2344c87f32c7c6ecb6c", size = 3602606, upload-time = "2026-09-02T14:48:10.384Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/5b/6ed903e4e6278a020c8a6f0dbbe78030d041840a6b4a64ea441a1e414077/lxml-6.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:3e9a00d1c2c30936f7add097c41afc5da6556c580909104aafd382cac92a855c", size = 4005999, upload-time = "2026-09-02T14:48:12.51Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/1b/7bcebb7b6332cb3ae85e9c13b139adb6f23f75c71d84041c56a5005d9a29/lxml-6.1.3-cp312-cp312-win_arm64.whl", hash = "sha256:1aeca87830c4fe649dcf93fe2b059525b71c72587f21be4ae4af7103082a79fa", size = 3666631, upload-time = "2026-09-02T14:48:14.567Z" },
+ { url = "https://files.pythonhosted.org/packages/52/05/3ef45db776baea068044c799bbba68f3ca00a440c0e930a17c572f3d9639/lxml-6.1.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3a48093cdb058a93af842ede9703520e810b05dcd0fc6d7190a06376c3bfb6bd", size = 8590357, upload-time = "2026-09-02T14:48:17.413Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/a5/eee2fc77eee5ea68e4a4334b1def1781a3beaeefd3d98e81b4a38dc447b7/lxml-6.1.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:887c021d9a977cff89cb273047c1352997b772a8908a25c21836861f69b92be1", size = 4632616, upload-time = "2026-09-02T14:48:20.745Z" },
+ { url = "https://files.pythonhosted.org/packages/35/42/df27b56848acd29d8a720acc28977911aab36f2a09df4208d5502e887415/lxml-6.1.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:611a51e61c92f62345a50b0035df6fc0d678f9299f33728826d831598862f59d", size = 4936186, upload-time = "2026-09-02T14:48:22.94Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/8d/8a7b91df0b54d09d25f5f44885d6b3e0a6d6643a8c070191580318d20c42/lxml-6.1.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b477912f42c5c33405a10c759d22f80cf5af043ae02d95b9d8e5e5bc555739ed", size = 5093324, upload-time = "2026-09-02T14:48:25.132Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/7e/8f340ddcd43790332fb0de8a26628d571a492da3300cd191821698407c96/lxml-6.1.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cffe18571ccc51d742cd08cbb3f8b756de9311d18c7ea98f5d92f37b8fb60c2", size = 4998850, upload-time = "2026-09-02T14:48:27.394Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/c1/9c5bb572f1f09ec9e4322bd4a4e9f4ad48347fc56ef94cf4df58a5279dc8/lxml-6.1.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75cc6569e86be5785b6188ef1642670c6adbc984e81ec35e224842ecd9eefcc8", size = 5626813, upload-time = "2026-09-02T14:48:29.61Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/7d/8bf1fd8bae8247743968bb76d027a1ac5bd2c4b44495fba6a71b30d10706/lxml-6.1.3-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d85dfab42dd672f87a7f76e9de7172962aee69fa12044f0d6e1a23cbd53fb80e", size = 5232385, upload-time = "2026-09-02T14:48:31.969Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/2e/6cef69ed81cb7df0d03b0dd09d08e6e2cf5061a743ff6f42f0b741548e9b/lxml-6.1.3-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:42632b4024ab24a6b488f559ac851312509888b6b80ae2aa11cf29a646a0d245", size = 5347088, upload-time = "2026-09-02T14:48:34.13Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/e1/8e5fd8ddc8c7d685badb0f2db149e3c9da84eefc2827c01c658df2c4e3cb/lxml-6.1.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:febd35ef45f603c2d74b74655efdbf45e14f55fc0aef4ac82b663ca829b283e0", size = 4707227, upload-time = "2026-09-02T14:48:36.62Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/7e/00041382a11be40a88bf405ebff11c8efabd3de79f2691e1638b1c47a8a0/lxml-6.1.3-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a43b3bdf11e477dc7770609d3477316f974354dfc8425d596f64f471cc8daf6e", size = 5240208, upload-time = "2026-09-02T14:48:38.893Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/fe/316538b5cff0936fa63d45d421c655730fcbb5a28dcac728c175083002bc/lxml-6.1.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d582042c69857c364e8153de6e18e0da9b7b515a6a8113caf69a6ec8e0520f2", size = 5050271, upload-time = "2026-09-02T14:48:41.213Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/91/455bcccb3ac725373007344d351151810cd19762d1673b64b811f4359a42/lxml-6.1.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:8e49a646acfab83c68974f4aa1d0a2acca9e88d7d627ae0fc13201b14b76d310", size = 4780433, upload-time = "2026-09-02T14:48:43.779Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/f6/580440e2f52cf00bba5c5e1080bfa88cdfcde73be71a11d95170ddbb663f/lxml-6.1.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0dee106e9aa97fb00541b1ed7827070564d0549c3d3fba8920e6b20fd980f748", size = 5645928, upload-time = "2026-09-02T14:48:46.187Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/dc/d123c1f244306543d545f62443f794959e4f1ea709fe100f8740d514e74a/lxml-6.1.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:dd5e90f34cffcfed97f36cf066325773d2b6021c60c29942e53a18b028501b1d", size = 5231184, upload-time = "2026-09-02T14:48:48.691Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/3c/fe55b2bd5c6113c906511cd88f6a470195c5fbff1124f19970ab706c3477/lxml-6.1.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d9b3e7d71bf6acff341233417abbdface29c647e3113892d9aaedc02eb4aa2bc", size = 5255814, upload-time = "2026-09-02T14:48:50.948Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/a7/485df55acf55dc35e4ca89d2f48f03889e5a3241826b18b85102b32ce9d8/lxml-6.1.3-cp313-cp313-win32.whl", hash = "sha256:160fcf381f76c3aeac28a756bec44f48942a8f7245a87aa28e3a523b4d90cd87", size = 3602214, upload-time = "2026-09-02T14:48:53.236Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/28/e46a7702bd95e9043291f7c3539b6184cba66f96cea9936f20939b284eeb/lxml-6.1.3-cp313-cp313-win_amd64.whl", hash = "sha256:e477aca0bc0d19f3b4ae9e4f2a1cfd687c31bf772d78734910658186b40b2477", size = 4004091, upload-time = "2026-09-02T14:48:55.699Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/1d/154c78e20479a43916e63f19cb720d83f44f024b03228be44c92d9a97b24/lxml-6.1.3-cp313-cp313-win_arm64.whl", hash = "sha256:b1cc980905221a5d8b3c476330730b3adb40ff80add71ffbdb6215ba055656f1", size = 3665468, upload-time = "2026-09-02T14:48:57.703Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/15/fc75a70b0af6021d0ea16811f1fc71cc42cd06ce90fe10f007a69b2eed84/lxml-6.1.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:2bec13085dc8ef48a3fe62f7dfcacfeda2c785cdf19cc8eeda2bb9ed081da165", size = 8609725, upload-time = "2026-09-02T14:49:00.156Z" },
+ { url = "https://files.pythonhosted.org/packages/84/ef/398fcf9018f881ec9aeaafae1ddd6586dfb13314a35d35e899de373dcae0/lxml-6.1.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4f4db7c7e954d289d71878938348b3d91b904a3e8210a11939359fb758a58e7d", size = 4639629, upload-time = "2026-09-02T14:49:02.81Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/2d/49b6a6ad7ce8f64b07b9fe852ff0c6d3fcbb26db61bee4f63d4120180a1c/lxml-6.1.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2cae5d5c90a62d9139c512a0cb1aad1d182b022b5740daea2617eb5bf7fc658e", size = 4965074, upload-time = "2026-09-02T14:49:05.133Z" },
+ { url = "https://files.pythonhosted.org/packages/66/bc/6230cf80e4331c33383b0b6b73dc31a393dd76edd4cb73d761de5123034d/lxml-6.1.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c6c0c13128a32eb04a51357e56a094e13aa8e6d3d1884de2e9ae923f6915e1a8", size = 5099355, upload-time = "2026-09-02T14:49:07.343Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/cf/d1143d9b7717e07a82f158a1fc9ce6e581fdad1226734950af869e3ffde4/lxml-6.1.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2221e88679d1351e9a40aaee54bc65679b9795bbd0160bc3d5e36b163344eb75", size = 5036795, upload-time = "2026-09-02T14:49:09.65Z" },
+ { url = "https://files.pythonhosted.org/packages/31/6f/194bb00ffb89712c30f5a7e1b8e685590e140fad6c8261fec172c09a3dc0/lxml-6.1.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cfb398886a7eb4c719161c3efcff2a1248febc53a4d8e5072d2d8a87fed84ac9", size = 5658740, upload-time = "2026-09-02T14:49:11.9Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/44/27e3cee3dcdb3b7bc09727b642bdbfcd098490ea77df04611db9060d7722/lxml-6.1.3-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7eb78ba28b187e1e9203a55c60fcf70df2d22cb205fe6d51b9383d6097419f0", size = 5245991, upload-time = "2026-09-02T14:49:14.154Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/e9/8312560579fc980bbd2233a8a673cc46f7d613d3633f2bf08a21e8f4ad13/lxml-6.1.3-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:ea6b1e9105b4b24a34c722432d9fb578f9ed83af21fa1abda639011e0f22bbb6", size = 5354136, upload-time = "2026-09-02T14:49:16.459Z" },
+ { url = "https://files.pythonhosted.org/packages/74/d8/eda60f4f73a9c780b5d6e1175484f66e6c81a2c93346e2906a1fec9c7a02/lxml-6.1.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:e8b17e23df3e827a69d25af70990ca2420e92668aaffaeeb3cd2351d7916a023", size = 4704379, upload-time = "2026-09-02T14:49:19.032Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/c8/c9cc60057be78ac34bd2b842e45e6e88edbfe5e532e82c3b82381b7aab49/lxml-6.1.3-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b7c37339d7e75cab9a123a04248e243cefefb302ad6db566ea0c77cbcde421e", size = 5258676, upload-time = "2026-09-02T14:49:21.306Z" },
+ { url = "https://files.pythonhosted.org/packages/41/7b/66894008fee8d1785b8db129747ae963fd427b68f456918df7f2f24a8b98/lxml-6.1.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:83e3a51e7933db700a0da0db31849db3a24022d9970da9bb73001e1d0326fd92", size = 5090069, upload-time = "2026-09-02T14:49:23.562Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/31/c1b60404859f4c3cd1f41f29c65a24e25cea78fde822d9574a21f66810be/lxml-6.1.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:9bde9ae026a55b9a192078dfa6e27dd0ca4a050171ab6272e92f97b757dfdf48", size = 4741958, upload-time = "2026-09-02T14:49:26.037Z" },
+ { url = "https://files.pythonhosted.org/packages/23/b8/6285f0cf546f14da2554cabdeaf7c2c2ff3190c74807f0de2e8810a786f9/lxml-6.1.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:1a635e837b50a1819bebfedaac5916498ea024120969da8790500148fb0a894d", size = 5683245, upload-time = "2026-09-02T14:49:28.438Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/f6/2168cab44336dcb15fed0f0b78577225b83297cdf0dee349c95420c3dcb0/lxml-6.1.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d0c5c362bc94f1929dc7e96e715bbe7bd17037f802e6d8f0d1545df9133c0559", size = 5246087, upload-time = "2026-09-02T14:49:30.955Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/89/32f5de69a0a31f30e6164981851f87b37ecb2c4ee838e504b88d49d4818e/lxml-6.1.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c59e4265608da6a041f54646ecc0c9ecdbb19aaf14c4c684bb6c2114998cc415", size = 5269352, upload-time = "2026-09-02T14:49:33.502Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/a1/741d952ed3a7ef7a50055c6415aec3f067015e97f72f4389ce77b09657ba/lxml-6.1.3-cp314-cp314-win32.whl", hash = "sha256:2e62c569ec7531b679b184cbfe335c501c1d13c4b363560013019962eb630e6d", size = 3662783, upload-time = "2026-09-02T14:50:23.751Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/bc/5811cc73cac05e324e05ba9b0924e1a163a317a167ede8a9c748b11db30a/lxml-6.1.3-cp314-cp314-win_amd64.whl", hash = "sha256:66299564c046bc7e0cc5de5106601eae907e9fa5904cd68a323380a8502f7861", size = 4073951, upload-time = "2026-09-02T14:50:26.348Z" },
+ { url = "https://files.pythonhosted.org/packages/92/18/3768c8b01ac3a9bed1914715e6011711b00e2a11628ffa6f7fa37f8e0269/lxml-6.1.3-cp314-cp314-win_arm64.whl", hash = "sha256:ebd054ad1737a68fb7c5c073d405cef2b88bb824e294de3b4a4e995b47f0e376", size = 3749279, upload-time = "2026-09-02T14:50:28.749Z" },
+ { url = "https://files.pythonhosted.org/packages/72/38/84684784738d9451db2b330de2483f496690c3a5c642071df24135739b37/lxml-6.1.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:5a143e6207579de8baeded4eaac9134413200359f1969d636f0bfb98ee8c3c8f", size = 8860296, upload-time = "2026-09-02T14:49:36.346Z" },
+ { url = "https://files.pythonhosted.org/packages/24/b7/fc4c50bb1b38e864010ea396046cabe85129bf9e65b11edcfbc37d356241/lxml-6.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a1cec0f99b9b914d39176347a93b7610dc09324491aee1cbc57cd291a41a1d55", size = 4755190, upload-time = "2026-09-02T14:49:39.872Z" },
+ { url = "https://files.pythonhosted.org/packages/94/e2/ee9aa6ed2b666b2db1f6f7fd48964ff9da39ebe827ef5eac0ab881f639d9/lxml-6.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f6b9d2aad499c769ee8287609ab0e6de99d8bcea99c6e6c2e64945259fd52fb2", size = 4979517, upload-time = "2026-09-02T14:49:42.153Z" },
+ { url = "https://files.pythonhosted.org/packages/29/e3/e7763d1661b283ddd4fa36f91b9a497db6b8d2aff55028b16c7f642e0755/lxml-6.1.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a23fefdb345b2d4d0ff2860571b5ff9a89a28b6a120f720e8fb0324d346626", size = 5115270, upload-time = "2026-09-02T14:49:44.493Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/cd/22205d5b4d177e3f4156f780412426ee7c7f8107809f119f0dcc40fa51e3/lxml-6.1.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:545ccc14fb05485f48b4439ec35beb16d5b5280eb6c81c658bd4707a2a119414", size = 5032449, upload-time = "2026-09-02T14:49:46.841Z" },
+ { url = "https://files.pythonhosted.org/packages/da/43/06a4626c3bb79ef8c501b674afab8100d64e798665bb2a97d1c960636a49/lxml-6.1.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:93476b6514b373fc6ca67d26c442784f7807c86f00635bfe79f935c3eab2af17", size = 5603325, upload-time = "2026-09-02T14:49:49.664Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/9c/733682a0c2de9f5779ba207bbb3f3f6be8c6bda863fc01739b186b38783a/lxml-6.1.3-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8db38ff3fb7aee7d6a82ae4da2eef1178656fe1216841fbd24870062a9d60473", size = 5229023, upload-time = "2026-09-02T14:49:52.447Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/8a/e69cdaca3fd33a647942925664f01b20908d41a6968c182305be9c38fb11/lxml-6.1.3-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:25f4118c438f96bb466e83108506d03d5c31b1bd2387e83e5b070bda6ded9c37", size = 5317811, upload-time = "2026-09-02T14:49:55.25Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/b2/0c397588174403c2ab68fc464abf97e03e7324f9c6cb6a99023104707195/lxml-6.1.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:1beb0f9909b26cee938df9ba56b15252a84429b1fc30ce6fca161390b9789a70", size = 4646516, upload-time = "2026-09-02T14:49:57.761Z" },
+ { url = "https://files.pythonhosted.org/packages/56/7e/cfea25afafbe49db8b225764f7f74bb37c2a7f5e717d917d3d4a5e098ed4/lxml-6.1.3-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3a27ac6c780c8b8a1cd231b58407634cafc1c4cc28cd6c7141362df0f36351e7", size = 5240626, upload-time = "2026-09-02T14:50:00.279Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/75/7a587771bb52ebb0e2c57b6dbe9fd96a70fbb54d72ddd97d54c5f8ec18d5/lxml-6.1.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a1932d7ce78a561367512c594fe66eac2b2ec9b9264cfd9b5f950622f4a116e2", size = 5086619, upload-time = "2026-09-02T14:50:03.245Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/01/94c0ebe6d831861542d251e038052e52bf6d33f1d18f1cfffdc82851065a/lxml-6.1.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:7d0f5976aa2701996f759b30172925829867547bb073af0ae67d1307a0f0262c", size = 4758828, upload-time = "2026-09-02T14:50:05.873Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/f1/938d67bd0e5b1fdfa52be28aefdffbad57e1f6b8e921c2aab88542c75f40/lxml-6.1.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:c5e7ce578aa8a80910a72a8ca0bbea3baae10100827249001999726a788456d8", size = 5627083, upload-time = "2026-09-02T14:50:08.555Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/65/4e51522f6c214650db0abb7b16ccd11b1238b8a05a8d59aa4ebed59c9f67/lxml-6.1.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d97c5227621af74b111882a290b10f371780a38eef9d9e730408fba2259b52fb", size = 5235170, upload-time = "2026-09-02T14:50:11.255Z" },
+ { url = "https://files.pythonhosted.org/packages/92/c2/e73d19365665f6b16ef84df21199befc3b06e4c539046ad2d9595f6fb9ea/lxml-6.1.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:da707f14ea3c35ee463d50acd596d6488e4b2b4ae7cf77a5bf93f55c023d63e8", size = 5252273, upload-time = "2026-09-02T14:50:13.782Z" },
+ { url = "https://files.pythonhosted.org/packages/48/a9/7f386c84c9fe2854e1ca6e231c285e1c8f392971ac353c6865e6ec49faff/lxml-6.1.3-cp314-cp314t-win32.whl", hash = "sha256:9efe56a68179f3adc4de41861c9358931db03837c48dd5e1c78077b84dd07f3a", size = 3902712, upload-time = "2026-09-02T14:50:16.171Z" },
+ { url = "https://files.pythonhosted.org/packages/82/a6/8a3eb793f7900ef01c7f99e6f5fcbcfbdff35251cfaef66b32a4c16352d6/lxml-6.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c9389b3784b56c58d933b5e0aecdf28f901b073ff385358d8a7d40907f6e14b2", size = 4400979, upload-time = "2026-09-02T14:50:18.621Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/c4/3807bea283b4fe9e9d9f5dde46a73df91178472b335d2778e10b2a37aa22/lxml-6.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32a409be3190b088f960ac92bfedfbef2f86c49ff940765e1548177592d20026", size = 3823401, upload-time = "2026-09-02T14:50:21.119Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/8e/4614fcd65496054cfb7172662f3576a59200278739506433b8c241ea422a/lxml-6.1.3-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:6ea2f13dce778ca072ccee598bca46a092ce192e8fd907b6c1f0e52c800529a0", size = 8609378, upload-time = "2026-09-02T14:50:31.772Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/51/2cdce3c65fa99a6195dd8fbd512d33407c1000ad99f63e0a285b63d7a8eb/lxml-6.1.3-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:c581b1d68b3845fb86c6b2983e755b29bf001461c59fa411d2c26a911b6559a9", size = 4640022, upload-time = "2026-09-02T14:50:34.41Z" },
+ { url = "https://files.pythonhosted.org/packages/52/09/0b30084e9eb1c546a4be3d9c56df70058d116b1a320400a59b0f7da87bf0/lxml-6.1.3-cp315-cp315-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e01125896585139453cab8cb235893644d8815d7509520da95ae3ee8d1c1f79", size = 5037928, upload-time = "2026-09-02T14:50:37.007Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/0e/5c37275a3e361f6138dc06db748ea565c1fe8a5f4ee5e2ddd80047c81a89/lxml-6.1.3-cp315-cp315-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:290f66b97ede0e552e1cb44a0fd8a74f9753ee635b50830a0b122fb72788d015", size = 5661932, upload-time = "2026-09-02T14:50:39.777Z" },
+ { url = "https://files.pythonhosted.org/packages/70/c5/b71ffb289b15e2642e2a3cf6d468c44da39ea119061a99e5b05e3d10f217/lxml-6.1.3-cp315-cp315-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:73fc05988ed20809450474ba760a87c8ad4e455fc09783c02195e56ec634b41a", size = 5249209, upload-time = "2026-09-02T14:50:42.141Z" },
+ { url = "https://files.pythonhosted.org/packages/81/ea/9910da149a23932f9301652e57661cd9e42b0df18f12be21159b7255f92b/lxml-6.1.3-cp315-cp315-manylinux_2_31_armv7l.whl", hash = "sha256:dc3a44689eea43eab836e5c98a8ab015dc2419987d1ea6eafc7c590cdff86bed", size = 4704543, upload-time = "2026-09-02T14:50:44.634Z" },
+ { url = "https://files.pythonhosted.org/packages/76/07/9290329cd188c62e22021f79df04ee0cc33d9a93b0d38bd65ccd452ad9d0/lxml-6.1.3-cp315-cp315-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:209c3ccbfe35a04ac6d24f0611f9d1cbf8025d49991b14acd935236234d6c156", size = 5261298, upload-time = "2026-09-02T14:50:47.301Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/0c/aba78bd3401cd99b73a0aed8e2b9b43e14be94fab3603d4bbc8a62365f2a/lxml-6.1.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:2f5b2a2b9811b853b39bfa41367c6d78747b8e3e80e07fc5a24aae295c1a4d7d", size = 5090453, upload-time = "2026-09-02T14:50:49.952Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/dc/fa4426c3355aa0216cbeb3911495b5f65a26e0df85859a89928fe28f0396/lxml-6.1.3-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:6a406d0b3cb207b0fa460ed4dc93e866f44f105da0169361cb18ff998a44c7f0", size = 4744709, upload-time = "2026-09-02T14:50:52.394Z" },
+ { url = "https://files.pythonhosted.org/packages/be/2b/224fe7918658ab7c532ac2412f3c1eb28f71e6364fb07566262d0cc6a7b6/lxml-6.1.3-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:53258656846f5c48996b882fb4b135885e088a3ad3d96b4bc0530f95124d1f69", size = 5685802, upload-time = "2026-09-02T14:50:55.043Z" },
+ { url = "https://files.pythonhosted.org/packages/21/44/7d480819b9adcae5f84dd8ac529132c6b7a578544398225cd20321adcd91/lxml-6.1.3-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:aa633613ff907ea91b9b0489a1f0da1b8725d8c6ccec6b77e8a1c9c235044bb0", size = 5249019, upload-time = "2026-09-02T14:50:57.985Z" },
+ { url = "https://files.pythonhosted.org/packages/72/83/385a267ea1b6b283f2249dd827ef360a295e9db14e13ef4665a120c60d64/lxml-6.1.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:90f709b9accab6b2e4d14f5c8718203877a0486bcb3afd74d8b539ecd1e961d4", size = 5271886, upload-time = "2026-09-02T14:51:01.667Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/0d/f967b0eb172ae876855a402d6d9b11fa86e3e0c89ca9bbfeadf7ffbfa719/lxml-6.1.3-cp315-cp315-win32.whl", hash = "sha256:b4fc6b03b9d9d90557274f571ab30e7fbbfc527955536935d96f98b6817a86e4", size = 3662894, upload-time = "2026-09-02T14:51:45.173Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/48/d8a8c4160a29e663109ad520bac2deb37fcd014756d024561e8bc3e611ec/lxml-6.1.3-cp315-cp315-win_amd64.whl", hash = "sha256:33cadd956b667997e4de1635fce9541f2e8ede2038fcde8cf55aa14d571d1bad", size = 4074626, upload-time = "2026-09-02T14:51:47.77Z" },
+ { url = "https://files.pythonhosted.org/packages/25/20/3e1395d34d19f9254625d0b567b81cf70d37d3417be074f4d63b94a2be3c/lxml-6.1.3-cp315-cp315-win_arm64.whl", hash = "sha256:8a330c0ee5fa318c7b5cbbaad882baeca3f570357e7eb25ab34bf31008150758", size = 3749495, upload-time = "2026-09-02T14:51:50.663Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/c6/7465ffd9c43883526a382df6fa4846c9d8d419214f7effbf65270e795471/lxml-6.1.3-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:0bf5a3e397df2ec4258eb5eea4c1ac6cf013ca1abd04a176903bff20a70021fe", size = 8857677, upload-time = "2026-09-02T14:51:05.109Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/eb/1f3a917e299df43c8162c3e6f64fc2cea3bcf277910f35bff5b8e5d39901/lxml-6.1.3-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:13d22c0d57355366b393936acf6b98a5e0edeadddd3fccbc6a846c50a76b8741", size = 4754522, upload-time = "2026-09-02T14:51:08.137Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/f9/f81b4bdb6efb7a596be29603d8758154d00a5f545db9f3cef9d9041c8f64/lxml-6.1.3-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cad7617727a96d189bd6f979d0fadf765198c7934e85f4edaba9bf3ad919a300", size = 5033744, upload-time = "2026-09-02T14:51:10.633Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/0f/26d9bfaacb319c86e0eca8a1a0bf1130d36a7afbd318883e23caea63763d/lxml-6.1.3-cp315-cp315t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cae82b5ca24b0c2beedb269f6e2a96f466acd926879ab00ae19f1a65cbf9ffb0", size = 5615269, upload-time = "2026-09-02T14:51:13.357Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/90/73675f3f4141350ed65d6fec533b107d4e802c5caa340cf111771edd86e0/lxml-6.1.3-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:69cafd61aea04ebb3502c93c2aaa568b12931ca0802231e0b5de76bf8b6e74bd", size = 5236280, upload-time = "2026-09-02T14:51:16.051Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/be/ed260767e7977de463a0f91f3f4fffcab85c0a2a024a21ffe1fa442c2c79/lxml-6.1.3-cp315-cp315t-manylinux_2_31_armv7l.whl", hash = "sha256:dc205732d593118cf701d986f40e9de7801bb2e371cb189ddbda9b7348f4d97e", size = 4650718, upload-time = "2026-09-02T14:51:19.102Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/fd/e9839d03b1e767f2725cf7d7d81b80d5f3f9fdc10ad8827e2479311b046e/lxml-6.1.3-cp315-cp315t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88e719b9437f148f7e1465df845c758dd1598618cbea3a2fd1e61a715542f2b2", size = 5243376, upload-time = "2026-09-02T14:51:21.606Z" },
+ { url = "https://files.pythonhosted.org/packages/34/a5/4606e347e2788c301f677004aa83e28d24da9fe663a24380122af57be6fc/lxml-6.1.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:40983eabefd13da003e68170928c7acc011f0d095eefce5871a3c71c9385fb9a", size = 5092340, upload-time = "2026-09-02T14:51:24.21Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/99/3314a8661cdf30f493c55a87db283961dfaae08451976a2ca418958e1804/lxml-6.1.3-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:fad67b12ffe0f71e02b4932b04883cbc76a9072bbd30731409d3523cf058b011", size = 4758768, upload-time = "2026-09-02T14:51:26.813Z" },
+ { url = "https://files.pythonhosted.org/packages/30/58/3bdc577f78ea8b7d72d39a84506f7001d5b28728f43e5b84891e3b7d9a4a/lxml-6.1.3-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6cd11e7550d89e551a87dcec30f04b1fca32e86b68708aa01a4daa455d8605e5", size = 5649546, upload-time = "2026-09-02T14:51:29.453Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/e4/652633de1a2395949ebb7a8fc7d089aba12a2b45f0fefbc9d29e3e3ab3cf/lxml-6.1.3-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ca0ec532ad2f5ba1e5ec120ac157769c57f01855b3d8bf37213f5d88abd9ba0a", size = 5234874, upload-time = "2026-09-02T14:51:32.262Z" },
+ { url = "https://files.pythonhosted.org/packages/65/a6/c4581d171de30449304b4859bbd3607e9b40da13c0f88b68e6097c8d785e/lxml-6.1.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:e99e09ab7741f1281e2677f4c0058c7f5267d182530b09c87e4f6aa26adf3887", size = 5260043, upload-time = "2026-09-02T14:51:34.841Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/d7/ed6ee6186a89e69ca4ea9658b2a278f46a5efe8b5d4db56c7197f18653fe/lxml-6.1.3-cp315-cp315t-win32.whl", hash = "sha256:ace1d2c83b2bd24db5940600541140e87a325e119cb32d5fa9ad720d7e76648e", size = 3901093, upload-time = "2026-09-02T14:51:37.234Z" },
+ { url = "https://files.pythonhosted.org/packages/67/9d/11d10257a4a048d04195d638bb61f0246ce2448eb05f682bcbab25a257a8/lxml-6.1.3-cp315-cp315t-win_amd64.whl", hash = "sha256:b49638355ea3bebba70da783ccbc630fd72afa16bc46c54474bfa1f9a915bbc6", size = 4395446, upload-time = "2026-09-02T14:51:39.884Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/b7/44edd7de434181c582892e68d1ffe6775ca403ce14aea07cb5a218a936cf/lxml-6.1.3-cp315-cp315t-win_arm64.whl", hash = "sha256:5a721a98c649855963811b59b55755b30566e7f7fc40bdc9803d66dee9f811cf", size = 3822836, upload-time = "2026-09-02T14:51:42.471Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/23/dc1fdf3a53f84ca88b6e942277ddb47954844a0ececea8cc5fa3c1324831/lxml-6.1.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4b061064b4a2fe8598a466d723d43dbcd5a610a5d5cfe02fb6226f5c17349f75", size = 3947704, upload-time = "2026-09-02T14:46:22.27Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/ed/e36d547d6c958b5693b873504735cb4d0388d545945d66a7aed8983a720b/lxml-6.1.3-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8499d464de86fab0f102313cce32a9bed9ab1f06ec813cf025cb790964fbb765", size = 4220149, upload-time = "2026-09-02T14:46:24.907Z" },
+ { url = "https://files.pythonhosted.org/packages/98/54/7f51e6b6cc0755f9b5fc6637748279e9f48289d917b3a47ac9fedf3318d3/lxml-6.1.3-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9e67324961ac9bbe616cce5100514d2e34d88665aeb07071e8b16eac55d06d94", size = 4329391, upload-time = "2026-09-02T14:46:27.111Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/9e/840b0d2e25c10c491b010d555b46e6e5264d3ad73a91557405fceb738c35/lxml-6.1.3-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d12669a2c419b0e8dc423d23dea24bb82f6f9cb829f32e04674b0ba40322a7c", size = 4262125, upload-time = "2026-09-02T14:46:29.199Z" },
+ { url = "https://files.pythonhosted.org/packages/69/8f/42a41571dfc772c12628747f883d24c978053856825b99d7a187117b8079/lxml-6.1.3-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:97acecb11cbc411473f15b8d780df06d7a9f3a2aad9aca78364f56640c8fb70e", size = 4410104, upload-time = "2026-09-02T14:46:32.102Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/aa/27d93812be916f1f674b2035edd86d41c77745ff2ad84f58c25a7445a397/lxml-6.1.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f8b9c8ceebae6387d0dc77f7f4dbbfbfc962dba2efbfe6877486075a480726b4", size = 3510724, upload-time = "2026-09-02T14:46:34.122Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/c1/2433176de263cc3f51fd2c303f993d5bb7f1da3139a0f7d168116c0bfa7a/lxml-6.1.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d2765c18ce303149ee804b1f3dad11232726dd0a702d73a15cf19179ac8cc962", size = 3942969, upload-time = "2026-09-02T14:46:36.55Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/71/de7759096f480180fd9e43ff7c017860e2d2a9a43741ab093cbdf1820f07/lxml-6.1.3-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d5a748d12dd9b535e0a130f60dae9ddf0adafbabe61e7864f55c7436c84547a", size = 4213008, upload-time = "2026-09-02T14:46:38.784Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/9b/c2d09af47a34fa6c0c27473083812b449a411680bd04bbe609cde291ddc8/lxml-6.1.3-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:41096ec0740a58dad03d3ae0c7486d306d20becefb13ceb1649835ab3eb64167", size = 4322012, upload-time = "2026-09-02T14:46:41.031Z" },
+ { url = "https://files.pythonhosted.org/packages/68/f3/bf56fee0403ebd995be8e78ec9aca566016487d1b3cbf755ebea8ccffbdb/lxml-6.1.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:415e3a115c0d510e329020012834d1c0aa1c581ee53a218603e38abbc1dea70a", size = 4257402, upload-time = "2026-09-02T14:46:43.134Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/1d/6da9cc086a20d9dd6bcbf7c5d9575f0331cca9a05e67dab02d15e828170b/lxml-6.1.3-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20428910dae17a1a93152a3ff2c0441d2f4932992c0797d65651dd0561f1792f", size = 4410889, upload-time = "2026-09-02T14:46:46.975Z" },
+ { url = "https://files.pythonhosted.org/packages/03/5c/91fe48856f9f8089be3096fa4dbe4b3fb5526f3bf3e852ea9497f399cb9f/lxml-6.1.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bc8dd3d9c93e70c3df974a201ac2958b6d77b465d813c51d1f15fa8e645763ae", size = 3511258, upload-time = "2026-09-02T14:46:49.046Z" },
+]
+
+[package.optional-dependencies]
+html-clean = [
+ { name = "lxml-html-clean" },
+]
+
+[[package]]
+name = "lxml-html-clean"
+version = "0.4.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "lxml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0a/63/195dfdde380a84df309e3bccf4384b034b745dba43426886f7ae623b4fba/lxml_html_clean-0.4.5.tar.gz", hash = "sha256:e2a4c7d5beedd17cd7b484d848a0571e54baa239a4f9df5546e3acba7f990560", size = 24142, upload-time = "2026-05-20T12:17:53.574Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6a/bd/6e2b76a6c5dee10397db9c929f0c5066766ec1036046f0335b7ca7ca08b8/lxml_html_clean-0.4.5-py3-none-any.whl", hash = "sha256:c76fcadd1e5bfb9b8bafc2200d51e4e78eb0dad67f56881c21dfb6484c7e7746", size = 14573, upload-time = "2026-05-20T12:17:52.215Z" },
+]
+
[[package]]
name = "mako"
version = "1.4.3"
@@ -1896,14 +2275,14 @@ version = "13.0.0"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
]
sdist = { url = "https://files.pythonhosted.org/packages/ce/a4/9cc30690a394a8305e8be4c9036aa16d0dfddadd09079860b582f562496d/pillow-13.0.0.tar.gz", hash = "sha256:cdcd1ba258178f7356d74170c9a81ba4eab6a5d55748bc402a5a2a6fe6be3510", size = 47058631, upload-time = "2026-10-16T22:18:09.718Z" }
@@ -2369,6 +2748,18 @@ crypto = [
{ name = "cryptography", version = "50.0.2", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine != 'x86_64' or sys_platform != 'darwin'" },
]
+[[package]]
+name = "pypdf"
+version = "6.21.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/28/081f1cbcca7042441dafc8de00f48ba60853f89e5bff92c5f26477346d81/pypdf-6.21.2.tar.gz", hash = "sha256:0a3e1c5c886a1be03646c16a04827cc166c2a0575c971b26a4bf89686551c2d4", size = 7144571, upload-time = "2026-10-21T16:44:55.272Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1b/4d/c9d2d67f204eff463237a1a8f5e25a6923b7b1043982b91fcaf104c8ef60/pypdf-6.21.2-py3-none-any.whl", hash = "sha256:1d44d1a3a200f25062adff0085b02040e4646431ac2ccac22e42679e91466084", size = 407766, upload-time = "2026-10-21T16:44:53.626Z" },
+]
+
[[package]]
name = "pytest"
version = "9.1.1"
@@ -2401,6 +2792,19 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
]
+[[package]]
+name = "python-dateutil"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "six" },
+ { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/df/f15f80383f152452d8985b36d95cb8751f901a3e0ff4cd27f7e118f168e2/python_dateutil-3.0.0.tar.gz", hash = "sha256:7ebcb3c29a92f3ceafe79a7a48a5c45677e9e004bbeec5742ac0bbb00560b7a2", size = 271066, upload-time = "2026-10-21T23:41:45.075Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5a/17/cebee01d1c0c1441174cf0456ddc91b280d79acb65340c05e41d77866ee8/python_dateutil-3.0.0-py2.py3-none-any.whl", hash = "sha256:3c79630202e4152c6add678446984236efe4f57e84d8e892aab0637bab82e9fd", size = 94659, upload-time = "2026-10-21T23:41:43.431Z" },
+]
+
[[package]]
name = "python-dotenv"
version = "1.2.4"
@@ -2433,6 +2837,15 @@ asyncio = [
{ name = "async-timeout", marker = "python_full_version < '3.11'" },
]
+[[package]]
+name = "pytz"
+version = "2026.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/14/21/d83d6ef28c4c912c4bb4d1dcf591f7b8c6bde87b9c66f9f454677314e16d/pytz-2026.5.tar.gz", hash = "sha256:fa23724b9c486543b9ff54a327ee7569ac83ade54bb9afd0fc18676620401c86", size = 318572, upload-time = "2026-10-04T02:37:58.719Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/4f/ef/c66110d46fb800dda0bf33164182dfadabe26a90e4476844d502a23dca8e/pytz-2026.5-py2.py3-none-any.whl", hash = "sha256:e658af3757f9e26a9d25dd2aff38335acd92bc9104f890a894b2c1ba28311b03", size = 506342, upload-time = "2026-10-04T02:37:56.814Z" },
+]
+
[[package]]
name = "pywebpush"
version = "2.3.0"
@@ -2550,6 +2963,143 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
]
+[[package]]
+name = "regex"
+version = "2026.9.29"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/f2/af1da9d3ceed77bfcdce40427d49ba0be94e4fe84245e3bfef68c10e75b6/regex-2026.9.29.tar.gz", hash = "sha256:8b5fcc4771732191b2b7d1dd68d8f0353f47f8d90b6150f6dce58bf1112442cb", size = 419199, upload-time = "2026-09-29T00:49:58.298Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f6/37/404442e7296554792e2de4c0c8f8b95ee491a3c227d6ff90d4cebf2dbde3/regex-2026.9.29-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9916fda742cd4eede63b286f58c06718324265d727ce0856eb1aac86d0d150d6", size = 495402, upload-time = "2026-09-29T00:45:50.322Z" },
+ { url = "https://files.pythonhosted.org/packages/72/6d/116db2946888bd60db8e2033739471be6d80aa47c833afd952c9ed40654c/regex-2026.9.29-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8873c4a11c50b9989168881aeb3f08859f469d809941866aa1feefd8be5431f6", size = 295139, upload-time = "2026-09-29T00:45:51.826Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/1d/aefd12fb5cd62b748aa6ed28725b375c71102853fcbf15fb6481f806a2ba/regex-2026.9.29-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1d9fe8091b2e89d470df68a9331111ed008ae8aae6bf1e8e1fba4086a495c84e", size = 292130, upload-time = "2026-09-29T00:45:53.017Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/98/41fe60ae6ccf3e166fe7bc73495aa15e9a1a7fe3a1f9f0f95a3d64a2df0f/regex-2026.9.29-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb00027a09a8f9f08028b40dce4c933cf73e4833240ed356583fdc9cfa721566", size = 793080, upload-time = "2026-09-29T00:45:54.331Z" },
+ { url = "https://files.pythonhosted.org/packages/45/0d/944b13e8286ecba61a3baeca28b375550821a279800bdb18fac41ade6637/regex-2026.9.29-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:14e953ff3607c92d7675bf79c4d4509ef6782aa8c08509f179f9b3d6d0679e86", size = 865241, upload-time = "2026-09-29T00:45:56.065Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/b4/e1c32fdee0462f1373c52a73325cafbde653fac0b0cc1e9badac74154f4a/regex-2026.9.29-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0476e5bcbe6e1ba3d1c4cc7bbb1c3ba78e3b979b5c8a88d0a6a8cdd4992b8c84", size = 905496, upload-time = "2026-09-29T00:45:57.491Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/99/eae371ca63f7ea1f1eac025021527adb57ce3a4b67ff608b896fd31ea447/regex-2026.9.29-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4fb41211d2333eb930a51e0546a65999761cf1f572a4da56ef9b8a62966c06f2", size = 797643, upload-time = "2026-09-29T00:45:58.746Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/26/9e4f158459e37e41633c96f49766a465f801c5daba9507260609ed76d783/regex-2026.9.29-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:edf06545875f3efa31560d94121e95c7fd70d98b1dfedc0157097d79b13b52ea", size = 797591, upload-time = "2026-09-29T00:46:00.2Z" },
+ { url = "https://files.pythonhosted.org/packages/86/60/5e1c5c6e85132e757ae77bd7693f1809046edb2c8853658c9200f4c8593c/regex-2026.9.29-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6398d5145689503412cc1748895242598d8846b8967b851133b20dc2ed1e21e8", size = 774874, upload-time = "2026-09-29T00:46:01.491Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/13/301b394f32a8db86ae3280533c9186229595fed766376f18e87959f92f96/regex-2026.9.29-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:45010bcfe66df41522d56c9b6114e87ecc597a08970ff6a2ced24415c141ae5f", size = 780168, upload-time = "2026-09-29T00:46:02.817Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/27/0c647127db32760b2dfc4c38da9ca509a3c4a8d3d93a586121a10fef2701/regex-2026.9.29-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5758353650079898dc1b2b0e95aa51fa23a30d020e06f62c430dd08ee56cdd8", size = 856604, upload-time = "2026-09-29T00:46:04.152Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/18/cac15fb2829c33218ececf76333b66869a96e4f973480ec32494921750f0/regex-2026.9.29-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:6f7121a8914ed13fcfe2099f895341bfb789f004d4c5a0bdece8fa667da10849", size = 760602, upload-time = "2026-09-29T00:46:05.794Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/55/967676e4089a25d5f54b9d62522f9fe09b87677d1db58f207888d4ccfbe3/regex-2026.9.29-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:b9d74e4eee9ddb64c2e92d5d61472c59c21684c059eb7b68767be9628e977859", size = 846830, upload-time = "2026-09-29T00:46:07.258Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/8d/bb4165d61860ed443da5fb0fafe629c1ee9202526394eead7925bdee2be4/regex-2026.9.29-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:143533cc4b6fbc5b95aca0a5b8d541088d374831593def000ec89322c220221d", size = 785445, upload-time = "2026-09-29T00:46:08.89Z" },
+ { url = "https://files.pythonhosted.org/packages/86/a6/a5cfc2560e063f8e6871373d3b719f573d7e7fcaa09db43e7c8aaeb51bd5/regex-2026.9.29-cp310-cp310-win32.whl", hash = "sha256:b84f186a7f0536fe4ff9a9fa12d06d007b9b71d4b5352ddcc41f59ad6522a312", size = 268950, upload-time = "2026-09-29T00:46:10.331Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/f6/b127312ebc8092357f435c9e4594fd8cf50abb85f8b4b16ab8d262abab2a/regex-2026.9.29-cp310-cp310-win_amd64.whl", hash = "sha256:23ae6fdad9e63e54038f5ef78aba2933faca61e24d432786589e737bc5522ebb", size = 280629, upload-time = "2026-09-29T00:46:11.638Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/e4/ab36f3c26f2374d16d525dd5a7fb4997f3c6e6bb7c6722821b84f9ea35b1/regex-2026.9.29-cp310-cp310-win_arm64.whl", hash = "sha256:c0094897d7d01f184b2d7fe8c56c66d64efe01b31f4b7d34205b391387df1111", size = 279407, upload-time = "2026-09-29T00:46:13.248Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/6b/6dea87689c3a06a6e79d254bf824e6f3e3d724b5ba027c6112559aa6cd2c/regex-2026.9.29-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6abb75ab16bc3281714a5b99548a2225db70dba1f995f6d7f7419b76eb5a8fbe", size = 495413, upload-time = "2026-09-29T00:46:14.51Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/a5/0c791a0e83ad1013d262c13247c4c77e0f4a8d05bdc167df96aba6681c0d/regex-2026.9.29-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b7b893976e7fe42053da64f2aa27239c24252fd2ec6df471e1be197c0addc3b1", size = 295145, upload-time = "2026-09-29T00:46:16.292Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/07/9bf3607d8d13a12e436ab9d63f9791e10706827d535695b23964ad79fd79/regex-2026.9.29-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:066d0e3dbfdd739bce2bf8c2a41dd16f73e3d8adc2eb06dd803a36a307f56075", size = 292123, upload-time = "2026-09-29T00:46:17.646Z" },
+ { url = "https://files.pythonhosted.org/packages/64/6b/32c2e6fc617e1d3f247e250fea31a9a35b1265bd32f585968aa13b9999b9/regex-2026.9.29-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7020ed44df30b3aa492c00ee3b52d0548c1f30c2c6c5bb13ae897680900d3413", size = 799537, upload-time = "2026-09-29T00:46:18.976Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/72/f041177f3c7a4606f7c81a95fe7eea03e2a0c4e8bff9e439a01432cbc9f2/regex-2026.9.29-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4613d7d9dda60fcba95f846cc6f808017f1843f392cf9daad14a6534493d71", size = 873255, upload-time = "2026-09-29T00:46:20.684Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/4e/a78948e11dd715e0e46716c2e0f3404b3fe6a44e2a2e9abdc7d965cab2b3/regex-2026.9.29-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bec37990e3d6121f29ecfb594bd8f1bf009e9f7926daba2e50e3b27d3892a783", size = 914570, upload-time = "2026-09-29T00:46:22.599Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/70/aa08d1d2b294894b365e5f8ba5380fe3f8546acdb81f10639dfd74209c37/regex-2026.9.29-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:612b709381c0355b70d89cdb51b7f670591ed5cbbc0e3b5337488019dc667b65", size = 804978, upload-time = "2026-09-29T00:46:23.981Z" },
+ { url = "https://files.pythonhosted.org/packages/21/32/1b03534c4715aca3b564416d28d518083ed4dab3bc913267600d2256140d/regex-2026.9.29-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a760da040b47767b4b873adfb7c3b691e9ba2fc60f113f9d0b88f1a62f323e85", size = 779297, upload-time = "2026-09-29T00:46:25.318Z" },
+ { url = "https://files.pythonhosted.org/packages/76/a7/378f6f558d9e4444af315a307c5953565a511d1e3666f1bb7bdc82012b6b/regex-2026.9.29-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:49ee178ca31c94621294bf9b8b676a92a2e6bba8af0529591753719e57edb621", size = 786961, upload-time = "2026-09-29T00:46:26.963Z" },
+ { url = "https://files.pythonhosted.org/packages/59/13/79f0b1846f5f342f92ddbd4b27b18bcb86da96d902c1a0be26520bde98d7/regex-2026.9.29-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:5eeb8edc6110d9194a4d0d54610f64c37a31c605b5dbb7e407fc6ec7fa34a4a1", size = 863234, upload-time = "2026-09-29T00:46:28.58Z" },
+ { url = "https://files.pythonhosted.org/packages/97/19/05af70dec9f2eed6ba34e08d2dcc6a48e7ae5e307659d5fe4201a5d7bbee/regex-2026.9.29-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ccb64d887a9db1cd76dbc0f92051a1a478a2a67e7f56c62d915cb881d7734704", size = 766487, upload-time = "2026-09-29T00:46:29.941Z" },
+ { url = "https://files.pythonhosted.org/packages/01/e1/9c7486d4afe8fdd1fe0ad60139f8aa91427381f409af6a29b609d8fdcb3a/regex-2026.9.29-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9e4482589065c8ecd761cff522dcd85f2d39e62f551e37e025d1c7d54772def3", size = 854792, upload-time = "2026-09-29T00:46:31.358Z" },
+ { url = "https://files.pythonhosted.org/packages/26/c7/49d008ff5f741d9a9799d7315556f3a12b983ff0fcd2cdfb62904bedafbf/regex-2026.9.29-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d60030baaa7bfbb02d650c126cdcddcb6e33dbff14d819434c8fa2fdcaeeeba5", size = 793050, upload-time = "2026-09-29T00:46:32.775Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/a1/46ba549e65562ca04608b24179b8a7bb6f146ae0e7c6d7f5e70f3339c8ba/regex-2026.9.29-cp311-cp311-win32.whl", hash = "sha256:18ae8eed4526e35bdb754d61562b90bf5c00a67fdcf3cc1380dd59597486631b", size = 268940, upload-time = "2026-09-29T00:46:34.179Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/4a/aab232183c70fdcf77bcf0c51819da02ec522e393e6a0bf00bcf2142e21f/regex-2026.9.29-cp311-cp311-win_amd64.whl", hash = "sha256:1043aedf5917caa861bcb25a9c11460049656bdf0017a90a309fa8f255467725", size = 280641, upload-time = "2026-09-29T00:46:35.484Z" },
+ { url = "https://files.pythonhosted.org/packages/33/b1/7c05954af0f51de376df2ba97f7f78a8b79334c7e5b3d2d9f2aead1f4d3d/regex-2026.9.29-cp311-cp311-win_arm64.whl", hash = "sha256:352cf115a810b357caa35193ab656ecf5ef41056855e82f292c99e8514f8d954", size = 279411, upload-time = "2026-09-29T00:46:37.193Z" },
+ { url = "https://files.pythonhosted.org/packages/84/48/3fdcde9a0baa84d7d25571223265d6e434e114763b438601d54a8028bf3e/regex-2026.9.29-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:dc79d36d0618752265f0d575915bdc5c5130ecb9c9f6b3bcefeae32e4bdfafcf", size = 497903, upload-time = "2026-09-29T00:46:38.938Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/1c/4ee3e97c76f53940488dfe7a7e18705e78daac8cd7fb161d246b9e328449/regex-2026.9.29-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3a21a9509d0ee88e7a70e1ad228cd2f0e0fd1e187458db132e8a8d18c97daf9d", size = 296416, upload-time = "2026-09-29T00:46:40.406Z" },
+ { url = "https://files.pythonhosted.org/packages/37/14/f3f0ba083d2094392d5eabf56db5ea6ba469fd6e927afd187042054ea68a/regex-2026.9.29-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f57dc6b8fef170f105d2cf5cdce254f47b137d7755086cf7050f47e16582abba", size = 293633, upload-time = "2026-09-29T00:46:41.959Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/72/67e7a8ce17f1aea49df215564048efb49cc8c2b31a0e0fc30f36838f8516/regex-2026.9.29-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f93bc1c3486ef3747e07c9d7c1d0a147b8fbaab975f80e348aed6f71309dfaca", size = 805885, upload-time = "2026-09-29T00:46:43.373Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/78/25436bcfd4d2260b4b4090094d55d7ab53ec8a1ab4865a0b8bcb33c7d5c0/regex-2026.9.29-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e1d3a4cb7993b708f0ada8d0c84590efd853f169e7147d2202c9da503180242", size = 878344, upload-time = "2026-09-29T00:46:45.328Z" },
+ { url = "https://files.pythonhosted.org/packages/97/e6/a09ec3a23ae41d6179880e67f0aace9284b2d95f2d7b326eff203f8eec5e/regex-2026.9.29-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dabee8f4935e731fb46b2a3091bdda0d3d94b3bbfb907d2b4f12eefce4009619", size = 919181, upload-time = "2026-09-29T00:46:47.041Z" },
+ { url = "https://files.pythonhosted.org/packages/26/83/d2fbd2e4e3afb1167daa825187d196f313cbaa1a4768f311fb041bb0e3d2/regex-2026.9.29-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:39ab5894d971f9ac68baa6eca5c50387db579cfcacf36ae8df3feceb1815e6d0", size = 807783, upload-time = "2026-09-29T00:46:48.894Z" },
+ { url = "https://files.pythonhosted.org/packages/46/0b/eb429a7016610d44fc89a597163f8c9127505f0d7dc724dc9effbb6a3ac0/regex-2026.9.29-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c1a9a6651197fbed6f0212591418b9def774fc3f8324f78d1bf0e6a63e5f8aa1", size = 783465, upload-time = "2026-09-29T00:46:50.64Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/07/58a3c0153c7476898430f6a7cf3d9062a1d17fbea4f43399ecaf411c7b4c/regex-2026.9.29-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:87fb80cbe3557e27e7b28b995c2b2eedf689b8886f941ab93e0e288f0976518a", size = 793519, upload-time = "2026-09-29T00:46:52.396Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/e8/161b94d39164520e21a7befe0245569bf7fda4c7cf1fc4e2df2b5def49da/regex-2026.9.29-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3c5c2ef13797466aa64170cbb66ad98a32351dd4127694cea7199f80f213750d", size = 869293, upload-time = "2026-09-29T00:46:54.128Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/07/3b02ed829aa2decdc1955d222bd1e2f99d1c8bb4873bbb9a66b2f0a36bff/regex-2026.9.29-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:59b49507f47479e299a9e1bc41b5cb83a7afda0540625f1dbae886615978acbf", size = 770239, upload-time = "2026-09-29T00:46:56.106Z" },
+ { url = "https://files.pythonhosted.org/packages/42/5b/ba61f6fe062eb8562e742367d177bb75370434138ef6c9d2a27114f8d613/regex-2026.9.29-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0dd8af32e9f7b56b7f95cc1fd79b23054c3bdc172392ae560acc24d57b7ffe71", size = 861973, upload-time = "2026-09-29T00:46:57.665Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/27/767259b20e8a842948990f5e99138d6c077248fd42f8b5468b1d9ca4b814/regex-2026.9.29-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db5e82ba15c142425b8406690032df89e39cca4a2e8afbbb9a3d84edc2373ac3", size = 796470, upload-time = "2026-09-29T00:46:59.236Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/05/2566c4ba849b68a8ab81a6bf428fa79d20aae7ddee83979103c0381df254/regex-2026.9.29-cp312-cp312-win32.whl", hash = "sha256:d0c3082bf79bcd6a614d55916590ad4b8f93200e10b97f463ea5d9d07c9b5f23", size = 269327, upload-time = "2026-09-29T00:47:01.135Z" },
+ { url = "https://files.pythonhosted.org/packages/93/19/489bc8db91196381c935752df01ba3f607140daece33b78d88573f028e64/regex-2026.9.29-cp312-cp312-win_amd64.whl", hash = "sha256:fdd88ed5e20b1bcdd234421e454962c971aa44b653bdb7f1ea9ef683e90fb649", size = 280334, upload-time = "2026-09-29T00:47:04.436Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/47/fb88ba779d0e5e7d4b0ec1aceeb13845948a2cb876bd572a2d1dfdba090b/regex-2026.9.29-cp312-cp312-win_arm64.whl", hash = "sha256:4fe97894d1b306c919b4e50def1e6f6c522f4d03a7283811f4d108f1ce5d3ac2", size = 279614, upload-time = "2026-09-29T00:47:06.541Z" },
+ { url = "https://files.pythonhosted.org/packages/79/d5/6080f7d1a6e7e36aa720f806ac93c035ba39c209ae6cc510e8ef4c0279c6/regex-2026.9.29-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f1a0d5117230dd46b399a30a38afa44f79c99f3168988fdc4f425c3f928b39df", size = 497622, upload-time = "2026-09-29T00:47:08.251Z" },
+ { url = "https://files.pythonhosted.org/packages/00/71/c87fc7a2e21a42f9d57489db32951c37eef56d153840459a80d464f0321d/regex-2026.9.29-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f0fe9834e5aeccaf19a0d8feb296d66a24be1a7c9922002f842a682cd5abb787", size = 296281, upload-time = "2026-09-29T00:47:09.764Z" },
+ { url = "https://files.pythonhosted.org/packages/11/9e/aa0f4cde3bc4688c1d58b0cd8415edd708339bc0bc401a195b0b1e8c8f0c/regex-2026.9.29-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c90fcf7804ea0a54b896ce0f2b9565350220b8d4890fd0db461a476a4c687963", size = 293472, upload-time = "2026-09-29T00:47:11.723Z" },
+ { url = "https://files.pythonhosted.org/packages/90/d4/e835c487850ed922a8d6074f953b888c8ea99775c76b9ed5f8a4d72eab92/regex-2026.9.29-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e11edba5bc344a32b029a7af9d4b3173982dd79eeafa0b9dbd787364414b0509", size = 805966, upload-time = "2026-09-29T00:47:13.235Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/57/ba8809847fbae8d2cbc71367c6ded510a7ec88bf52493c65efc1acf4effb/regex-2026.9.29-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bb90e7177944b6684738c1fc36aabd2dd00d1de3be7dbe09f91e196f1bc0dc81", size = 878346, upload-time = "2026-09-29T00:47:14.877Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/52/e3da19fc3cc15ef67ab67e121e87887c3bccfdb683a7a9ec557c460ca5b7/regex-2026.9.29-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d06fcdecc10fc7954d7c8f27a03c96055fe525274dc84a7b0dbdc3d6b9e03dab", size = 919250, upload-time = "2026-09-29T00:47:16.622Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/8e/c1ed81f55f992f6aa0b699a592a50c1ce9e6d44ff1aee2c14c0537dcef9c/regex-2026.9.29-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d49c18f1ea294cf4adde2e5ac256e98c82ea9d708462ce4bf799dffa7cfe8a2c", size = 807902, upload-time = "2026-09-29T00:47:18.268Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/bc/5a6886eb470e41040e21e05b75024a18b6ebfe7ea400b72094a60f949101/regex-2026.9.29-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3e778bfccd63075167709136afbc251c1f683758d5bf49c803c60ac3f894ce6b", size = 783514, upload-time = "2026-09-29T00:47:19.921Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/52/6d951d453b023c6edb880f1ba474291b53b8ce1cc438b96a9db6d791d991/regex-2026.9.29-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:686ac5350fceae63830bb98805fcb8039325bf4c06d9f6f048ff65229d5bffa5", size = 793466, upload-time = "2026-09-29T00:47:21.552Z" },
+ { url = "https://files.pythonhosted.org/packages/99/b9/d5a41adc08360f5eee0dc4846c578f002366947211fc8af5a69a64ee7b9f/regex-2026.9.29-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:26ec4ccce55aa533fbd603d08911b01101a8fcfec987845ac3ae2c7087b2bde3", size = 869464, upload-time = "2026-09-29T00:47:23.276Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/32/d76c9d91f5d798e2e9e67f6f85ec4ae35445ac425f7454797311cecb80ca/regex-2026.9.29-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a655d34b2a6943af32401f3d94f72e9d731f6ad16285815550bf2b4ee69d420a", size = 770278, upload-time = "2026-09-29T00:47:25.193Z" },
+ { url = "https://files.pythonhosted.org/packages/24/00/aeebdb540c620a0f7317f6d6fad80a47729ecf0599a24b5c34ec155351f5/regex-2026.9.29-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:0c992c19cd45058a4b92f68f139c93db168b48fb1f322c9a7cd620806afb6b51", size = 861949, upload-time = "2026-09-29T00:47:27.005Z" },
+ { url = "https://files.pythonhosted.org/packages/12/62/d0314bcedfd3586197e4596931fa220260eb2385bf53184e5b9ae67db24b/regex-2026.9.29-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ebb8912f565b8cdbbf27debfe00df04202c20e2f651b9e32767930c5eace3621", size = 796602, upload-time = "2026-09-29T00:47:29.233Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/c7/d5a8c13a613facb03e0fb55c1ebaaf7bb35d8e2c1abe8bef8dca809fc1d9/regex-2026.9.29-cp313-cp313-win32.whl", hash = "sha256:4d7d93613b01b0199961330e49cfc52d479b3d5776c56c691db31130c0a07d91", size = 269306, upload-time = "2026-09-29T00:47:31.14Z" },
+ { url = "https://files.pythonhosted.org/packages/80/a7/bf93a3a6afa5f7bc16b7afb94ae581b01cae620b8ad56bd8f9572a985959/regex-2026.9.29-cp313-cp313-win_amd64.whl", hash = "sha256:61956f074ecd123f55adca68ee3eab46e6a07ad3f8e64e6db95dfacb444f55c4", size = 280307, upload-time = "2026-09-29T00:47:32.709Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/7d/388274e53605a86297f433a08102a7bbdcf9379d47683d307ccaefd88e2c/regex-2026.9.29-cp313-cp313-win_arm64.whl", hash = "sha256:bfc71e6d970419c1309b3640305298643e2a734cad3f7cfb6d2ddee4175ab53d", size = 279599, upload-time = "2026-09-29T00:47:34.674Z" },
+ { url = "https://files.pythonhosted.org/packages/93/1f/d9dc6f02f569625faf67a4daec926cd5023472dcd69bb44286dccd5a5ab3/regex-2026.9.29-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:957bb708e8057ab1649ba566456429d691ec9b90d1c9ad1af1ba7ffbbeaf05f2", size = 497598, upload-time = "2026-09-29T00:47:36.541Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/83/9b693a3fd1451381e812031a8961ec5b3b8f0c8cc6871f14c5223642804d/regex-2026.9.29-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c9b602fae1e00b7c035d661ce85575365719192a7b46784bd71cf64c68053aa0", size = 296250, upload-time = "2026-09-29T00:47:38.233Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/5f/52bc2abc3fef040cd9de76ab29c918d6a717a454ae2b9dd7938b0c95656d/regex-2026.9.29-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0166844493626c5015c6088ee15c9ca2fd060ca15b7641d1657da6a58432ae33", size = 293518, upload-time = "2026-09-29T00:47:39.957Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/fc/cf50671215ee0057046980b4571ef8646a005819bb67f0957e779ed107a5/regex-2026.9.29-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b97a38fb4c732b6832db6bf108963adbcd82ef1268ba2025dce390f45af75efa", size = 806037, upload-time = "2026-09-29T00:47:41.676Z" },
+ { url = "https://files.pythonhosted.org/packages/14/4b/dddef8fc15c63e4347cc9efb138d0cd306f30e6c98acbcc81a8f780083b9/regex-2026.9.29-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a540abfab208e1b7ef2df231c40ef3b6cbb30a0aad6204e9b6a81c10a6794628", size = 878881, upload-time = "2026-09-29T00:47:43.755Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/cb/38daabed32d28f7e58a06e9344ce00dc67952e9996bc578ed6a29fe1240e/regex-2026.9.29-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ddfa987262763c3c22a8367d2a49c244b018a74c3a8e3ab1a864119ad45c5633", size = 918684, upload-time = "2026-09-29T00:47:45.594Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/4d/041d9458a645fee4fce4d642a89d27271a3cfcd91095104f6dde44da70bf/regex-2026.9.29-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f7f7aa47b229f2b39a2ae2596d2ad5625d77b5eb9856fac2dab3eb506cdd0a0", size = 807176, upload-time = "2026-09-29T00:47:47.372Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/c4/4383eed7aa5aef67616cb1b3f3ad06b7c624c4e6cced48630cd5ce133d85/regex-2026.9.29-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d9b77b25b4f395f92de6099ab08e8ae2bc7e51dfe157f22900902243a5cc90c7", size = 784315, upload-time = "2026-09-29T00:47:49.518Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/a6/0086ad31cebb183c637d3198547075aa493afde308e1ff61fccccb29ba6e/regex-2026.9.29-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:34b6925af9853bf461950e6508910f179fd6e9b1a7ec8548e069606b7e51a26b", size = 793748, upload-time = "2026-09-29T00:47:51.279Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/a0/f9005cba3f629a859573fc5d1224ea4e1f97919ec8581d018e03a351a604/regex-2026.9.29-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:addd736a0547d553283adaf4e05d7104e7f2c7b0b092e9b4d28756825f14531f", size = 870302, upload-time = "2026-09-29T00:47:53.368Z" },
+ { url = "https://files.pythonhosted.org/packages/01/4f/e1a3e46bb5315a4e18b01a990e7a28e2a16595609d50c442baf2815a3c65/regex-2026.9.29-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fe3fa1dd453ed5c7f5ea23a26218329790ed7197a99b90e94330e313959a7f52", size = 770299, upload-time = "2026-09-29T00:47:55.606Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/fe/f303b4acfda44e1ff1379368748c1ef2dad04a6a8e9c0ecbc970b19d97ca/regex-2026.9.29-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0cc63b5e47c12a48d90c7e9d7de6a035dd14f62868aaedbb4e0ff8ba2b8bfe7b", size = 861570, upload-time = "2026-09-29T00:47:57.617Z" },
+ { url = "https://files.pythonhosted.org/packages/60/b6/b4f7e99249f596017c60ccad5faf9310fc8e3e59bb2244940a90a1b0bdff/regex-2026.9.29-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:724184b4aafed865e4f13ca313fdcb43024300c028ec67319cfa16847d84685e", size = 795967, upload-time = "2026-09-29T00:47:59.922Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/d3/fc865a4638d9f6762192b6bab5b7aa1f33a90e9e99578c2e111e2a63c8c3/regex-2026.9.29-cp314-cp314-win32.whl", hash = "sha256:c6c8fabf1dafc1f1ddcbb67896d3f93efb092e8c4b6322d7389b944e76a484e5", size = 274758, upload-time = "2026-09-29T00:48:01.8Z" },
+ { url = "https://files.pythonhosted.org/packages/31/e2/c2b466924ccbeb874862968ca638051b15a8fd29d994a0e99004a5cbf78e/regex-2026.9.29-cp314-cp314-win_amd64.whl", hash = "sha256:1c2a0026062abcc321a53db4a185ceba0b59a66b5d37b0808917a88b55a5257f", size = 283817, upload-time = "2026-09-29T00:48:03.614Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/42/ea0f8dbaa924fa75c6338935eaee2f44dab369b27f02db1e03d74344b049/regex-2026.9.29-cp314-cp314-win_arm64.whl", hash = "sha256:121a76a0985db80ceae9e171c337f8c927868e37d01b54e3ce87bc87f9c6a208", size = 283663, upload-time = "2026-09-29T00:48:05.624Z" },
+ { url = "https://files.pythonhosted.org/packages/44/48/d58e5081119f5c223bbb37d2340acde3d069e1df8e8cd166c37502eee4da/regex-2026.9.29-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e31f72490b7c12f7790e1e25c3afffd20503ee1bfb43461d7838b871ff244b19", size = 501393, upload-time = "2026-09-29T00:48:07.833Z" },
+ { url = "https://files.pythonhosted.org/packages/72/3c/c49945287d4f9efee7d41f98072f8ad880efb8f430595a612fbdea996a4e/regex-2026.9.29-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:80ea96f5c1a30bf09007d48466521d9c294bebe197c708c3359096e3e3691632", size = 298237, upload-time = "2026-09-29T00:48:09.684Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/1f/688cb61c3d4cf7bcc1ed444b5cc49399eba3e51c469ae285cf87fea3022e/regex-2026.9.29-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:554bffadcbcb6d5f4e5fb10a61cc52084b9a63d1dab5f10bcd2c4343972e8e2c", size = 295936, upload-time = "2026-09-29T00:48:11.454Z" },
+ { url = "https://files.pythonhosted.org/packages/26/a3/de43ac6b877b7d09c19a3a426b1bd5acdd209eaaf68f406466f80439ccf6/regex-2026.9.29-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:864e9b87ac33c3fb9fb4ad48166d4fdb579c351d5c77deb0d34bccb36a775cd9", size = 816905, upload-time = "2026-09-29T00:48:13.321Z" },
+ { url = "https://files.pythonhosted.org/packages/62/14/9940763201c51d537786304984c67d0fc3d2ed18837ffb6f09a869f6b6c9/regex-2026.9.29-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:044265d77d94f5e3cb2fd72c76723807c429cb8c533e9d4672d0334a6f14f588", size = 881527, upload-time = "2026-09-29T00:48:15.313Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/e1/c842d8df0b23245ebf202f8ab9c39fd48e2db39959454ec39a41c8c72082/regex-2026.9.29-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2089fe39c406784d90101c726755ffa1497bb74638fd434300d2b88006186de8", size = 923115, upload-time = "2026-09-29T00:48:17.328Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/c1/98622479e3c354a446a75232e522d747d2b3df23092dcd8a5309380a2020/regex-2026.9.29-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0def9fb6abac55492d6d51cddb7225d07d6f279e774e0adc08569a54a5fc8d46", size = 820674, upload-time = "2026-09-29T00:48:19.32Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/d0/5808c95f9c79ed27b5eedaafc3df6239ec56a49f2e23ea8f831b18427c82/regex-2026.9.29-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:888d60953908dcf761aa320c3e390ab8556efbdb551ace63921de90f6ae0848d", size = 793306, upload-time = "2026-09-29T00:48:21.615Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/d3/021ca2638671ad20603bcd9b4d5bfa35d2610cd216a043ea7f0b44ea39f6/regex-2026.9.29-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed511a0708e2297e1d6431e7fb217e3402791e491e02da800658ace4973df1bb", size = 803103, upload-time = "2026-09-29T00:48:23.871Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/2d/755c6d13ef9c657378013676c391c7a402166b3f419a464a3e058dcbe533/regex-2026.9.29-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e1172147d28d8fbcf8cb8d26c41506169f5ad8fe9ec969cb116835a19d4d8eca", size = 872175, upload-time = "2026-09-29T00:48:26.255Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/fc/e1cab183b9dafe8597f58c1c766da9bf96204d3b2f232bcf3eeb75ff7b6c/regex-2026.9.29-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:92f05c9c42bde5785dc48770bc2194d9f7442544156f951e19cd31b096cec562", size = 777362, upload-time = "2026-09-29T00:48:28.389Z" },
+ { url = "https://files.pythonhosted.org/packages/06/7c/e10ea17fba31fb4a1f9d13ed53a2d2a9066a2aea58d7557e263f6d99e7b0/regex-2026.9.29-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f37964e4a5e993d2fd45147741e9dff7f34a2d8c00ab94c4ea0514a4677f959e", size = 865606, upload-time = "2026-09-29T00:48:30.4Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/6e/69824d9aee1fd41c54ea7264654a47c8d9d84d8a228e11c2bcf4c201ed81/regex-2026.9.29-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:951733b1bbdb71e377cec567b409f1a7881b47cfcad84121aa74cb575fa425ea", size = 807945, upload-time = "2026-09-29T00:48:32.375Z" },
+ { url = "https://files.pythonhosted.org/packages/89/22/857050a86e21ce60193e02a8ef662521f2e263a645c8b1b905fc136b61a7/regex-2026.9.29-cp314-cp314t-win32.whl", hash = "sha256:65b408d8fcb273e3499e7ef2ce796810da1becd208c7fb4373692a242d79d461", size = 276758, upload-time = "2026-09-29T00:48:34.72Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/96/56808fe029553d7d4c703414f2a527faad2ea2bfa9ca094a2e7f8762b530/regex-2026.9.29-cp314-cp314t-win_amd64.whl", hash = "sha256:bf48516e35cf848390ea68850aba53e7c333720d2945b4d2c25b69fc5171723f", size = 286527, upload-time = "2026-09-29T00:48:36.864Z" },
+ { url = "https://files.pythonhosted.org/packages/01/aa/074e2cfb3d8101a6a764aba5f7c5d1e21de087483e35bdc0c4ce2eb60364/regex-2026.9.29-cp314-cp314t-win_arm64.whl", hash = "sha256:9173db3be74a35cb6731701094b98120f7ee4876a287882a59cdea1fa7da342f", size = 285954, upload-time = "2026-09-29T00:48:38.901Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/dc/d84990386c9dfdf8c377f00f371b241fdc9a2c8aea0e3d66941b2e51be0b/regex-2026.9.29-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:c3589f40749acce747510bf5d589d54e376cb0930ea58b35effac97e5312b0c1", size = 497836, upload-time = "2026-09-29T00:48:40.858Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/ab/a569ebde875fa12ff8c6c9a30e07503620f195e4be4d54c3d3ee8eecc283/regex-2026.9.29-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:32ab11df9677ca80bcbb5fe4eb1da9109a5019239a054836efc6fa1c64e683cf", size = 296244, upload-time = "2026-09-29T00:48:42.952Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/3e/7d548e82a108e7c8b2d5246650e397a2f8db599f9b2e975466939c5b4e70/regex-2026.9.29-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:7c03031610e3e6ed1768a2b7a8fc84637c1257b50c5eacaf094c6e17a84fc563", size = 293748, upload-time = "2026-09-29T00:48:44.985Z" },
+ { url = "https://files.pythonhosted.org/packages/40/34/a8e19a52f452bbb07b32a2bef70dcdf90c2737049749f74cc12d7486fb4f/regex-2026.9.29-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:42e82e578c904445d4c8a35b8f28052cf567593215fa5db06266fbc6f77aaa2e", size = 807840, upload-time = "2026-09-29T00:48:46.948Z" },
+ { url = "https://files.pythonhosted.org/packages/88/7b/11fbd4640b3bb82b72822a63c20ade4013d562d291703a9debeedc24e682/regex-2026.9.29-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0b65c72739f981377c9c22e0c5c3cd7f42da7bd8a3c9209330fac772c7d893ed", size = 879330, upload-time = "2026-09-29T00:48:49.168Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/55/de58c74f1f4e31586d83eb39c56872d686c4e0d0966d151884c833b94ced/regex-2026.9.29-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4408b2b27a95ca8cc48b7411945753773353b5c93b307754781086c99d3a576f", size = 919251, upload-time = "2026-09-29T00:48:51.322Z" },
+ { url = "https://files.pythonhosted.org/packages/81/42/a8c480f6dd5ac59fa28ddae79afd9d7ac7e596fdb61813adc65bb6e674b8/regex-2026.9.29-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a714befaacbd10092ffe4cea0d3c5f008fb9efe9bc322c715bcdfdee414b9a3d", size = 808808, upload-time = "2026-09-29T00:48:53.529Z" },
+ { url = "https://files.pythonhosted.org/packages/68/60/0bc0d1ec8b37ad64be6fa30e035251f11de9667a0fac9e82ee74517d81be/regex-2026.9.29-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33026515aebc0e70d1c89978e53e8d695d35d9e472f8d5b34465ba3c74028650", size = 789907, upload-time = "2026-09-29T00:48:56.036Z" },
+ { url = "https://files.pythonhosted.org/packages/da/84/116a3ef19b3acfe81077f0bf2cbc7714a5e94bc8935b7243ab61cb0f1c3c/regex-2026.9.29-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:31b003f9a070335e2a8233ee9b14a3ca8e6d792012ae011f741bf0aaf11744c5", size = 795770, upload-time = "2026-09-29T00:48:58.284Z" },
+ { url = "https://files.pythonhosted.org/packages/96/ba/e38c3f203e7e7e18c957d48e6cb6dbf96c11e95a44efa4a480522afc5d6d/regex-2026.9.29-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:c03c6eb6ece86dfdcbb34799efaa339b093132e1aceed491ba5e08fe06cdf699", size = 870671, upload-time = "2026-09-29T00:49:00.506Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/0f/9ee0b0cb76c55f63684bd7fff554978e8773b4fc86e2bcb2d50772dc1086/regex-2026.9.29-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:a5300757f8a68f5b6cc33f57338d72a0e3589c5cc9ad5f8504ea06f028be582a", size = 778631, upload-time = "2026-09-29T00:49:02.984Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/19/e6e3eeb226af5872c4958002f6edef4e4f40ea4cc5f5665023f2019eb045/regex-2026.9.29-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:80c7cadd3fd2bfde5df8aa0787e315812cad0c313a753095d02f4c2b6c01677b", size = 862187, upload-time = "2026-09-29T00:49:05.264Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/62/823c102e106bb2711d6b7dfe5981552fe4467b2969c46a20c5c383cf498c/regex-2026.9.29-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:3f1e6cb402a89457582cd696f982559217d13484a193202c394015297968c86d", size = 798423, upload-time = "2026-09-29T00:49:07.644Z" },
+ { url = "https://files.pythonhosted.org/packages/37/e0/e927776258fa70b2f6feffc3be584ffc85ba4c1e20a320f0aee9a632fc7d/regex-2026.9.29-cp315-cp315-win32.whl", hash = "sha256:a64b85a4760337cfefdb27d42da6ed8b58e8cde3f2d57b6ef43e76ef6ea9ef47", size = 274757, upload-time = "2026-09-29T00:49:10.513Z" },
+ { url = "https://files.pythonhosted.org/packages/77/04/358de85d1860238e1b4fa98fc2c80c990124a25d2e14739e28cc02c25562/regex-2026.9.29-cp315-cp315-win_amd64.whl", hash = "sha256:b3e445b66c80b4eb4234e855ce94d9adc183eedbd632816228d89930b91b2c5b", size = 283824, upload-time = "2026-09-29T00:49:12.849Z" },
+ { url = "https://files.pythonhosted.org/packages/92/d3/d5c5b264784a5ab2b0f8cf620c1eeb4dbf3440d306761905e7d99345bef5/regex-2026.9.29-cp315-cp315-win_arm64.whl", hash = "sha256:8f39588af4731c8923c26810eb3b33f76f17633985e40f59c3cd45a33805a895", size = 283664, upload-time = "2026-09-29T00:49:15.331Z" },
+ { url = "https://files.pythonhosted.org/packages/02/dc/f63ec2c201445ce1150fe780f5c56f16a10124d9a9da3a93161dbb0d8892/regex-2026.9.29-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:fb99cc9d45f48895d9d67f6a0b8a57f08d39c174d9f25ad97a313e0470267b1c", size = 501549, upload-time = "2026-09-29T00:49:17.705Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/5c/d2a698dc6bfc11fbce03f1cb0249c13284e93b79ed11f893edf6fac431c9/regex-2026.9.29-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:720537c7ea6f80dc61913184edb0ce2497a306b39ef19f28505b322553d52bdb", size = 298187, upload-time = "2026-09-29T00:49:20.171Z" },
+ { url = "https://files.pythonhosted.org/packages/85/b7/88dcdb38cd3935d4ee9e9ce9b8e56cb3b3518d1f020acfa7dd62ad289bf8/regex-2026.9.29-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0fd2c901cc307a745ad4bc87f20060d7a0825a3371d1e93488af22e7a387f78f", size = 296157, upload-time = "2026-09-29T00:49:22.342Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/8e/ba6c01dde33a69fc294b38b43f6677baaa5735a6248f39708031a738158a/regex-2026.9.29-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b11b589e00095ec69cf79841a76360f9b079e95b0368a25b5ebb951ab0c157ff", size = 818468, upload-time = "2026-09-29T00:49:24.612Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/f1/2586693e3a2d6b1247852593d37a6c17b42a92ee44f7cdcb9a0c1494e64a/regex-2026.9.29-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d7cab119d0df0b9413f106b4d7fc34f2872d3574ed3806fb48959c830b1537da", size = 882825, upload-time = "2026-09-29T00:49:26.996Z" },
+ { url = "https://files.pythonhosted.org/packages/30/51/084f3e7bdcd0e9c33665c938cf5d134dc3548cbb4a75f0197ec7bfd754b1/regex-2026.9.29-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b89efc38431793d28b7cd91227e2f952ad7c48df19132b17f43a5fec3c14143b", size = 923314, upload-time = "2026-09-29T00:49:29.822Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/f1/066c6fc23b7dc229789c21c880b5ba5ad689fb95fed12e078266f55a1f9b/regex-2026.9.29-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:80a5ea3b4fd9d6a5b9a44f7976a9acaaab35aa3c1f6b29e5bd857dfabaded223", size = 822222, upload-time = "2026-09-29T00:49:32.404Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/56/592cd46fdb8f2f8682a1d7fd1310e4d0bcb93fbd0e6bbe4141ac28240227/regex-2026.9.29-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:19959129885356df0e97556856f77eb2888380dac18bed075a7c05c5128c618d", size = 794882, upload-time = "2026-09-29T00:49:35.076Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/4d/d65384bb071c864b01aa8314e3a6a687845ebd57588390976edc960c218b/regex-2026.9.29-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:6a1a824fbed817e0a891103886b68f063b1e83cc51bc97192a90a60195a9291f", size = 805887, upload-time = "2026-09-29T00:49:37.395Z" },
+ { url = "https://files.pythonhosted.org/packages/65/b6/358de0d8f40d5178e4f7e7e121cfd5b961c812b77a055d11f5079e3f8fd7/regex-2026.9.29-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1ba8c6a416569ce0d37e83e28a254a61dc99a419084dfb6476cea02d997f74fa", size = 872901, upload-time = "2026-09-29T00:49:39.927Z" },
+ { url = "https://files.pythonhosted.org/packages/00/06/6bfded72d043240c6b52bbb5e16f639d81affbf7484b4fe2ec45f3d4afc9/regex-2026.9.29-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:446654b29bfaa30500d80947eda42cef1449dc8a87f4e3cf061cc8485d3a1f0b", size = 782970, upload-time = "2026-09-29T00:49:42.581Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/20/9f418a50baa78b3ed8308fcb0cc49e472dd000b7ef935a7295af202ea744/regex-2026.9.29-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bf3c49863c23a1ad6da9c30351aed6cff8d5ddbeb63c5c8420ae54e98c7d0138", size = 865441, upload-time = "2026-09-29T00:49:45.238Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/29/817c7eacdeaf8463123e949bd394c39ad024eea1ec38ddf5ad141da2f3bd/regex-2026.9.29-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:01000ddf0e3ffef97f2413ceb514f6313040106b6d18a03ee00a4fe35c1eb1db", size = 809431, upload-time = "2026-09-29T00:49:47.878Z" },
+ { url = "https://files.pythonhosted.org/packages/63/0b/83aab3b5b739947f744135a7a3a446e25433ebc92b05e01aae197ccbfdda/regex-2026.9.29-cp315-cp315t-win32.whl", hash = "sha256:c4e38dd8f39c43a91d2410ad2b85610701b0979342c3df1d69eaf8e838c757d8", size = 276964, upload-time = "2026-09-29T00:49:50.524Z" },
+ { url = "https://files.pythonhosted.org/packages/72/f2/6314b5fc68789b5dcc38885bc6e3d6986b34fb3372b7231088ee5cecaa05/regex-2026.9.29-cp315-cp315t-win_amd64.whl", hash = "sha256:e2c89e9b762c57f59d5e99ee8b20202adb892e35f8d3485741340999ca55058e", size = 286487, upload-time = "2026-09-29T00:49:53.224Z" },
+ { url = "https://files.pythonhosted.org/packages/56/bc/97b2245c8c7b2dd01f2db74f2bea003cd33c15009b4996a2447f46b5325c/regex-2026.9.29-cp315-cp315t-win_arm64.whl", hash = "sha256:e8c65ef3862a8ad6e86492b6ed9327805dd66904c012bd3649dc67d822ed6c34", size = 285955, upload-time = "2026-09-29T00:49:55.655Z" },
+]
+
[[package]]
name = "requests"
version = "2.34.2"
@@ -2712,6 +3262,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/cd/1a/b3a3e9f6520493fed7997af4d2de7965d71549c62f994a8fd15f2ecd519e/sentry_sdk-2.56.0-py2.py3-none-any.whl", hash = "sha256:5afafb744ceb91d22f4cc650c6bd048ac6af5f7412dcc6c59305a2e36f4dbc02", size = 451568, upload-time = "2026-03-24T09:56:34.807Z" },
]
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
[[package]]
name = "slack-sdk"
version = "3.45.0"
@@ -2805,14 +3364,14 @@ version = "2.1.0"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
]
dependencies = [
@@ -2931,14 +3490,14 @@ version = "1.9.0"
source = { registry = "https://pypi.org/simple" }
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
- "python_full_version == '3.13.*' and sys_platform == 'win32'",
"python_full_version >= '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version >= '3.14' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.13.*' and sys_platform == 'win32'",
+ "python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
"(python_full_version == '3.13.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'win32')",
+ "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform == 'win32'",
"python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
- "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
"(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version == '3.11.*' and sys_platform == 'emscripten')",
]
dependencies = [
@@ -2950,6 +3509,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/f3/93/181df62699d9b5aca1d87e5cfda131dac87e3cdaebf668662f7206ca3470/starlette-1.9.0-py3-none-any.whl", hash = "sha256:fd3f159936e882d06c1108f84688f7cda2cf85fc6a592a50edbd175e882c2ddc", size = 80335, upload-time = "2026-10-18T15:50:31.526Z" },
]
+[[package]]
+name = "tld"
+version = "0.13.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/5d/76b4383ac4e5b5e254e50c09807b3e13820bed6d6c11cd540264988d6802/tld-0.13.2.tar.gz", hash = "sha256:d983fa92b9d717400742fca844e29d5e18271079c7bcfabf66d01b39b4a14345", size = 467175, upload-time = "2026-03-06T23:50:34.498Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9e/90/39a85a4b63c84213e78b3c17d22e1bf45328acf8ebb33ef93be30d0a3911/tld-0.13.2-py2.py3-none-any.whl", hash = "sha256:9b8fdbdb880e7ba65b216a4937f2c94c49a7226723783d5838fc958ac76f4e0c", size = 296743, upload-time = "2026-03-06T23:50:32.465Z" },
+]
+
[[package]]
name = "tomli"
version = "2.4.1"
@@ -3004,6 +3572,24 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
]
+[[package]]
+name = "trafilatura"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "charset-normalizer" },
+ { name = "courlan" },
+ { name = "htmldate" },
+ { name = "justext" },
+ { name = "lxml" },
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/e7/d359fcf887675c4305fb1f4548372484a2d8f0bc793dc6f2da3a748c1253/trafilatura-2.3.1.tar.gz", hash = "sha256:2e5557aeab32d33b9da7ff0debbb677a676c5b648a927e50d91b8277011e1105", size = 350794, upload-time = "2026-10-06T19:30:26.202Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f5/20/e95d135c417aceaa3d34d1b4dff9aceb85e98800480eca1b033933717169/trafilatura-2.3.1-py3-none-any.whl", hash = "sha256:f86bad2ee36f82884e14dee84c83aae0f0ac0127da5c65764e82f3846716b822", size = 158660, upload-time = "2026-10-06T19:30:24.385Z" },
+]
+
[[package]]
name = "truststore"
version = "0.10.5"
diff --git a/vibe/data/web_fetch_browser.json b/vibe/data/web_fetch_browser.json
new file mode 100644
index 000000000..e3773ddef
--- /dev/null
+++ b/vibe/data/web_fetch_browser.json
@@ -0,0 +1,12 @@
+{
+ "version": "0.16.3",
+ "impersonate": "chrome150",
+ "verified_at": "2026-10-25",
+ "sec_ch_ua": "\"Not;A=Brand\";v=\"8\", \"Chromium\";v=\"150\", \"Google Chrome\";v=\"150\"",
+ "platforms": {
+ "darwin": {"platform": "macOS", "ua_os": "Macintosh; Intel Mac OS X 10_15_7"},
+ "win32": {"platform": "Windows", "ua_os": "Windows NT 10.0; Win64; x64"},
+ "linux": {"platform": "Linux", "ua_os": "X11; Linux x86_64"}
+ },
+ "header_order": ["sec-ch-ua", "sec-ch-ua-mobile", "sec-ch-ua-platform", "Upgrade-Insecure-Requests", "User-Agent", "Accept", "Sec-Fetch-Site", "Sec-Fetch-Mode", "Sec-Fetch-User", "Sec-Fetch-Dest", "Accept-Encoding", "Accept-Language"]
+}