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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
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.ymlindex f861ddab3..1b397a642 100644--- a/.github/workflows/lint.yml+++ b/.github/workflows/lint.yml@@ -110,6 +110,48 @@ jobs:pip install pre-commitpre-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: changesif: needs.changes.outputs.docs_only == 'false'diff --git a/core/handlers/model_hub/local_fetch.py b/core/handlers/model_hub/local_fetch.pynew file mode 100644index 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__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/core/web_fetch_worker/extract.py b/core/web_fetch_worker/extract.pynew file mode 100644index 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.pynew file mode 100644index 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 Nonediff --git a/core/web_fetch_worker/transport.py b/core/web_fetch_worker/transport.pynew file mode 100644index 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+ raisediff --git a/core/web_fetch_worker/worker.py b/core/web_fetch_worker/worker.pynew file mode 100644index 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.jsonindex 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.pyindex 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.parentdiff --git a/docs/plans/web-fetch.md b/docs/plans/web-fetch.mdindex 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-originzero-delay meta-refresh and one same-origin Markdown alternate all consume thesame local deadline/body/hop budgets. Ignore malformed alternates; an alternatewhose 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, noHTTP 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:```httpAccept: 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. Asingle cheap same-origin `<link rel="alternate" type="text/markdown">` isallowed, 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 notsilently 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. Withinthe 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 thedegraded transport **before sending** and record `transport_degraded: true` witha bounded reason; no target error triggers a second local request. Decode onlyadvertised 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**, includingDNS, 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 countedon 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, environmentcredential, 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.shindex 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; thenVIBE_CANDIDATE_BIN_PATH="$generation_bin/vibe"if [ ! -x "$VIBE_CANDIDATE_BIN_PATH" ]; thenwarn "uv completed but the candidate vibe launcher was not created"diff --git a/pyproject.toml b/pyproject.tomlindex 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.pyindex 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.pyindex 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"] == 2assert 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 sourcesassert "codex_license" not in sourcesfor 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.pyindex 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.pynew file mode 100644index 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++[email protected]("url", [+ "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 Nonediff --git a/tests/test_model_hub_fetch_tls.py b/tests/test_model_hub_fetch_tls.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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)  <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 Nonediff --git a/tests/test_sentry_integration.py b/tests/test_sentry_integration.pyindex 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 gzipimport sentry_sdkfrom sentry_sdk.envelope import Envelope@@ -761,7 +770,7 @@ def test_performance_transactions_are_scrubbed_like_events(monkeypatch, tmp_pathsentry_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_pathdef test_real_sdk_event_shapes_preserve_protocol_ownership(monkeypatch, tmp_path):- import gzipimport jsonimport sentry_sdk@@ -822,7 +830,7 @@ def test_real_sdk_event_shapes_preserve_protocol_ownership(monkeypatch, tmp_pathsentry_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_pathdef test_worker_scrub_retains_rotated_secret_after_enqueue(monkeypatch, tmp_path):"""A value queued before rotation remains covered by the process-lifetime union."""- import gzipimport threadingimport sentry_sdk@@ -888,7 +895,7 @@ def test_worker_scrub_retains_rotated_secret_after_enqueue(monkeypatch, tmp_pathtry:(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.lockindex f142fbefa..400e33d5d 100644--- a/uv.lock+++ b/uv.lock@@ -3,14 +3,14 @@ revision = 5requires-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.jsonnew file mode 100644index 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"]+}