From faad9764a267d8339f2c02adc0025bac6b82dd28 Mon Sep 17 00:00:00 2001 From: Dusan Malusev Date: Thu, 23 Jul 2026 17:17:42 +0200 Subject: [PATCH 1/4] feature(argusAI): summarize SCT events in the similarity worker Dispatch a bounded, best-effort summarization pass from the event-similarity worker: sanitize and BGE-embed through a shared EventEmbedder, then hand ERROR/CRITICAL events to an OpenAI-backed Summarizer whose result is written to the new sct_event.summary column. Summarization runs on a capped thread pool with a backlog gate and can never break embedding. Summary prompts are externalized to versioned files. --- argus/backend/plugins/sct/testrun.py | 1 + .../tests/sct_events/test_sct_events.py | 49 +++- argusAI/event_similarity_processor_v2.py | 55 ++--- argusAI/prompts/__init__.py | 20 ++ argusAI/prompts/judge.md | 12 + argusAI/prompts/v1_baseline.md | 1 + argusAI/prompts/v2_structured.md | 16 ++ argusAI/prompts/v3_fielded.md | 11 + argusAI/prompts/v4_adaptive.md | 16 ++ argusAI/prompts/v5_surgical.md | 21 ++ argusAI/prompts/v6_summary.md | 17 ++ argusAI/prompts/v7_summary.md | 21 ++ argusAI/tests/test_summary_dispatcher.py | 222 ++++++++++++++++++ argusAI/utils/embedding.py | 48 ++++ argusAI/utils/event_message_sanitizer.py | 15 +- argusAI/utils/summarizer.py | 126 ++++++++++ argusAI/utils/summary_dispatcher.py | 161 +++++++++++++ argus_web.example.yaml | 20 ++ pyproject.toml | 1 + 19 files changed, 787 insertions(+), 46 deletions(-) create mode 100644 argusAI/prompts/__init__.py create mode 100644 argusAI/prompts/judge.md create mode 100644 argusAI/prompts/v1_baseline.md create mode 100644 argusAI/prompts/v2_structured.md create mode 100644 argusAI/prompts/v3_fielded.md create mode 100644 argusAI/prompts/v4_adaptive.md create mode 100644 argusAI/prompts/v5_surgical.md create mode 100644 argusAI/prompts/v6_summary.md create mode 100644 argusAI/prompts/v7_summary.md create mode 100644 argusAI/tests/test_summary_dispatcher.py create mode 100644 argusAI/utils/embedding.py create mode 100644 argusAI/utils/summarizer.py create mode 100644 argusAI/utils/summary_dispatcher.py diff --git a/argus/backend/plugins/sct/testrun.py b/argus/backend/plugins/sct/testrun.py index 9026cc3d1..65a87116b 100644 --- a/argus/backend/plugins/sct/testrun.py +++ b/argus/backend/plugins/sct/testrun.py @@ -86,6 +86,7 @@ class SCTEvent(Model): event_type = columns.Text() message = columns.Text(required=True) duplicate_id = columns.UUID() + summary = columns.Text() # LLM-generated summary; null until/unless summarized (see argusAI) # DB Log columns node = columns.Text() diff --git a/argus/backend/tests/sct_events/test_sct_events.py b/argus/backend/tests/sct_events/test_sct_events.py index 07eb243fb..5cadd301e 100644 --- a/argus/backend/tests/sct_events/test_sct_events.py +++ b/argus/backend/tests/sct_events/test_sct_events.py @@ -6,8 +6,9 @@ from flask.testing import FlaskClient +from argus.backend.db import ScyllaCluster from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest -from argus.backend.plugins.sct.testrun import SCTEventSeverity, SCTTestRun +from argus.backend.plugins.sct.testrun import SCTEvent, SCTEventSeverity, SCTTestRun from argus.backend.service.client_service import ClientService from argus.backend.plugins.sct.service import SCTService from argus.backend.service.testrun import TestRunService @@ -43,6 +44,52 @@ def test_submit_event(client_service: ClientService, sct_service: SCTService, te assert len(all_events) == 1, "Event not found" +def test_get_events_includes_summary_field(client_service: ClientService, sct_service: SCTService, testrun_service: TestRunService, fake_test: ArgusTest): + run_type, run_req = get_fake_test_run(fake_test) + client_service.submit_run(run_type, asdict(run_req)) + run: SCTTestRun = testrun_service.get_run(run_type, run_req.run_id) + + message = "database error: sstable corruption at offset 42" + event_data: RawEventPayload = { + "duration": 30.0, + "event_type": "end", + "known_issue": None, + "message": message, + "nemesis_name": None, + "nemesis_status": None, + "node": None, + "received_timestamp": None, + "run_id": run.id, + "severity": SCTEventSeverity.ERROR.value, + "target_node": None, + "ts": datetime.now(tz=UTC).timestamp() + } + _ = sct_service.submit_event(str(run.id), event_data) + + # A freshly submitted event has no summary yet: the field is present and null, + # and consumers fall back to the original message (goal 4). + before = run.get_events_limited(run.id, severities=[SCTEventSeverity.ERROR]) + assert len(before) == 1, "Event not found" + assert "summary" in before[0], "summary column must ride along in the get_events payload" + assert before[0]["summary"] is None, "un-summarized event must report summary=null" + assert before[0]["message"] == message + + # Simulate the argusAI worker writing a summary back with its exact raw-CQL upsert. + evt = before[0] + cluster = ScyllaCluster.get() + stmt = cluster.prepare( + f"UPDATE {SCTEvent.table_name()} SET summary = ? WHERE run_id = ? AND severity = ? AND ts = ?" + ) + summary = "ERROR on sstable corruption (offset 42)" + cluster.session.execute(stmt, (summary, evt["run_id"], evt["severity"], evt["ts"])) + + # Serving now carries the summary, and the original message is intact (additive, goal 3). + after = run.get_events_limited(run.id, severities=[SCTEventSeverity.ERROR]) + assert len(after) == 1 + assert after[0]["summary"] == summary + assert after[0]["message"] == message, "original message must remain intact alongside the summary" + + def test_get_events_by_severity(client_service: ClientService, sct_service: SCTService, testrun_service: TestRunService, fake_test: ArgusTest): run_type, run_req = get_fake_test_run(fake_test) client_service.submit_run(run_type, asdict(run_req)) diff --git a/argusAI/event_similarity_processor_v2.py b/argusAI/event_similarity_processor_v2.py index 1b720fe42..d4f58ddd6 100644 --- a/argusAI/event_similarity_processor_v2.py +++ b/argusAI/event_similarity_processor_v2.py @@ -12,13 +12,11 @@ from collections import namedtuple import logging import time -from pathlib import Path from threading import Event from typing import Literal from uuid import UUID from datetime import datetime -from chromadb.utils.embedding_functions.onnx_mini_lm_l6_v2 import ONNXMiniLM_L6_V2 from chromadb.utils.distance_functions import cosine from numpy import array @@ -26,7 +24,8 @@ from argus.backend.plugins.sct.testrun import SCTUnprocessedEvent, SCTEvent from argus.backend.util.logsetup import setup_application_logging from argusAI.utils.scylla_connection import ScyllaConnection -from argusAI.utils.event_message_sanitizer import MessageSanitizer +from argusAI.utils.embedding import EventEmbedder +from argusAI.utils.summary_dispatcher import SummaryDispatcher LOGGER = logging.getLogger(__name__) SLEEP_INTERVAL = 1 # Sleep for 1 second between processing cycles @@ -36,23 +35,6 @@ RunIdStr = str -class BgeSmallEnEmbeddingModel(ONNXMiniLM_L6_V2): - """ - Compact English text embedding model by BAAI, released Sep 2023. - Trained on large-scale paired data with RetroMAE and contrastive learning. - Produces high-quality 384-dim embeddings, optimized for efficiency in semantic search, classification, and clustering. - """ - - MODEL_NAME: str = "bge-small-en-v1.5" - DOWNLOAD_PATH: Path = Path.home() / ".cache" / "chroma" / "onnx_models" / MODEL_NAME - EXTRACTED_FOLDER_NAME: str = "onnx" - ARCHIVE_FILENAME: str = "onnx.tar.gz" - MODEL_DOWNLOAD_URL: str = ( - "https://scylla-qa-public.s3.us-east-1.amazonaws.com/ArgusAI/bge-small-en-v1.5/onnx.tar.gz" - ) - _MODEL_SHA256: str = "e7d1743b0c08f55c687cff6af696683398682f9ab4fb3cad1be644ee5553a72d" - - class EventSimilarityProcessorV2: """ Processes unprocessed SCT events by generating embeddings and storing them in severity-specific tables. @@ -65,8 +47,7 @@ def __init__(self, stop_event: Event | None = None) -> None: Args: stop_event: Optional threading.Event to signal shutdown """ - self.embedding_model = BgeSmallEnEmbeddingModel() - self.sanitizer = MessageSanitizer() + self.embedder = EventEmbedder() self.stop_event = stop_event or Event() self.db = ScyllaConnection() self.processed_count = 0 @@ -78,6 +59,10 @@ def __init__(self, stop_event: Event | None = None) -> None: or SCTErrorEventEmbedding.__keyspace__ or self.db.config["SCYLLA_KEYSPACE_NAME"] ) + # Best-effort summarization of unique events, dispatched from the per-event pipeline. + # Inert unless EVENT_SUMMARIZATION_ENABLED and OPENAI_API_KEY are configured; the + # embedding path is never blocked or altered by it. + self.summary_dispatcher = SummaryDispatcher(self.db, self.db.config) LOGGER.info("EventSimilarityProcessorV2 initialized") def _clear_stale_cache(self): @@ -260,31 +245,21 @@ def _process_single_event(self, run_id: UUID, severity: str, ts: datetime) -> No LOGGER.warning(f"Event has no message: run_id={run_id}, severity={severity}, ts={ts}") raise ValueError("Event message is empty") - # Step 2: Sanitize event message + # Step 2-3: Sanitize the message and generate its embedding (shared with the eval). try: - sanitized_message = self.sanitizer.sanitize(run_id, message) + embedding = self.embedder.embed(message, run_id) except Exception as e: - LOGGER.error(f"Failed to sanitize message for event (run_id={run_id}): {e}", exc_info=True) - raise - - if not sanitized_message or not sanitized_message.strip(): - LOGGER.warning(f"Sanitized message is empty for event: run_id={run_id}, severity={severity}, ts={ts}") - raise ValueError("Sanitized message is empty") - - # Step 3: Generate embedding - try: - embeddings = self.embedding_model([sanitized_message]) - if not embeddings or len(embeddings) == 0: - raise ValueError("Embedding generation returned empty result") - embedding = embeddings[0] - except Exception as e: - LOGGER.error(f"Failed to generate embedding for event (run_id={run_id}): {e}", exc_info=True) + LOGGER.error(f"Failed to embed event (run_id={run_id}): {e}", exc_info=True) raise # Step 3.5: Check if event is duplicate, cancel remaining steps if it is. if self._mark_event_is_duplicate(run_id, ts, severity, embedding): return + # Step 3.6: Event is unique — dispatch summarization of the RAW message (not the + # sanitized one) as a fire-and-forget background task. Never blocks Step 4. + self.summary_dispatcher.dispatch(run_id, severity, ts, message) + # Step 4: Store embedding in severity-specific table try: if severity == "ERROR": @@ -318,6 +293,8 @@ def _process_single_event(self, run_id: UUID, severity: str, ts: datetime) -> No def shutdown(self) -> None: """Shutdown the processor and cleanup resources.""" self.stop_event.set() + # Drain in-flight summarization tasks before closing the DB they write through. + self.summary_dispatcher.shutdown() self.db.shutdown() LOGGER.info("EventSimilarityProcessorV2 shutdown complete") diff --git a/argusAI/prompts/__init__.py b/argusAI/prompts/__init__.py new file mode 100644 index 000000000..e9c146b96 --- /dev/null +++ b/argusAI/prompts/__init__.py @@ -0,0 +1,20 @@ +from __future__ import annotations + +from pathlib import Path + +PROMPTS_DIR = Path(__file__).resolve().parent + +PRODUCTION_PROMPT_NAME = "v7_summary" +JUDGE_PROMPT_NAME = "judge" + + +def load_prompt(name: str) -> str: + path = PROMPTS_DIR / f"{name}.md" + if not path.is_file(): + available = sorted(p.stem for p in PROMPTS_DIR.glob("*.md")) + raise FileNotFoundError(f"No prompt '{name}' at {path}. Available: {available}") + return path.read_text(encoding="utf-8").strip() + + +def load_summary_prompts() -> dict[str, str]: + return {p.stem: p.read_text(encoding="utf-8").strip() for p in sorted(PROMPTS_DIR.glob("v*.md"))} diff --git a/argusAI/prompts/judge.md b/argusAI/prompts/judge.md new file mode 100644 index 000000000..2c09e4e60 --- /dev/null +++ b/argusAI/prompts/judge.md @@ -0,0 +1,12 @@ +You are a strict evaluator of error-event summaries for a database test-triage tool. +You are given the ORIGINAL event and a candidate SUMMARY of it. +Judge only how well the summary preserves the information an engineer needs to triage the failure, and whether it is faithful (adds nothing false). + +Score these dimensions 0-100: +- coverage: are the critical facts kept? (failure type, node/shard, exact error string, root-cause line, key numeric values, deepest stack frames, event id/timestamp when present) +- faithfulness: is everything in the summary actually supported by the original? (hallucinations or wrong values crater this score) +- conciseness: is it free of redundant boilerplate while staying lossless? (do NOT reward brevity that drops facts) + +Return ONLY a JSON object, no prose, of the form: +{"coverage": , "faithfulness": , "conciseness": , "dropped_critical": ["..."], "hallucinations": ["..."], "verdict": ""} +"dropped_critical" lists important facts missing from the summary; "hallucinations" lists anything asserted but unsupported. Both empty is ideal. diff --git a/argusAI/prompts/v1_baseline.md b/argusAI/prompts/v1_baseline.md new file mode 100644 index 000000000..141fa04c6 --- /dev/null +++ b/argusAI/prompts/v1_baseline.md @@ -0,0 +1 @@ +Summarize this error event in a way we don't lose information and use minimum tokens. Don't add anything more from your side. diff --git a/argusAI/prompts/v2_structured.md b/argusAI/prompts/v2_structured.md new file mode 100644 index 000000000..24961afc3 --- /dev/null +++ b/argusAI/prompts/v2_structured.md @@ -0,0 +1,16 @@ +You summarize a single ScyllaDB test (SCT) ERROR/CRITICAL event for engineers triaging a failed run. + +Preserve, verbatim where they appear, every fact needed to identify and locate the failure: +- the failure/event type and severity +- the implicated node name and shard, if present +- exact error strings, error codes, keyspace/table names, and numeric values (sizes, counts, timeouts) +- the event id and timestamp, if present +- the most specific root-cause line, and the deepest few frames of any stack trace + +Rules: +- Do NOT invent, infer, or add anything not present in the event. If something is unknown, omit it — never guess. +- Do NOT editorialize or suggest fixes. +- Drop only redundant boilerplate and repeated log noise. When in doubt, keep it. +- Use the fewest tokens that lose no information a triager would need. + +Output plain text, no preamble. diff --git a/argusAI/prompts/v3_fielded.md b/argusAI/prompts/v3_fielded.md new file mode 100644 index 000000000..b4adae91f --- /dev/null +++ b/argusAI/prompts/v3_fielded.md @@ -0,0 +1,11 @@ +You compress one SCT ERROR/CRITICAL event for a failure-investigation tool. Lossless on facts, minimal on tokens. + +Emit these fields, each on its own line, omitting any that are truly absent (never fabricate): +TYPE: () +NODE: , shard +SIGNAL: +DETAILS: +TRACE: +ID: @ + +Hard rules: copy facts verbatim; add nothing not in the input; if unsure whether a detail matters, keep it. No fixes, no commentary. diff --git a/argusAI/prompts/v4_adaptive.md b/argusAI/prompts/v4_adaptive.md new file mode 100644 index 000000000..a73e4f368 --- /dev/null +++ b/argusAI/prompts/v4_adaptive.md @@ -0,0 +1,16 @@ +You compress a single ScyllaDB test (SCT) ERROR/CRITICAL event for engineers triaging a failed run. Goal: keep every fact needed to identify and locate the failure, using far fewer characters than the original. + +Keep, copied verbatim where present (never reworded, never relabeled): +- severity, event type, and event_id / period_type / line_number if present +- the implicated node name and shard +- the exact error/exception string and error code, verbatim (including any leading log prefix like "!ERR |") +- keyspace/table names and all numeric values (sizes, counts, timeouts, offsets) +- for a stack/backtrace: the exception line, the top 2-3 frames, the deepest 2-3 frames, and any allocation/reclaim/stall chain frames (e.g. logalloc/segment_pool/seastar::memory reclaim). Replace long runs of library frames with "… frames …". Never drop the chain that shows *why* it failed. + +Hard rules: +- The summary MUST be shorter than the original. Never output more characters than you received. +- If the event is already short (a few lines), just strip redundant noise and return the essential line(s). Do NOT reformat it into a field list, and do NOT re-quote the full original log line in addition to the fields — that duplicates content and makes it longer. +- Add nothing not in the event. Do not infer root cause, do not suggest fixes, do not relabel a line as something it isn't. If unsure whether a detail matters, keep it verbatim rather than paraphrasing. +- Prefer a compact form: a short header line of the key identifiers, then only the lines that carry signal. + +Output plain text, no preamble. diff --git a/argusAI/prompts/v5_surgical.md b/argusAI/prompts/v5_surgical.md new file mode 100644 index 000000000..461334753 --- /dev/null +++ b/argusAI/prompts/v5_surgical.md @@ -0,0 +1,21 @@ +You summarize a single ScyllaDB test (SCT) ERROR/CRITICAL event for engineers triaging a failed run. + +Preserve, verbatim where they appear, every fact needed to identify and locate the failure: +- the failure/event type and severity +- the implicated node name and shard, if present +- exact error strings, error codes, keyspace/table names, and numeric values (sizes, counts, timeouts) +- the event id and timestamp, if present +- the most specific root-cause line, and the deepest few frames of any stack trace + +Rules: +- Do NOT invent, infer, or add anything not present in the event. If something is unknown, omit it — never guess. +- Do NOT editorialize or suggest fixes. +- Drop only redundant boilerplate and repeated log noise. When in doubt, keep it. +- Use the fewest tokens that lose no information a triager would need. + +Output plain text, no preamble. + +Length discipline (this is what keeps summarization worthwhile): +- Never output more characters than you received. A summary that is longer than the original is a failure. +- If the event is already short (roughly a handful of lines), do NOT expand it into a field-per-line list and do NOT re-quote the full original log line separately from the facts — that duplicates content. Just return the essential line(s) with redundant noise removed. For long events, keep the informative structure as above. +- Never drop stack/backtrace frames on large events: keep the exception line, the top frames, the deepest frames, and any allocation/reclaim/stall chain, collapsing only long runs of unrelated library frames. diff --git a/argusAI/prompts/v6_summary.md b/argusAI/prompts/v6_summary.md new file mode 100644 index 000000000..c6092f068 --- /dev/null +++ b/argusAI/prompts/v6_summary.md @@ -0,0 +1,17 @@ +Summarize this ScyllaDB test (SCT) ERROR/CRITICAL event into a short, readable triage summary. + +This summary is the FIRST-PASS view for an engineer or an AI investigator. The full original event is always available on demand, so do NOT reproduce it verbatim — compress aggressively. A reader who needs the raw stack trace, full log lines, or exact offsets will open the original; your job is to let them decide whether they need to. + +Produce a compact Markdown summary with: +- a one-line **headline**: the failure/event type, the key value(s), the node and shard, and the severity in plain terms (e.g. non-fatal warning vs fatal error) +- **Root cause**: the most likely cause in one or two lines, in plain engineering language — transform the stack trace into meaning (the operation and subsystem involved), do not list raw frames or hex addresses +- **Call chain**: the meaningful sequence of operations, as decoded symbols/subsystems where the event names them; omit library glue and raw addresses +- **Trigger**: what set it off, if the event supports an answer +- **Event ID** and **timestamp** + +Faithfulness rules (this is what keeps the summary trustworthy): +- Base the root cause and call chain ONLY on what the event actually evidences — the error message, named libraries/symbols, offsets, and log text present. Do NOT invent specific function names, subsystems, or causes the event does not support. +- If the cause or call chain is not determinable from the event, say so briefly (e.g. "root cause not evident from the backtrace") rather than guessing. A cautious, correct summary beats a confident, wrong one. +- Never contradict a value in the event; copy exact identifiers (event id, node, numbers) rather than paraphrasing them. + +Aim for the fewest tokens that still let a triager understand what failed and decide whether to open the original. Output concise Markdown, no preamble. diff --git a/argusAI/prompts/v7_summary.md b/argusAI/prompts/v7_summary.md new file mode 100644 index 000000000..2103f7144 --- /dev/null +++ b/argusAI/prompts/v7_summary.md @@ -0,0 +1,21 @@ +Summarize this ScyllaDB test (SCT) ERROR/CRITICAL event into a short, readable triage summary. + +This is the FIRST-PASS view for an engineer or AI investigator. The full original event is always available on demand, so do NOT reproduce it verbatim — compress hard. Your job is to let the reader understand what failed and decide whether to open the original. + +Adapt the shape to the event: + +- If the event is SHORT (a line or two, no real stack trace): output a single headline line — failure/event type, key value(s), node/shard, and the exact error text — and stop. Do NOT add Root cause / Call chain / Trigger sections; there is nothing to decode, and inventing them is worse than omitting them. + +- If the event carries a STACK TRACE or is long: output compact Markdown with + - **Headline**: failure/event type, key value(s), node/shard, severity as literally stated + - **Root cause**: one or two lines, only if the trace/message actually shows it — name the operation and subsystem from the decoded symbols present in the trace + - **Call chain**: the meaningful decoded frames the trace names (skip hex addresses and library glue) + - **Event ID** and **timestamp** + +Faithfulness rules (non-negotiable — a wrong summary is worse than a terse one): +- State severity (non-fatal / fatal) ONLY if the event text says so. Do not infer it. +- Do NOT guess a trigger, root cause, or call chain that the event does not evidence. Only decode symbols and frames that literally appear in the trace. If the cause isn't determinable, write "root cause not evident from the event" — never speculate. +- Copy exact identifiers (event id, node, numbers, error strings) rather than paraphrasing; never contradict a value in the event. +- No hedging prose, no "may/might/likely" speculation about unstated behavior. + +Aim for the fewest tokens that still convey what failed. Output concise Markdown (or a single line for short events), no preamble. diff --git a/argusAI/tests/test_summary_dispatcher.py b/argusAI/tests/test_summary_dispatcher.py new file mode 100644 index 000000000..1cb1ab466 --- /dev/null +++ b/argusAI/tests/test_summary_dispatcher.py @@ -0,0 +1,222 @@ +"""Unit tests for SummaryDispatcher (best-effort event summarization). + +The OpenAI client is mocked; there is no network and no real ScyllaDB — the "db" is a fake +that records the CQL it was asked to execute. Covers the behaviors the design requires +(docs/plans/event-summarization.md §8): unique event -> UPDATE with the right key, disabled +/ keyless -> inert, summarizer error -> no write, and the min-chars gate. +""" + +import threading +from datetime import datetime, timezone +from uuid import uuid4 + +import pytest + +from argusAI.utils import summary_dispatcher as sd +from argusAI.utils.summarizer import SummarizationResult, SummarizerError + + +class FakeDB: + def __init__(self, config): + self.config = config + self.executed = [] + + def execute(self, query, params): + self.executed.append((query, params)) + return object() # real ScyllaConnection.execute returns a truthy ResultSet on success + + +class FakeSummarizer: + """Stands in for argusAI.utils.summarizer.Summarizer.""" + + instances = [] + + def __init__(self, *args, **kwargs): + self.calls = [] + FakeSummarizer.instances.append(self) + + def summarize(self, model, message, prompt=None, **kwargs): + self.calls.append((model, message, prompt)) + return SummarizationResult( + summary=f"SUMMARY[{message[:10]}]", + model=model, + prompt_tokens=100, + completion_tokens=20, + cached_tokens=0, + latency_ms=5.0, + ) + + +class ErroringSummarizer(FakeSummarizer): + def summarize(self, model, message, prompt=None, **kwargs): + raise SummarizerError("boom") + + +@pytest.fixture(autouse=True) +def _reset(): + FakeSummarizer.instances = [] + + +def _config(**over): + cfg = { + "EVENT_SUMMARIZATION_ENABLED": True, + "OPENAI_API_KEY": "test-key", + "OPENAI_SUMMARY_MODEL": "gpt-5-mini", + "EVENT_SUMMARIZATION_MAX_CONCURRENCY": 2, + } + cfg.update(over) + return cfg + + +def _dispatch_one(dispatcher, message="a fairly long event message with detail"): + run_id, ts = uuid4(), datetime.now(timezone.utc) + dispatcher.dispatch(run_id, "ERROR", ts, message) + dispatcher.shutdown() # drains in-flight tasks + return run_id, ts + + +def test_unique_event_writes_summary_with_right_key(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config()) + dispatcher = sd.SummaryDispatcher(db, db.config) + assert dispatcher.enabled + + run_id, ts = _dispatch_one(dispatcher, "database error: sstable corruption at offset 42") + + assert len(db.executed) == 1 + query, params = db.executed[0] + assert "UPDATE sct_event SET summary" in query + assert "WHERE run_id = ? AND severity = ? AND ts = ?" in query + summary, w_run, w_sev, w_ts = params + assert w_run == run_id and w_sev == "ERROR" and w_ts == ts + assert summary.startswith("SUMMARY[") + + +def test_disabled_is_inert(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config(EVENT_SUMMARIZATION_ENABLED=False)) + dispatcher = sd.SummaryDispatcher(db, db.config) + assert not dispatcher.enabled + _dispatch_one(dispatcher) + assert db.executed == [] + assert FakeSummarizer.instances == [] # no client constructed + + +def test_missing_key_disables_without_crashing(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config(OPENAI_API_KEY=None)) + dispatcher = sd.SummaryDispatcher(db, db.config) + assert not dispatcher.enabled + _dispatch_one(dispatcher) + assert db.executed == [] + + +def test_summarizer_error_leaves_summary_null(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", ErroringSummarizer) + db = FakeDB(_config()) + dispatcher = sd.SummaryDispatcher(db, db.config) + _dispatch_one(dispatcher) + assert db.executed == [] # failure => no write, summary stays null + + +def test_min_chars_gate_skips_short_events(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config(EVENT_SUMMARIZATION_MIN_CHARS=800)) + dispatcher = sd.SummaryDispatcher(db, db.config) + + _dispatch_one(dispatcher, "short message") # below threshold + assert db.executed == [] + + dispatcher2 = sd.SummaryDispatcher(db, db.config) + _dispatch_one(dispatcher2, "x" * 900) # above threshold + assert len(db.executed) == 1 + + +def test_empty_message_not_dispatched(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config()) + dispatcher = sd.SummaryDispatcher(db, db.config) + _dispatch_one(dispatcher, "") + assert db.executed == [] + + +def test_malformed_config_disables_without_crashing(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config(EVENT_SUMMARIZATION_MIN_CHARS="not-a-number")) + dispatcher = sd.SummaryDispatcher(db, db.config) # int() must not escape __init__ + assert not dispatcher.enabled + _dispatch_one(dispatcher) + assert db.executed == [] + + +def test_dispatch_swallows_submit_failure_and_releases_slot(monkeypatch): + """A submit failure (e.g. executor shut down) must never propagate into the embedding + path, and the acquired slot must be released so summarization is not wedged forever.""" + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config(EVENT_SUMMARIZATION_MAX_CONCURRENCY=1, EVENT_SUMMARIZATION_MAX_BACKLOG=4)) + dispatcher = sd.SummaryDispatcher(db, db.config) + + class BoomExecutor: + def submit(self, *args, **kwargs): + raise RuntimeError("cannot schedule new futures after shutdown") + + dispatcher._executor = BoomExecutor() + + for _ in range(10): # more than the 4 slots -> proves the slot is released each time + dispatcher.dispatch(uuid4(), "ERROR", datetime.now(timezone.utc), "long enough message") + + assert db.executed == [] + assert dispatcher._slots.acquire(blocking=False) # a slot is still free, not leaked + + +def test_counters_track_success(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + db = FakeDB(_config()) + dispatcher = sd.SummaryDispatcher(db, db.config) + _dispatch_one(dispatcher, "a sufficiently long event message worth summarizing") + assert (dispatcher._n_ok, dispatcher._n_failed, dispatcher._n_dropped) == (1, 0, 0) + + +def test_counters_track_failure(monkeypatch): + monkeypatch.setattr(sd, "Summarizer", ErroringSummarizer) + db = FakeDB(_config()) + dispatcher = sd.SummaryDispatcher(db, db.config) + _dispatch_one(dispatcher, "a sufficiently long event message worth summarizing") + assert (dispatcher._n_ok, dispatcher._n_failed, dispatcher._n_dropped) == (0, 1, 0) + + +def test_swallowed_db_write_counts_as_failure(monkeypatch): + # ScyllaConnection.execute swallows write errors and returns None; a null result must + # be treated as a failed persist, not logged/counted as a success. + monkeypatch.setattr(sd, "Summarizer", FakeSummarizer) + + class SwallowingDB(FakeDB): + def execute(self, query, params): + self.executed.append((query, params)) # records the write, then returns None like a swallowed failure + + db = SwallowingDB(_config()) + dispatcher = sd.SummaryDispatcher(db, db.config) + _dispatch_one(dispatcher, "a sufficiently long event message worth summarizing") + assert (dispatcher._n_ok, dispatcher._n_failed, dispatcher._n_dropped) == (0, 1, 0) + + +def test_backlog_full_is_dropped(monkeypatch): + gate = threading.Event() + + class BlockingSummarizer(FakeSummarizer): + def summarize(self, model, message, prompt=None, **kwargs): + gate.wait(timeout=5) # hold the slot until released + return super().summarize(model, message, prompt, **kwargs) + + monkeypatch.setattr(sd, "Summarizer", BlockingSummarizer) + db = FakeDB(_config(EVENT_SUMMARIZATION_MAX_CONCURRENCY=1, EVENT_SUMMARIZATION_MAX_BACKLOG=4)) + dispatcher = sd.SummaryDispatcher(db, db.config) + msg = "an event message long enough to pass the gate" + + for _ in range(4): # fill every slot (tasks block, holding them) + dispatcher.dispatch(uuid4(), "ERROR", datetime.now(timezone.utc), msg) + dispatcher.dispatch(uuid4(), "ERROR", datetime.now(timezone.utc), msg) # no slot -> dropped + + gate.set() + dispatcher._executor.shutdown(wait=True) # drain the 4 accepted tasks (no cancellation) + assert len(db.executed) == 4 diff --git a/argusAI/utils/embedding.py b/argusAI/utils/embedding.py new file mode 100644 index 000000000..8885f3af7 --- /dev/null +++ b/argusAI/utils/embedding.py @@ -0,0 +1,48 @@ +from pathlib import Path +from uuid import UUID + +from chromadb.utils.embedding_functions.onnx_mini_lm_l6_v2 import ONNXMiniLM_L6_V2 + +from argusAI.utils.event_message_sanitizer import MessageSanitizer + +_ZERO_UUID = UUID(int=0) + + +class BgeSmallEnEmbeddingModel(ONNXMiniLM_L6_V2): + """ + Compact English text embedding model by BAAI, released Sep 2023. + Trained on large-scale paired data with RetroMAE and contrastive learning. + Produces high-quality 384-dim embeddings, optimized for efficiency in semantic search, classification, and clustering. + """ + + MODEL_NAME: str = "bge-small-en-v1.5" + DOWNLOAD_PATH: Path = Path.home() / ".cache" / "chroma" / "onnx_models" / MODEL_NAME + EXTRACTED_FOLDER_NAME: str = "onnx" + ARCHIVE_FILENAME: str = "onnx.tar.gz" + MODEL_DOWNLOAD_URL: str = ( + "https://scylla-qa-public.s3.us-east-1.amazonaws.com/ArgusAI/bge-small-en-v1.5/onnx.tar.gz" + ) + _MODEL_SHA256: str = "e7d1743b0c08f55c687cff6af696683398682f9ab4fb3cad1be644ee5553a72d" + + +class EventEmbedder: + """The single place that turns an event message into an embedding: sanitize (strip + run-specific noise) then embed with BGE-small-en. Shared by the similarity worker and + the eval's similarity dedup so both produce identical vectors from identical inputs.""" + + def __init__(self, write_log: bool = True): + self.sanitizer = MessageSanitizer(write_log=write_log) + self.model = BgeSmallEnEmbeddingModel() + + def embed(self, message: str, run_id: UUID = _ZERO_UUID) -> list[float]: + sanitized = self.sanitizer.sanitize(run_id, message) + if not sanitized or not sanitized.strip(): + raise ValueError("Sanitized message is empty") + vectors = self.model([sanitized]) + if not vectors: + raise ValueError("Embedding generation returned empty result") + return vectors[0] + + def embed_many(self, messages: list[str], run_id: UUID = _ZERO_UUID) -> list: + sanitized = [self.sanitizer.sanitize(run_id, m) for m in messages] + return self.model(sanitized) diff --git a/argusAI/utils/event_message_sanitizer.py b/argusAI/utils/event_message_sanitizer.py index 536605729..1e53a113e 100644 --- a/argusAI/utils/event_message_sanitizer.py +++ b/argusAI/utils/event_message_sanitizer.py @@ -14,7 +14,7 @@ class MessageSanitizer: Sanitized messages are written to a file for further analysis. """ - def __init__(self): + def __init__(self, write_log: bool = True): self.event_pattern: Pattern = re.compile(r"Severity\.(ERROR|CRITICAL|WARNING|INFO)\)") self.event_id_pattern: Pattern = re.compile( r"(?:event_id=)?[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}" @@ -108,16 +108,19 @@ def __init__(self): self.remove_special_chars, self.normalize_whitespace, ] - os.makedirs("logs", exist_ok=True) - self.sanitized_messages_fp = open( - "logs/sanitized_messages_" + datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + ".log", "w" - ) + self.sanitized_messages_fp = None + if write_log: + os.makedirs("logs", exist_ok=True) + self.sanitized_messages_fp = open( + "logs/sanitized_messages_" + datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + ".log", "w" + ) def sanitize(self, run_id: UUID, message: str) -> str: result = message for sanitizer in self.sanitizers: result = sanitizer(result) - self.sanitized_messages_fp.write(f"{run_id}: {result}\n") + if self.sanitized_messages_fp is not None: + self.sanitized_messages_fp.write(f"{run_id}: {result}\n") return result def remove_preface(self, text: str) -> str: diff --git a/argusAI/utils/summarizer.py b/argusAI/utils/summarizer.py new file mode 100644 index 000000000..2bd7d7b6b --- /dev/null +++ b/argusAI/utils/summarizer.py @@ -0,0 +1,126 @@ +from __future__ import annotations + +import logging +import time +from dataclasses import dataclass +from typing import Any + +from argusAI.prompts import PRODUCTION_PROMPT_NAME, load_prompt + +LOGGER = logging.getLogger(__name__) + +DEFAULT_PROMPT = load_prompt(PRODUCTION_PROMPT_NAME) + + +@dataclass(frozen=True) +class SummarizationResult: + summary: str + model: str + prompt_tokens: int + completion_tokens: int + cached_tokens: int + latency_ms: float + + @property + def total_tokens(self) -> int: + return self.prompt_tokens + self.completion_tokens + + +class SummarizerError(RuntimeError): + pass + + +class Summarizer: + def __init__( + self, + api_key: str, + base_url: str | None = None, + timeout: float = 60.0, + max_retries: int = 5, + ): + if not api_key: + raise SummarizerError("Summarizer requires an API key") + try: + from openai import OpenAI # noqa: PLC0415 - lazy: openai is an optional ('ai-eval') dependency + except ImportError as exc: # pragma: no cover - dependency guard + raise SummarizerError( + "The 'openai' package is required for summarization. " + "Install it via the 'ai-eval' optional dependency group." + ) from exc + + client_kwargs: dict[str, Any] = { + "api_key": api_key, + "timeout": timeout, + "max_retries": max_retries, + } + if base_url: + client_kwargs["base_url"] = base_url + self._client = OpenAI(**client_kwargs) + + def summarize( + self, + model: str, + message: str, + prompt: str = DEFAULT_PROMPT, + **params: Any, + ) -> SummarizationResult: + if not message: + raise SummarizerError("Cannot summarize an empty message") + + started = time.monotonic() + try: + response = self._client.chat.completions.create( + model=model, + messages=[ + {"role": "system", "content": prompt}, + {"role": "user", "content": message}, + ], + **params, + ) + except Exception as exc: # noqa: BLE001 - provider raises a wide variety + raise SummarizerError(f"Summarization call failed for model {model}: {exc}") from exc + latency_ms = (time.monotonic() - started) * 1000.0 + + summary = (response.choices[0].message.content or "").strip() + if not summary: + raise SummarizerError(f"Model {model} returned an empty summary") + + usage = getattr(response, "usage", None) + prompt_tokens = getattr(usage, "prompt_tokens", 0) or 0 + completion_tokens = getattr(usage, "completion_tokens", 0) or 0 + cached_tokens = 0 + details = getattr(usage, "prompt_tokens_details", None) + if details is not None: + cached_tokens = getattr(details, "cached_tokens", 0) or 0 + + result = SummarizationResult( + summary=summary, + model=model, + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + cached_tokens=cached_tokens, + latency_ms=latency_ms, + ) + LOGGER.debug( + "Summarized with %s: %d->%d tokens (%d cached) in %.0fms", + model, + prompt_tokens, + completion_tokens, + cached_tokens, + latency_ms, + ) + return result + + def raw_completion(self, model: str, system: str, user: str, **params: Any) -> str: + try: + response = self._client.chat.completions.create( + model=model, + messages=[ + {"role": "system", "content": system}, + {"role": "user", "content": user}, + ], + **params, + ) + except Exception as exc: # noqa: BLE001 + raise SummarizerError(f"Completion call failed for model {model}: {exc}") from exc + return (response.choices[0].message.content or "").strip() diff --git a/argusAI/utils/summary_dispatcher.py b/argusAI/utils/summary_dispatcher.py new file mode 100644 index 000000000..3dfe508b4 --- /dev/null +++ b/argusAI/utils/summary_dispatcher.py @@ -0,0 +1,161 @@ +from __future__ import annotations + +import logging +import os +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone +from threading import BoundedSemaphore, Lock +from uuid import UUID + +from argusAI.prompts import load_prompt + +from .summarizer import DEFAULT_PROMPT, Summarizer, SummarizerError + +LOGGER = logging.getLogger(__name__) + +_SCT_EVENT_TABLE = "sct_event" +_STATS_LOG_EVERY = 50 # emit a rolling aggregate line every N completed summarizations + + +def _lag_seconds(ts: datetime) -> float: + """Seconds from the event's timestamp to now — the summarization lag (§6 metrics).""" + if ts.tzinfo is None: + ts = ts.replace(tzinfo=timezone.utc) + return max(0.0, (datetime.now(timezone.utc) - ts).total_seconds()) + + +def _resolve_prompt(config: dict) -> str: + inline = config.get("EVENT_SUMMARIZATION_PROMPT") + if inline: + return inline + version = config.get("EVENT_SUMMARIZATION_PROMPT_VERSION") or os.environ.get("EVENT_SUMMARIZATION_PROMPT_VERSION") + if version: + try: + return load_prompt(version) + except FileNotFoundError as exc: + LOGGER.warning("%s; falling back to the default prompt", exc) + return DEFAULT_PROMPT + + +class SummaryDispatcher: + def __init__(self, db, config: dict): + self._db = db + self.model = config.get("OPENAI_SUMMARY_MODEL", "gpt-5-mini") + self.prompt = _resolve_prompt(config) + self.min_chars = 0 + self._slots = BoundedSemaphore(1) + self._summarizer: Summarizer | None = None + self._executor: ThreadPoolExecutor | None = None + self.enabled = False + + # Aggregate counters (§6 metrics). Mutated from pool threads, so guard with a lock. + self._stats_lock = Lock() + self._n_ok = 0 + self._n_failed = 0 + self._n_dropped = 0 + self._n_since_log = 0 + + try: + if not config.get("EVENT_SUMMARIZATION_ENABLED", False): + raise ValueError("EVENT_SUMMARIZATION_ENABLED=false") + self.min_chars = int(config.get("EVENT_SUMMARIZATION_MIN_CHARS", 0)) + max_concurrency = int(config.get("EVENT_SUMMARIZATION_MAX_CONCURRENCY", 4)) + max_backlog = int(config.get("EVENT_SUMMARIZATION_MAX_BACKLOG", 1000)) + self._slots = BoundedSemaphore(max_backlog) + api_key = config.get("OPENAI_API_KEY") + if not api_key: + raise ValueError("OPENAI_API_KEY is missing") + self._summarizer = Summarizer(api_key=api_key, base_url=config.get("OPENAI_BASE_URL")) + self._executor = ThreadPoolExecutor(max_workers=max_concurrency, thread_name_prefix="event-summarizer") + except Exception as exc: # noqa: BLE001 - summarization setup must never break the embedding worker + LOGGER.info("Event summarization disabled: %s", exc) + return + + self.enabled = True + LOGGER.info( + "Event summarization enabled (model=%s, concurrency=%d, max_backlog=%d, min_chars=%d)", + self.model, + max_concurrency, + max_backlog, + self.min_chars, + ) + + def dispatch(self, run_id: UUID, severity: str, ts: datetime, message: str) -> None: + if not self.enabled or self._executor is None or not message: + return + if len(message) < self.min_chars: + return + if not self._slots.acquire(blocking=False): + self._bump("dropped") + LOGGER.warning("Summarization backlog full; dropping run_id=%s ts=%s", run_id, ts) + return + try: + self._executor.submit(self._summarize_and_store, run_id, severity, ts, message) + except Exception as exc: # noqa: BLE001 - dispatch must never disrupt the embedding path + self._slots.release() + LOGGER.warning("Could not dispatch summarization run_id=%s ts=%s: %s", run_id, ts, exc) + + def _summarize_and_store(self, run_id: UUID, severity: str, ts: datetime, message: str) -> None: + try: + result = self._summarizer.summarize(self.model, message, prompt=self.prompt) + query = f"UPDATE {_SCT_EVENT_TABLE} SET summary = ? WHERE run_id = ? AND severity = ? AND ts = ?" + # ScyllaConnection.execute swallows write failures and returns None; a null result + # means the summary never persisted, so don't count/log it as a success. + if self._db.execute(query, (result.summary, run_id, severity, ts)) is None: + raise SummarizerError("summary DB write failed (execute returned None)") + self._bump("ok") + LOGGER.info( + "Summarized run_id=%s severity=%s ts=%s: %d->%d chars, %d->%d tok (%d cached), %.0fms, lag=%.1fs", + run_id, + severity, + ts, + len(message), + len(result.summary), + result.prompt_tokens, + result.completion_tokens, + result.cached_tokens, + result.latency_ms, + _lag_seconds(ts), + ) + except SummarizerError as exc: + self._bump("failed") + LOGGER.warning("Summarization failed run_id=%s ts=%s: %s", run_id, ts, exc) + except Exception as exc: # noqa: BLE001 - a task must never crash a pool thread + self._bump("failed") + LOGGER.error("Summarize/store error run_id=%s ts=%s: %s", run_id, ts, exc, exc_info=True) + finally: + self._slots.release() + + def _bump(self, kind: str) -> None: + """Increment an aggregate counter and emit a rolling tally every _STATS_LOG_EVERY events.""" + with self._stats_lock: + if kind == "ok": + self._n_ok += 1 + elif kind == "failed": + self._n_failed += 1 + elif kind == "dropped": + self._n_dropped += 1 + self._n_since_log += 1 + due = self._n_since_log >= _STATS_LOG_EVERY + if due: + self._n_since_log = 0 + snapshot = (self._n_ok, self._n_failed, self._n_dropped) + if due: + self._log_stats(*snapshot) + + @staticmethod + def _log_stats(ok: int, failed: int, dropped: int) -> None: + LOGGER.info( + "Summarization totals: %d ok, %d failed, %d dropped (backlog full)", + ok, + failed, + dropped, + ) + + def shutdown(self) -> None: + if self._executor is not None: + self._executor.shutdown(wait=True, cancel_futures=True) + with self._stats_lock: + snapshot = (self._n_ok, self._n_failed, self._n_dropped) + self._log_stats(*snapshot) + LOGGER.info("Summary dispatcher shut down") diff --git a/argus_web.example.yaml b/argus_web.example.yaml index 690ce8be2..89bc698f0 100644 --- a/argus_web.example.yaml +++ b/argus_web.example.yaml @@ -98,3 +98,23 @@ CLOUDFLARE_ACCESS_AUD: your-application-aud-tag-from-cloudflare-dashboard ZEUS_SCHEMA: http ZEUS_HOST: example.com:80 ZEUS_TOKEN: your-token + +# Event summarization (argusAI worker). Disabled by default; read once at worker startup, +# so changing any of these requires a worker restart. See docs/plans/event-summarization.md. +EVENT_SUMMARIZATION_ENABLED: false +# OPENAI_API_KEY: your-openai-key # required only when summarization is enabled +# OPENAI_BASE_URL: https://api.openai.com/v1 # set for Azure / proxy / compatible endpoints +OPENAI_SUMMARY_MODEL: gpt-5-mini # winner of the evaluation sweep (argusAI/eval) +EVENT_SUMMARIZATION_MAX_CONCURRENCY: 4 # bounded executor / rate-limit guard +# Max events waiting to be summarized before new ones are dropped. Decoupled from +# concurrency so a burst is buffered, not lost; bounds memory if the API stalls. +EVENT_SUMMARIZATION_MAX_BACKLOG: 1000 +# Skip events shorter than this many chars (summarizing them expands rather than compresses). +# 0 = summarize everything; ~800 is the data-backed production value (argusAI/eval §7). +EVENT_SUMMARIZATION_MIN_CHARS: 0 +# Pick which versioned prompt to use (a stem from argusAI/prompts/, e.g. v7_summary). +# Also settable via the EVENT_SUMMARIZATION_PROMPT_VERSION env var. Defaults to the winner. +# EVENT_SUMMARIZATION_PROMPT_VERSION: v7_summary +# Or supply the full prompt text inline, which overrides the version selection above: +# EVENT_SUMMARIZATION_PROMPT: | +# ...your prompt... diff --git a/pyproject.toml b/pyproject.toml index 3dbe08537..43b072a05 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -78,6 +78,7 @@ dev = [ ] ai = [ "chromadb >= 1.0.15", + "openai >= 1.60.0", ] [tool.ruff] From 4f4b18a53669d6bf5745d4ad8f6624805cef5ddd Mon Sep 17 00:00:00 2001 From: Dusan Malusev Date: Thu, 23 Jul 2026 17:18:11 +0200 Subject: [PATCH 2/4] feature(argusAI): event summarization evaluation harness Add an offline harness that sweeps prompts and models over real SCT events, scores each summary with an LLM judge (coverage/faithfulness/conciseness), tracks token-based cost, compression and latency, and renders an HTML report. Optionally collapses near-duplicate events through the worker's embedder so the sweep sees the canonical set production would summarize. Regenerates uv.lock for the new openai/tiktoken/chromadb dependencies. --- argusAI/eval/.gitignore | 5 + argusAI/eval/README.md | 103 +++ argusAI/eval/__init__.py | 14 + argusAI/eval/__main__.py | 130 ++++ argusAI/eval/baseline.py | 141 ++++ argusAI/eval/baseline/baseline.json | 60 ++ argusAI/eval/baseline/events.json | 622 ++++++++++++++++ argusAI/eval/config.example.yaml | 69 ++ argusAI/eval/config.py | 132 ++++ argusAI/eval/dedup.py | 60 ++ argusAI/eval/events_source.py | 205 ++++++ argusAI/eval/harness.py | 184 +++++ argusAI/eval/judge.py | 106 +++ argusAI/eval/metrics.py | 103 +++ argusAI/eval/pricing.py | 65 ++ argusAI/eval/prompts.py | 7 + argusAI/eval/report.py | 358 ++++++++++ argusAI/eval/results.py | 73 ++ docs/plans/MASTER.md | 4 +- docs/plans/event-summarization.md | 384 ++++++++++ docs/plans/progress.json | 12 +- pyproject.toml | 6 + uv.lock | 1029 ++++++++++++++++++++++++++- 23 files changed, 3864 insertions(+), 8 deletions(-) create mode 100644 argusAI/eval/.gitignore create mode 100644 argusAI/eval/README.md create mode 100644 argusAI/eval/__init__.py create mode 100644 argusAI/eval/__main__.py create mode 100644 argusAI/eval/baseline.py create mode 100644 argusAI/eval/baseline/baseline.json create mode 100644 argusAI/eval/baseline/events.json create mode 100644 argusAI/eval/config.example.yaml create mode 100644 argusAI/eval/config.py create mode 100644 argusAI/eval/dedup.py create mode 100644 argusAI/eval/events_source.py create mode 100644 argusAI/eval/harness.py create mode 100644 argusAI/eval/judge.py create mode 100644 argusAI/eval/metrics.py create mode 100644 argusAI/eval/pricing.py create mode 100644 argusAI/eval/prompts.py create mode 100644 argusAI/eval/report.py create mode 100644 argusAI/eval/results.py create mode 100644 docs/plans/event-summarization.md diff --git a/argusAI/eval/.gitignore b/argusAI/eval/.gitignore new file mode 100644 index 000000000..f4661c100 --- /dev/null +++ b/argusAI/eval/.gitignore @@ -0,0 +1,5 @@ +# Local eval working files — never commit outputs, working configs, or anything key-adjacent +out/ +out_*/ +config.yaml +*.local.yaml diff --git a/argusAI/eval/README.md b/argusAI/eval/README.md new file mode 100644 index 000000000..1eb59fb68 --- /dev/null +++ b/argusAI/eval/README.md @@ -0,0 +1,103 @@ +# Event Summarization — evaluation harness + +Offline harness that answers the two questions PR #1016 asked before rollout: + +1. **Which model?** — the cheapest one whose summaries stay faithful and lose no + information a triager (or Zeus) needs. +2. **Is the prompt any good?** — iterate it on real events until the output is right. + +It pulls real SCT `ERROR`/`CRITICAL` events from Argus (via the `argus` CLI), +summarizes each with several candidate models under a configurable prompt, scores every +summary against the **original** event with a frontier judge model, and renders a +self-contained HTML report: a quality-vs-cost decision graph plus every summary shown +side-by-side with its source so a human can verify the judge. + +Nothing is hard-coded — **model and API key are configurable** (mandatory for +production), as is the prompt, the judge, and the pricing table. + +## Setup + +```bash +pip install -e '.[ai-eval]' # installs openai + PyYAML +export OPENAI_API_KEY=sk-... # key comes from the env, never the config file +``` + +The `argus` CLI must be authenticated (`argus auth`) — the harness shells out to it. + +## Run + +```bash +# 1. edit argusAI/eval/config.example.yaml: set run_ids/test_id, models, prompts, pricing +cp argusAI/eval/config.example.yaml argusAI/eval/config.yaml + +# 2. (optional) collect events first, without spending any API tokens, and inspect them +python -m argusAI.eval --config argusAI/eval/config.yaml --fetch-only + +# 3. full sweep: summarize × judge × render report +python -m argusAI.eval --config argusAI/eval/config.yaml --open + +# re-render the HTML from an existing results.json (no API calls) +python -m argusAI.eval --config argusAI/eval/config.yaml --report-only --open +``` + +Outputs land in `output_dir` (default `argusAI/eval/out/`): + +| File | What | +|------|------| +| `events.json` | the deduplicated events that were evaluated (reusable via `events_file`) | +| `results.json` | every (event × model × prompt) cell: summary, tokens, cost, latency, judge score | +| `report.html` | the presentable graph + per-event side-by-side summaries | + +## Config + +See `config.example.yaml` — commented in full. The key knobs: + +- `models` — list of candidates; each `params` block is forwarded verbatim to the API + call (`reasoning_effort`, `temperature`, `max_completion_tokens`, …). +- `prompts` — names from `prompts.py`; list several to A/B them on the same events. +- `judge_model` / `judge_enabled` — the frontier scorer (Opus-class / GPT-5-class). +- `pricing` — USD per 1M tokens; **the defaults are placeholders**, set real numbers or + the cost axis is meaningless (unknown models are flagged in the report, never silent). + +## Regression baseline + +`out/` is gitignored, so a run's evidence lives only on your laptop. To keep a durable +reference that future prompt/model changes are checked against, freeze the current winner +into the tracked `baseline/` dir: + +```bash +# seed a baseline (from a fresh sweep, or from an existing results.json without spending tokens) +python -m argusAI.eval --config ... --write-baseline argusAI/eval/baseline +python -m argusAI.eval --config ... --report-only --write-baseline argusAI/eval/baseline + +# later: re-run on the *frozen* events and check for regressions (exit 1 on FAIL) +python -m argusAI.eval --config ... --baseline argusAI/eval/baseline +``` + +`baseline/` holds two committed files: `events.json` (the frozen input set — `--baseline` +forces the run onto it so inputs are identical) and `baseline.json` (per-`(model,prompt)` +mean scores). Comparison is **aggregate + tolerance**, not exact-match, because the +summarizer and judge are non-deterministic. A series **FAILs** only when faithfulness or +coverage drops more than `--tolerance` points (default 3) — the two axes that mean +information was dropped or invented. Conciseness, cost, and latency are shown as deltas but +never fail the check; new hallucinations or dropped-critical items are flagged inline. + +Deliberately not wired into CI: each run spends real OpenAI tokens and the judge is +non-deterministic, so it's a manual pre-change gate, not an automated one. + +## Iterating the prompt + +`prompts.py` holds `PRODUCTION` (the current winner) and `BASELINE` (the naive one-liner, +kept as an A/B control). To try a new idea, **add a new named entry** rather than editing +`PRODUCTION` in place, list both in `prompts:`, and the report compares them head-to-head on +identical events — so a regression is visible, not lost. If the challenger wins, promote its +text into `PRODUCTION` here **and** into `argusAI/utils/summarizer.py`'s `DEFAULT_PROMPT` +(the two are kept byte-identical), which becomes the production `EVENT_SUMMARIZATION_PROMPT` +default. Older experiments aren't carried in this file — git history and the saved `out/` +reports are the record. + +## Relation to production + +`argusAI/utils/summarizer.py` (the `Summarizer` class) is shared: this harness and the +production worker call it identically, so a summary you approve here is byte-for-byte what +the worker will store for the same `(model, prompt)`. diff --git a/argusAI/eval/__init__.py b/argusAI/eval/__init__.py new file mode 100644 index 000000000..530233f6f --- /dev/null +++ b/argusAI/eval/__init__.py @@ -0,0 +1,14 @@ +"""Offline evaluation harness for event summarization. + +Extracts real SCT ERROR/CRITICAL events (via the ``argus`` CLI), summarizes each +with several candidate models under a configurable prompt, scores the summaries for +information preservation with a frontier judge model, and renders a comparison graph +plus a per-event side-by-side HTML report. + +This is the harness the design doc (docs/plans/event-summarization.md §7) requires to +pick ``OPENAI_SUMMARY_MODEL`` and to validate the prompt before rollout. Run it as:: + + python -m argusAI.eval --config argusAI/eval/config.example.yaml + +See ``argusAI/eval/README.md``. +""" diff --git a/argusAI/eval/__main__.py b/argusAI/eval/__main__.py new file mode 100644 index 000000000..ac00675ac --- /dev/null +++ b/argusAI/eval/__main__.py @@ -0,0 +1,130 @@ +"""CLI: run the evaluation sweep and render the report. + + python -m argusAI.eval --config argusAI/eval/config.example.yaml + +Sub-modes: + --fetch-only collect events into out/events.json and stop (no API calls) + --report-only re-render the HTML from an existing out/results.json (no API calls) + --write-baseline DIR freeze the current run's aggregate scores as a regression baseline + --baseline DIR re-run on the frozen set and check for regressions (exit 1 on FAIL) + +Everything else (models, prompts, events, judge) comes from the YAML config; only the +API key comes from the environment (OPENAI_API_KEY by default). +""" + +from __future__ import annotations + +import argparse +import json +import logging +import sys +import webbrowser +from pathlib import Path + +from .baseline import BASELINE_FILE, EVENTS_FILE, compare, load_baseline, render_table, save_baseline +from .config import EvalConfig +from .events_source import EventFetcher, save_events +from .harness import EvalHarness +from .report import report_from_file, write_report + +_DEFAULT_TOLERANCE = 3.0 + + +def _write_baseline(results: dict, out_dir: Path, tolerance: float) -> None: + """Persist baseline.json plus the frozen events beside it, so a later --baseline run + scores the identical inputs.""" + path = save_baseline(results, out_dir, tolerance) + (out_dir / EVENTS_FILE).write_text(json.dumps(results.get("events", []), indent=2), encoding="utf-8") + print(f"Baseline: {path} (+ {out_dir / EVENTS_FILE}, {results.get('num_events')} events)") + + +def _run_baseline_check(cfg: EvalConfig, base_dir: Path, tolerance: float | None, report_path: Path) -> int: + """Re-run the sweep on the frozen event set and diff aggregate scores against the stored + baseline. Exit non-zero if a gated axis regressed beyond tolerance.""" + base_path, events_path = base_dir / BASELINE_FILE, base_dir / EVENTS_FILE + if not base_path.exists() or not events_path.exists(): + print(f"Baseline incomplete: need both {base_path} and {events_path}.", file=sys.stderr) + return 1 + baseline = load_baseline(base_path) + tol = tolerance if tolerance is not None else baseline.get("tolerance", _DEFAULT_TOLERANCE) + cfg.events_file = events_path # regression check must score the identical frozen inputs + results = EvalHarness(cfg).run() + write_report(results, report_path) + rows, ok = compare(results, baseline, tol) + print("\n" + render_table(rows, baseline, tol)) + print(f"\nReport: {report_path}\n{'PASS — no regressions' if ok else 'FAIL — regressions above'}") + return 0 if ok else 1 + + +def _setup_logging(verbose: bool) -> None: + logging.basicConfig( + level=logging.DEBUG if verbose else logging.INFO, + format="%(asctime)s %(levelname)s %(name)s: %(message)s", + datefmt="%H:%M:%S", + ) + logging.getLogger("httpx").setLevel(logging.WARNING) + logging.getLogger("openai").setLevel(logging.WARNING) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(prog="python -m argusAI.eval", description=__doc__) + parser.add_argument("--config", required=True, help="path to eval YAML config") + parser.add_argument("--fetch-only", action="store_true", help="only collect events, no API calls") + parser.add_argument("--report-only", action="store_true", help="only re-render report from results.json") + parser.add_argument("--write-baseline", metavar="DIR", help="freeze this run's scores as a regression baseline") + parser.add_argument("--baseline", metavar="DIR", help="re-run on the frozen set and check for regressions") + parser.add_argument( + "--tolerance", type=float, default=None, + help=f"allowed faithfulness/coverage drop in points (default: baseline's, else {_DEFAULT_TOLERANCE})", + ) + parser.add_argument("--open", action="store_true", help="open the HTML report in a browser when done") + parser.add_argument("-v", "--verbose", action="store_true") + args = parser.parse_args(argv) + _setup_logging(args.verbose) + + cfg = EvalConfig.from_yaml(args.config) + out_dir = cfg.output_dir + results_path = out_dir / "results.json" + report_path = out_dir / "report.html" + + if args.report_only: + if not results_path.exists(): + print(f"No results at {results_path}; run the sweep first.", file=sys.stderr) + return 1 + report_from_file(results_path, report_path) + print(f"Report: {report_path}") + if args.write_baseline: # seed a baseline from an existing run, spending no tokens + results = json.loads(results_path.read_text(encoding="utf-8")) + _write_baseline(results, Path(args.write_baseline), args.tolerance or _DEFAULT_TOLERANCE) + if args.open: + webbrowser.open(report_path.resolve().as_uri()) + return 0 + + if args.baseline: + return _run_baseline_check(cfg, Path(args.baseline), args.tolerance, report_path) + + if args.fetch_only: + fetcher = EventFetcher(argus_cli=cfg.argus_cli, no_cache=cfg.no_cache) + events = fetcher.collect( + run_ids=cfg.run_ids, + test_id=cfg.test_id, + test_run_limit=cfg.test_run_limit, + max_events=cfg.max_events, + ) + save_events(events, out_dir / "events.json") + print(f"Collected {len(events)} events -> {out_dir / 'events.json'}") + return 0 if events else 2 + + harness = EvalHarness(cfg) # validates the API key up front + results = harness.run() + write_report(results, report_path) + print(f"\nResults: {results_path}\nReport: {report_path}") + if args.write_baseline: + _write_baseline(results, Path(args.write_baseline), args.tolerance or _DEFAULT_TOLERANCE) + if args.open: + webbrowser.open(report_path.resolve().as_uri()) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/argusAI/eval/baseline.py b/argusAI/eval/baseline.py new file mode 100644 index 000000000..5b69db172 --- /dev/null +++ b/argusAI/eval/baseline.py @@ -0,0 +1,141 @@ +"""Regression baseline: freeze the current winner's aggregate scores, then check a later +run against them. + +Why aggregate-and-tolerance instead of a golden results.json: both the summarizer and the +judge are non-deterministic, so cost, latency, and judge scores drift run to run. An +exact-match baseline would fail on noise and get ignored. Instead we store the per-series +means (from ``metrics.aggregate_series``) and, on compare, fail only when the two axes that +mean *information was lost* — faithfulness and coverage — drop by more than ``tolerance`` +points. Conciseness, cost, and latency are tradeoffs: shown as deltas, never a failure. + +Comparison is only meaningful on identical inputs, so ``--baseline`` forces the run onto the +frozen ``events.json`` stored beside ``baseline.json``. +""" + +from __future__ import annotations + +import json +from dataclasses import asdict +from pathlib import Path + +from .metrics import SeriesStats, aggregate_series + +BASELINE_FILE = "baseline.json" +EVENTS_FILE = "events.json" + +# Judge axes that gate the verdict — a drop here means dropped/invented information. +_GATED = ("avg_faithfulness", "avg_coverage") +# Field-aware rounding for the stored file. Judge means round hard (1 dp) so sub-point noise +# doesn't churn the committed baseline; cost is ~$0.002/cell so it needs 6 dp or it flattens +# to zero. Default 1 dp for anything not listed. +_ROUND = { + "avg_coverage": 1, "avg_faithfulness": 1, "avg_conciseness": 1, "avg_overall": 1, + "avg_compression": 3, "avg_cost": 6, "avg_latency_ms": 0, "avg_completion_tokens": 1, +} + + +def _round(stats: SeriesStats) -> dict: + d = asdict(stats) + return {k: (round(v, _ROUND.get(k, 1)) if isinstance(v, float) else v) for k, v in d.items()} + + +def serialize_baseline(results: dict, tolerance: float) -> dict: + """Build the committed baseline document from a results dict (fresh or loaded).""" + series, multi_prompt = aggregate_series(results) + return { + "generated_at": results.get("generated_at"), + "judge_model": results.get("judge_model"), + "num_events": results.get("num_events"), + "tolerance": tolerance, + "multi_prompt": multi_prompt, + "series": [_round(s) for s in sorted(series, key=lambda s: s.key)], + } + + +def save_baseline(results: dict, out_dir: Path, tolerance: float) -> Path: + out_dir.mkdir(parents=True, exist_ok=True) + path = out_dir / BASELINE_FILE + path.write_text(json.dumps(serialize_baseline(results, tolerance), indent=2), encoding="utf-8") + return path + + +def load_baseline(path: Path) -> dict: + return json.loads(path.read_text(encoding="utf-8")) + + +def _fmt_delta(cur: float, base: float) -> str: + d = cur - base + return f"{cur:5.1f} ({d:+.1f})" + + +def compare(results: dict, baseline: dict, tolerance: float) -> tuple[list[dict], bool]: + """Diff a fresh run against a stored baseline, series by series (matched on key). + + Returns (rows, ok). ok is False if any shared series regressed on a gated axis, or a + baseline series is missing from the run. New series (in the run, not the baseline) are + reported but never fail — you can't regress against a baseline that doesn't exist yet. + """ + current = {s.key: s for s in aggregate_series(results)[0]} + base_by_key = {b["key"]: b for b in baseline.get("series", [])} + rows: list[dict] = [] + ok = True + + for key in sorted(base_by_key): + base = base_by_key[key] + cur = current.get(key) + if cur is None: + rows.append({"key": key, "status": "MISSING", "detail": "series absent from this run"}) + ok = False + continue + regressions = [] + for axis in _GATED: + drop = base[axis] - getattr(cur, axis) + if drop > tolerance: + regressions.append(f"{axis.removeprefix('avg_')} -{drop:.1f}") + # Dropped-critical / hallucination counts are informational, but a new hallucination + # where there was none is worth shouting about even inside tolerance. + halluc_delta = cur.total_hallucinations - base["total_hallucinations"] + dropped_delta = cur.total_dropped - base["total_dropped"] + row = { + "key": key, + "status": "PASS" if not regressions else "FAIL", + "faith": _fmt_delta(cur.avg_faithfulness, base["avg_faithfulness"]), + "cover": _fmt_delta(cur.avg_coverage, base["avg_coverage"]), + "concise": _fmt_delta(cur.avg_conciseness, base["avg_conciseness"]), + "cost": _fmt_delta(cur.avg_cost * 100, base["avg_cost"] * 100), # cents/cell + "halluc_delta": halluc_delta, + "dropped_delta": dropped_delta, + "detail": ", ".join(regressions), + } + if regressions: + ok = False + rows.append(row) + + for key in sorted(set(current) - set(base_by_key)): + rows.append({"key": key, "status": "NEW", "detail": "no baseline entry (not gated)"}) + return rows, ok + + +def render_table(rows: list[dict], baseline: dict, tolerance: float) -> str: + """Human-readable delta table for the terminal. Numbers are current (Δ vs baseline).""" + head = ( + f"Baseline: {baseline.get('num_events')} events, judge={baseline.get('judge_model')}, " + f"generated {baseline.get('generated_at')}\nTolerance: {tolerance:.1f} pts on faithfulness & coverage " + f"(cost in cents/cell; hall/drop deltas informational)\n" + ) + lines = [head, f"{'series':<34}{'faith':>13}{'cover':>13}{'concise':>13}{'cost':>13} verdict"] + lines.append("-" * 104) + for r in rows: + if r["status"] in ("MISSING", "NEW"): + lines.append(f"{r['key']:<34}{'':>52} {r['status']}: {r['detail']}") + continue + flags = "" + if r["halluc_delta"] > 0: + flags += f" +{r['halluc_delta']}halluc" + if r["dropped_delta"] > 0: + flags += f" +{r['dropped_delta']}drop" + verdict = r["status"] + (f" ({r['detail']})" if r["detail"] else "") + flags + lines.append( + f"{r['key']:<34}{r['faith']:>13}{r['cover']:>13}{r['concise']:>13}{r['cost']:>13} {verdict}" + ) + return "\n".join(lines) diff --git a/argusAI/eval/baseline/baseline.json b/argusAI/eval/baseline/baseline.json new file mode 100644 index 000000000..b6eaae479 --- /dev/null +++ b/argusAI/eval/baseline/baseline.json @@ -0,0 +1,60 @@ +{ + "generated_at": "2026-07-21T13:47:49.825381+00:00", + "judge_model": "gpt-5", + "num_events": 62, + "tolerance": 3.0, + "multi_prompt": true, + "series": [ + { + "key": "gpt-5-mini \u00b7 v5_surgical", + "model": "gpt-5-mini", + "prompt_name": "v5_surgical", + "n": 62, + "errors": 0, + "avg_coverage": 97.0, + "avg_faithfulness": 99.7, + "avg_conciseness": 93.0, + "avg_overall": 97.5, + "avg_cost": 0.002149, + "avg_compression": 0.692, + "avg_latency_ms": 10519.0, + "avg_completion_tokens": 851.1, + "total_dropped": 16, + "total_hallucinations": 2 + }, + { + "key": "gpt-5-mini \u00b7 v6_summary", + "model": "gpt-5-mini", + "prompt_name": "v6_summary", + "n": 62, + "errors": 0, + "avg_coverage": 86.6, + "avg_faithfulness": 86.5, + "avg_conciseness": 84.8, + "avg_overall": 86.3, + "avg_cost": 0.001408, + "avg_compression": 0.902, + "avg_latency_ms": 7806.0, + "avg_completion_tokens": 488.9, + "total_dropped": 173, + "total_hallucinations": 74 + }, + { + "key": "gpt-5-mini \u00b7 v7_summary", + "model": "gpt-5-mini", + "prompt_name": "v7_summary", + "n": 62, + "errors": 0, + "avg_coverage": 86.0, + "avg_faithfulness": 99.0, + "avg_conciseness": 87.1, + "avg_overall": 91.4, + "avg_cost": 0.001993, + "avg_compression": 0.451, + "avg_latency_ms": 7095.0, + "avg_completion_tokens": 443.4, + "total_dropped": 173, + "total_hallucinations": 6 + } + ] +} \ No newline at end of file diff --git a/argusAI/eval/baseline/events.json b/argusAI/eval/baseline/events.json new file mode 100644 index 000000000..0bf2d80ec --- /dev/null +++ b/argusAI/eval/baseline/events.json @@ -0,0 +1,622 @@ +[ + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "CRITICAL", + "event_type": "ClusterHealthValidatorEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-2", + "ts": "2026-05-23T13:50:01.121Z", + "message": "(ClusterHealthValidatorEvent Severity.CRITICAL) period_type=one-time event_id=51b8419a-9772-475c-87cb-309622d0087d: type=NodeStatus node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-2 error=Current node Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-2 [35.227.10.26 | 10.142.0.112] (Type: n2-highmem-16) (rack: RACK2). Node Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 [34.75.113.93 | 10.142.0.116] (Type: n2-highmem-16) (rack: RACK0) (not target node) status is DN", + "repeats": 3, + "message_chars": 505 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5 [35.237.47.140 | 10.142.0.115] (Type: n2-highmem-16) (rack: RACK2)", + "ts": "2026-05-22T12:23:45.147Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=b5455f84-32a8-4dba-b986-f7d054aedb18 duration=3h4m3s: nemesis_name=AbortRepairMonkey target_node=Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5 [35.237.47.140 | 10.142.0.115] (Type: n2-highmem-16) (rack: RACK2) errors=Failed on waiting until task: repair/8bf83451-b568-473b-8f71-527388c8cc19 reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/8bf83451-b568-473b-8f71-527388c8cc19 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 71, in wait_for\n res = retry(func, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 475, in __call__\n do = self.iter(retry_state=retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 376, in iter\n result = action(retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 418, in exc_check\n raise retry_exc.reraise()\n ~~~~~~~~~~~~~~~~~^^\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 186, in reraise\n raise self\ntenacity.RetryError: RetryError[]\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 374, in wait_for_status\n return wait.wait_for(\n ~~~~~~~~~~~~~^\n func=self.is_status_in_list,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n ...<5 lines>...\n timeout=timeout,\n ^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 87, in wait_for\n raise raising_exc from ex\nsdcm.exceptions.WaitForTimeoutError: Wait for: Waiting until task: repair/8bf83451-b568-473b-8f71-527388c8cc19 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1970, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 451, in disrupt\n self.runner.disrupt_abort_repair()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 3250, in disrupt_abort_repair\n self.run_repair()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2170, in run_repair\n self.run_repair_manager(ignore_down_hosts=ignore_down_hosts, timeout=timeout)\n ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2140, in run_repair_manager\n task_final_status = mgr_task.wait_and_get_final_status(timeout=timeout) # timeout is 24 hours\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 431, in wait_and_get_final_status\n res = self.wait_for_status(list_status=list_final_status, timeout=timeout, step=step)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 384, in wait_for_status\n raise WaitForTimeoutError(\n ...<3 lines>...\n ) from ex\nsdcm.exceptions.WaitForTimeoutError: Failed on waiting until task: repair/8bf83451-b568-473b-8f71-527388c8cc19 reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/8bf83451-b568-473b-8f71-527388c8cc19 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n", + "repeats": 0, + "message_chars": 4032 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5", + "ts": "2026-05-22T15:40:11.735Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=ac9f5fec-3236-4813-b34b-142ecd73813f: type=DATABASE_ERROR regex=(^ERROR|!\\s*?ERR).*\\[shard.*\\] line_number=72398 node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5\n2026-05-22T15:40:11.735 longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5 !ERR | scylla[4326] [shard 12: mt] sstable - Could not create SSTable component /var/lib/scylla/data/scylla_bench/view_test-0ef5f2b055bf11f1a3131ae0b5e923f7/ms-3h0m_17hs_0hd002sprksc97plh3-big-Digest.crc32. Found exception: std::_Nested_exception (https://cloudkms.googleapis.com/v1/projects/sct-project-1/locations/us-east1/keyRings/demo-keyring/cryptoKeys/scylla-key-3:decrypt): std::system_error (error system:32, sendmsg: Broken pipe)", + "repeats": 0, + "message_chars": 788 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 [34.75.113.93 | 10.142.0.116] (Type: n2-highmem-16) (rack: RACK0)", + "ts": "2026-05-22T17:20:27.782Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=1bd042e2-243d-4875-9812-bac87862bc69 duration=3h48m43s: nemesis_name=MgmtCorruptThenRepair target_node=Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 [34.75.113.93 | 10.142.0.116] (Type: n2-highmem-16) (rack: RACK0) errors=Failed on waiting until task: repair/145e73cc-2557-4409-9b4e-1584a72d2f20 reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/145e73cc-2557-4409-9b4e-1584a72d2f20 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 71, in wait_for\n res = retry(func, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 475, in __call__\n do = self.iter(retry_state=retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 376, in iter\n result = action(retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 418, in exc_check\n raise retry_exc.reraise()\n ~~~~~~~~~~~~~~~~~^^\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 186, in reraise\n raise self\ntenacity.RetryError: RetryError[]\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 374, in wait_for_status\n return wait.wait_for(\n ~~~~~~~~~~~~~^\n func=self.is_status_in_list,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n ...<5 lines>...\n timeout=timeout,\n ^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 87, in wait_for\n raise raising_exc from ex\nsdcm.exceptions.WaitForTimeoutError: Wait for: Waiting until task: repair/145e73cc-2557-4409-9b4e-1584a72d2f20 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1970, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 442, in disrupt\n self.runner.disrupt_mgmt_corrupt_then_repair()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 3168, in disrupt_mgmt_corrupt_then_repair\n self.run_repair_manager()\n ~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2140, in run_repair_manager\n task_final_status = mgr_task.wait_and_get_final_status(timeout=timeout) # timeout is 24 hours\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 431, in wait_and_get_final_status\n res = self.wait_for_status(list_status=list_final_status, timeout=timeout, step=step)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 384, in wait_for_status\n raise WaitForTimeoutError(\n ...<3 lines>...\n ) from ex\nsdcm.exceptions.WaitForTimeoutError: Failed on waiting until task: repair/145e73cc-2557-4409-9b4e-1584a72d2f20 reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/145e73cc-2557-4409-9b4e-1584a72d2f20 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n", + "repeats": 0, + "message_chars": 3831 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5", + "ts": "2026-05-22T19:19:53.659Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=ac9f5fec-3236-4813-b34b-142ecd73813f: type=DATABASE_ERROR regex=(^ERROR|!\\s*?ERR).*\\[shard.*\\] line_number=123291 node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5\n2026-05-22T19:19:53.659 longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5 !ERR | scylla[4326] [shard 4: mt] sstable - Could not create SSTable component /var/lib/scylla/data/scylla_bench/test-16039e9055ba11f188dd373976fd8be4/ms-3h0m_1hnt_1satc2a2zd43qqfdh3-big-Digest.crc32. Found exception: std::_Nested_exception (https://cloudkms.googleapis.com/v1/projects/sct-project-1/locations/us-east1/keyRings/demo-keyring/cryptoKeys/scylla-key-3:decrypt): std::system_error (error system:32, sendmsg: Broken pipe)", + "repeats": 0, + "message_chars": 784 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "SoftTimeoutEvent", + "node": "", + "ts": "2026-05-22T23:22:17.607Z", + "message": "(SoftTimeoutEvent Severity.ERROR) period_type=one-time event_id=7cf5919b-c60d-4630-8fa2-d3e89ba202d5 during_nemesis=CreateIndexNemesis, source=SoftTimeout message=operation 'CREATE_INDEX' is finished and took 19681.5s (soft timeout was set to 14400s)\nTraceback (most recent call last):\n File \"/usr/local/lib/python3.14/threading.py\", line 1043, in _bootstrap\n self._bootstrap_inner()\n File \"/usr/local/lib/python3.14/threading.py\", line 1081, in _bootstrap_inner\n self._context.run(self.run)\n File \"/usr/local/lib/python3.14/threading.py\", line 1023, in run\n self._target(*self._args, **self._kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/sct_events/decorators.py\", line 26, in wrapper\n return func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 434, in run\n self.call_next_nemesis()\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2108, in call_next_nemesis\n self.execute_nemesis(nemesis=next(self.infinite_cycle))\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1970, in execute_nemesis\n nemesis.disrupt()\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 899, in disrupt\n self.runner.disrupt_create_index()\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 5322, in disrupt_create_index\n with adaptive_timeout(\n File \"/usr/local/lib/python3.14/contextlib.py\", line 148, in __exit__\n next(self.gen)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/adaptive_timeouts/__init__.py\", line 286, in adaptive_timeout\n SoftTimeoutEvent(operation=operation.name, soft_timeout=soft_timeout, duration=duration).publish_or_dump()\n", + "repeats": 0, + "message_chars": 1721 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "FailedResultEvent", + "node": "", + "ts": "2026-05-22T23:22:17.874Z", + "message": "(FailedResultEvent Severity.ERROR) period_type=one-time event_id=c55b7b89-066a-4940-8fc9-88b301841ae2 during_nemesis=CreateIndexNemesis: message=Argus validation failed for the result in CREATE_INDEX - Timeout Statistics. Please check the 'Results' tab for more details.", + "repeats": 0, + "message_chars": 270 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6", + "ts": "2026-05-23T01:13:38.790Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=21704484-3045-46e8-8a7a-bc95e365ec66: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=123179 node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6\n2026-05-23T01:13:38.790 longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 !WARNING | scylla[28477] [shard 12:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x355ff4e 0x355fb91 0x1d10658 0x35d5cf7 0x181e275 0x2445033 0x1813066 0x2370258 0x236f43b 0x1ea652d 0x1822c19 0x1822d53 0x18211c4 0x5897638 0x5855cca /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::__new_allocator::allocate(unsigned long, void const*) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/new_allocator.h:151\n (inlined by) std::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ./build/release/seastar/./seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ./build/release/seastar/./seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ./build/release/seastar/./seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(seastar::task*&&) at ./build/release/seastar/./seastar/include/seastar/core/circular_buffer.hh:404\n (inlined by) seastar::reactor::add_task(seastar::task*) at ./build/release/seastar/./seastar/src/core/reactor.cc:3129\n (inlined by) seastar::schedule(seastar::task*) at ./build/release/seastar/./seastar/src/core/reactor.cc:3834\n (inlined by) void seastar::internal::promise_base::make_ready<(seastar::internal::promise_base::urgent)0>() at ./build/release/seastar/./seastar/src/core/future.cc:125\nvoid seastar::internal::promise_base::set_exception_impl(std::__exception_ptr::exception_ptr&&) at ./build/release/seastar/./seastar/include/seastar/core/future.hh:812\n (inlined by) seastar::internal::promise_base::set_exception(std::__exception_ptr::exception_ptr&&) at ./build/release/seastar/./seastar/include/seastar/core/future.hh:830\n (inlined by) seastar::internal::promise_base::set_exception(std::__exception_ptr::exception_ptr const&) at ./build/release/seastar/./seastar/include/seastar/core/future.hh:834\n (inlined by) seastar::promise::set_exception(std::__exception_ptr::exception_ptr const&) at ./build/release/seastar/./seastar/include/seastar/core/future.hh:996\n (inlined by) seastar::rpc::connection::withdraw(boost::intrusive::list_iterator, (boost::intrusive::link_mode_type)2, boost::intrusive::dft_tag, 1u>, false>, std::__exception_ptr::exception_ptr) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:283\nseastar::rpc::connection::stop_send_loop(std::__exception_ptr::exception_ptr) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:209\nseastar::rpc::client::loop(seastar::rpc::client_options, seastar::socket_address const&, seastar::socket_address const&) (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1041\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/cache/63085/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 0, + "message_chars": 7705 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-3 [34.139.165.95 | 10.142.0.113] (Type: n2-highmem-16) (rack: RACK0)", + "ts": "2026-05-23T10:51:53.937Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=4d0df60a-748a-4777-b215-4cc67694055e duration=9h38m50s: nemesis_name=IsolateNodeWithProcessSignalNemesis target_node=Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-3 [34.139.165.95 | 10.142.0.113] (Type: n2-highmem-16) (rack: RACK0) errors=Failed on waiting until task: repair/f508d36c-2562-430d-b7c0-623e77aedb2f reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/f508d36c-2562-430d-b7c0-623e77aedb2f reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 71, in wait_for\n res = retry(func, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 475, in __call__\n do = self.iter(retry_state=retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 376, in iter\n result = action(retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 418, in exc_check\n raise retry_exc.reraise()\n ~~~~~~~~~~~~~~~~~^^\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 186, in reraise\n raise self\ntenacity.RetryError: RetryError[]\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 374, in wait_for_status\n return wait.wait_for(\n ~~~~~~~~~~~~~^\n func=self.is_status_in_list,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n ...<5 lines>...\n timeout=timeout,\n ^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 87, in wait_for\n raise raising_exc from ex\nsdcm.exceptions.WaitForTimeoutError: Wait for: Waiting until task: repair/f508d36c-2562-430d-b7c0-623e77aedb2f reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1970, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 975, in disrupt\n self.runner.disrupt_refuse_connection_with_send_sigstop_signal_to_scylla_on_banned_node()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 5672, in disrupt_refuse_connection_with_send_sigstop_signal_to_scylla_on_banned_node\n self._refuse_connection_from_banned_node(use_iptables=False)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 5721, in _refuse_connection_from_banned_node\n ExitStack() as stack,\n ~~~~~~~~~^^\n File \"/usr/local/lib/python3.14/contextlib.py\", line 619, in __exit__\n raise exc\n File \"/usr/local/lib/python3.14/contextlib.py\", line 604, in __exit__\n if cb(*exc_details):\n ~~^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 5730, in _finalizer\n self._remove_node_add_node(\n ~~~~~~~~~~~~~~~~~~~~~~~~~~^\n verification_node=working_node,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n node_to_remove=self.target_node,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n remove_node_host_id=target_host_id,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 3823, in _remove_node_add_node\n self.run_repair(ignore_down_hosts=True)\n ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2170, in run_repair\n self.run_repair_manager(ignore_down_hosts=ignore_down_hosts, timeout=timeout)\n ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2140, in run_repair_manager\n task_final_status = mgr_task.wait_and_get_final_status(timeout=timeout) # timeout is 24 hours\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 431, in wait_and_get_final_status\n res = self.wait_for_status(list_status=list_final_status, timeout=timeout, step=step)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 384, in wait_for_status\n raise WaitForTimeoutError(\n ...<3 lines>...\n ) from ex\nsdcm.exceptions.WaitForTimeoutError: Failed on waiting until task: repair/f508d36c-2562-430d-b7c0-623e77aedb2f reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/f508d36c-2562-430d-b7c0-623e77aedb2f reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n", + "repeats": 0, + "message_chars": 5284 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 [34.75.113.93 | 10.142.0.116] (Type: n2-highmem-16) (rack: RACK0)", + "ts": "2026-05-23T11:34:17.411Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=a0025106-cf3c-4b97-aa6d-b9324c71bfdc duration=11m47s: nemesis_name=MgmtRepair target_node=Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 [34.75.113.93 | 10.142.0.116] (Type: n2-highmem-16) (rack: RACK0) errors=Task: repair/c0bdb476-b571-45fe-85f6-eefe033984fd final status is: ERROR.\nTask progress string: Run:\t\tb1ef3f54-569a-11f1-b4d7-42010a8e007b\nStatus:\t\tERROR\nCause:\t\tanother task is running\nStart time:\t23 May 26 11:29:43 UTC\nEnd time:\t23 May 26 11:29:43 UTC\nDuration:\t0s\nProgress:\t-\n\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1970, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 430, in disrupt\n self.runner.disrupt_mgmt_repair_cli()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 3162, in disrupt_mgmt_repair_cli\n self.run_repair_manager()\n ~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2147, in run_repair_manager\n raise ScyllaManagerError(\n ...<2 lines>...\n )\nsdcm.mgmt.common.ScyllaManagerError: Task: repair/c0bdb476-b571-45fe-85f6-eefe033984fd final status is: ERROR.\nTask progress string: Run:\t\tb1ef3f54-569a-11f1-b4d7-42010a8e007b\nStatus:\t\tERROR\nCause:\t\tanother task is running\nStart time:\t23 May 26 11:29:43 UTC\nEnd time:\t23 May 26 11:29:43 UTC\nDuration:\t0s\nProgress:\t-\n\n\n", + "repeats": 0, + "message_chars": 1688 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5 [35.237.47.140 | 10.142.0.115] (Type: n2-highmem-16) (rack: RACK2)", + "ts": "2026-05-23T12:34:27.392Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=54402aad-79b3-4057-a35c-07b256db051c duration=18m37s: nemesis_name=RestartThenRepairNodeMonkey target_node=Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-5 [35.237.47.140 | 10.142.0.115] (Type: n2-highmem-16) (rack: RACK2) errors=Task: repair/5e42253e-823c-4ef3-9961-4af3a6b7aa7e final status is: ERROR.\nTask progress string: Run:\t\t1995d3a1-56a3-11f1-b4da-42010a8e007b\nStatus:\t\tERROR\nCause:\t\tanother task is running\nStart time:\t23 May 26 12:29:53 UTC\nEnd time:\t23 May 26 12:29:53 UTC\nDuration:\t0s\nProgress:\t-\n\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1970, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 118, in disrupt\n self.runner.disrupt_restart_then_repair_node()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 787, in disrupt_restart_then_repair_node\n self.run_repair()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2170, in run_repair\n self.run_repair_manager(ignore_down_hosts=ignore_down_hosts, timeout=timeout)\n ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2147, in run_repair_manager\n raise ScyllaManagerError(\n ...<2 lines>...\n )\nsdcm.mgmt.common.ScyllaManagerError: Task: repair/5e42253e-823c-4ef3-9961-4af3a6b7aa7e final status is: ERROR.\nTask progress string: Run:\t\t1995d3a1-56a3-11f1-b4da-42010a8e007b\nStatus:\t\tERROR\nCause:\t\tanother task is running\nStart time:\t23 May 26 12:29:53 UTC\nEnd time:\t23 May 26 12:29:53 UTC\nDuration:\t0s\nProgress:\t-\n\n\n", + "repeats": 1, + "message_chars": 1974 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6", + "ts": "2026-05-23T13:25:10.253Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=94dc4850-58bb-4019-a856-94a845b9b8cb: type=DISK_ERROR regex=storage_service - .*due to I\\/O errors.*Disk error: std::system_error line_number=530111 node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6\n2026-05-23T13:25:10.253 longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 !ERR | scylla[28477] [shard 9:comp] storage_service - Shutting down communications due to I/O errors until operator intervention: Disk error: std::system_error (error system:61, No data available)", + "repeats": 0, + "message_chars": 555 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6", + "ts": "2026-05-23T13:25:10.275Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=ac9f5fec-3236-4813-b34b-142ecd73813f: type=DATABASE_ERROR regex=(^ERROR|!\\s*?ERR).*\\[shard.*\\] line_number=530127 node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6\n2026-05-23T13:25:10.275 longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 !ERR | scylla[28477] [shard 9:comp] compaction_manager - Compaction task 0x609003109400 for table scylla_bench.test compaction_group=0 [0x60900457c540]: failed due to storage io error: Storage I/O error: 61: No data available: stopping", + "repeats": 0, + "message_chars": 559 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6", + "ts": "2026-05-23T13:47:17.037Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=5370ccdf-87ee-4559-83e8-3c5b2a46bdb1: type=RUNTIME_ERROR regex=std::runtime_error line_number=536108 node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6\nstd::runtime_error (The gossiper is not ready yet)", + "repeats": 1, + "message_chars": 277 + }, + { + "run_id": "d57aaf15-40a2-42a0-b450-8e269e75b121", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-05-23T14:48:13.813Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=34380396-6119-47f1-b6e5-f3e79ab69f01, source=LargePartitionLongevityTest.test_large_partition_longevity()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (ClusterHealthValidatorEvent Severity.CRITICAL) period_type=one-time event_id=51b8419a-9772-475c-87cb-309622d0087d: type=NodeStatus node=longevity-large-partitions-200k-pks-db-node-d57aaf15-0-2 error=Current node Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-2 [35.227.10.26 | 10.142.0.112] (Type: n2-highmem-16) (rack: RACK2). Node Node longevity-large-partitions-200k-pks-db-node-d57aaf15-0-6 [34.75.113.93 | 10.142.0.116] (Type: n2-highmem-16) (rack: RACK0) (not target node) status is DN\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1612 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "CRITICAL", + "event_type": "CassandraStressLogEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-5b879df8-0-1 [34.86.28.65 | 10.150.0.36] (Type: e2-standard-2) (rack: c)", + "ts": "2026-06-23T02:01:03.226Z", + "message": "(CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=dcfa313d-bc6e-4cd3-9b90-eb8300b30eb9 during_nemesis=GrowShrinkClusterNemesis,AddDropColumnMonkey: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=124018 node=Node raft-double-cluster-size-with-schem-loader-node-5b879df8-0-1 [34.86.28.65 | 10.150.0.36] (Type: e2-standard-2) (rack: c)\n[2026-06-23 02:01:03.134] java.io.IOException: Operation x10 on key(s) [4d503250334d36353331]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n", + "repeats": 0, + "message_chars": 640 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "CRITICAL", + "event_type": "CassandraStressEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-5b879df8-0-1 [34.86.28.65 | 10.150.0.36] (Type: e2-standard-2) (rack: c)", + "ts": "2026-06-23T02:01:09.521Z", + "message": "(CassandraStressEvent Severity.CRITICAL) period_type=end event_id=dcfa313d-bc6e-4cd3-9b90-eb8300b30eb9 during_nemesis=GrowShrinkClusterNemesis,AddDropColumnMonkey duration=10h12m30s: node=Node raft-double-cluster-size-with-schem-loader-node-5b879df8-0-1 [34.86.28.65 | 10.150.0.36] (Type: e2-standard-2) (rack: c)\nstress_cmd=cassandra-stress write cl=QUORUM duration=720m no-warmup -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=3) compaction(strategy=LeveledCompactionStrategy)' -mode cql3 native -rate threads=40 -pop 'dist=uniform(1..20971520)' -col 'n=FIXED(10) size=FIXED(512)' -log interval=5\nerrors:\n\nStress command completed with bad status 1: Failed to connect over JMX; not collecting these stats\ncom.datastax.driver.core.exceptions.WriteTimeoutException: Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)", + "repeats": 0, + "message_chars": 917 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-2", + "ts": "2026-06-22T14:23:08.774Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=03ad79b6-ce08-4bae-a4f9-89d504109223: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=6683 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-2\n2026-06-22T14:23:08.774 raft-double-cluster-size-with-schem-db-node-5b879df8-0-2 !WARNING | scylla[5212] [shard 0:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x36459bd 0x3645301 0x1e08548 0x57d47f7 0x180fd8b 0x47abab0 0x1b50ee1 0x1b4dcca 0x1b4c1e5 0x2743a59 0x1819689 0x18197c3 0x181b194 0x2aafc68 0x2ab0339 0x2aafd7b 0x2aac5c4 0x2aae2ec /opt/scylladb/libreloc/libc.so.6+0x35b4 /opt/scylladb/libreloc/libc.so.6+0x3667 0x36f5184\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\nstd::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::reactor::run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3245\nseastar::app_template::run_deprecated(int, char**, std::function&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:266\nseastar::app_template::run(int, char**, std::function ()>&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:160\nscylla_main(int, char**) at ./main.cc:821\nstd::function::operator()(int, char**) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) main at ./main.cc:2835\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\n__libc_start_call_main at ??:0\n__libc_start_main@GLIBC_2.2.5 at ??:0\n_start at ??:0\n\n", + "repeats": 12, + "message_chars": 61560 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-3", + "ts": "2026-06-22T17:47:25.430Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=03ad79b6-ce08-4bae-a4f9-89d504109223: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=61971 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-3\n2026-06-22T17:47:25.430 raft-double-cluster-size-with-schem-db-node-5b879df8-0-3 !WARNING | scylla[5201] [shard 10:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x36459bd 0x3645301 0x1e08548 0x57d47f7 0x180fd8b 0x47abab0 0x1b50ee1 0x1b4dcca 0x1b4c1e5 0x2743a59 0x1819689 0x18197c3 0x181b194 0x581db28 0x57dbd5a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\nstd::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 8, + "message_chars": 62340 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-5", + "ts": "2026-06-22T18:59:31.334Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=03ad79b6-ce08-4bae-a4f9-89d504109223 during_nemesis=GrowShrinkClusterNemesis: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=32905 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-5\n2026-06-22T18:59:31.334 raft-double-cluster-size-with-schem-db-node-5b879df8-0-5 !WARNING | scylla[5217] [shard 4:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x36459bd 0x3645301 0x1e08548 0x57d47f7 0x180fd8b 0x47abab0 0x1b50ee1 0x1b4dcca 0x1b4c1e5 0x2743a59 0x1819689 0x18197c3 0x181b194 0x581db28 0x57dbd5a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\nstd::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 11, + "message_chars": 62380 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-5", + "ts": "2026-06-22T20:31:38.886Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=03ad79b6-ce08-4bae-a4f9-89d504109223 during_nemesis=GrowShrinkClusterNemesis: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=38826 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-5\n2026-06-22T20:31:38.886 raft-double-cluster-size-with-schem-db-node-5b879df8-0-5 !WARNING | scylla[5217] [shard 8:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x36459bd 0x3645301 0x1e08548 0x57d47f7 0x180fd8b 0x47abab0 0x1b50ee1 0x1b4dcca 0x1b4c1e5 0x2743a59 0x1819689 0x18197c3 0x181b194 0x581db28 0x57dbd5a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\nstd::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 10, + "message_chars": 62380 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-5", + "ts": "2026-06-22T20:41:13.323Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=c5e60187-b2cc-4b07-8896-510acc23b75e: type=REACTOR_STALLED regex=Reactor stalled line_number=47829 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-5 known_issue=https://github.com/scylladb/scylladb/issues/8828\n2026-06-22T20:41:13.323 raft-double-cluster-size-with-schem-db-node-5b879df8-0-5 !INFO | scylla[5217] Reactor stalled for 65 ms on shard 0, in scheduling group sl:default. Backtrace: 0x2b8c27c 0x2b8bf56 /opt/scylladb/libreloc/libc.so.6+0x1a28f 0x180e5b6 0x1aa5e20 0x1aa14aa 0x1aa058e 0x1aa0232 0x181d517 0x20065e5 0x2005a68 /opt/scylladb/libreloc/libc.so.6+0xf375b /opt/scylladb/libreloc/libc.so.6+0xf3cfb 0x27e598a 0x473a36b 0x47456bf 0x4278e5a 0x18196e6 0x18197c3 0x181b194 0x2aafc68 0x2ab0339 0x2aafd7b 0x2aac5c4 0x2aae2ec /opt/scylladb/libreloc/libc.so.6+0x35b4 /opt/scylladb/libreloc/libc.so.6+0x3667 0x36f5184\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::backtrace_buffer::append_backtrace_oneline()::'lambda'(seastar::frame)&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::backtrace_buffer::append_backtrace_oneline() at ./build/release/seastar/./seastar/src/core/reactor.cc:822\n (inlined by) seastar::print_with_backtrace(seastar::backtrace_buffer&, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:849\nseastar::internal::cpu_stall_detector::generate_trace() at ./build/release/seastar/./seastar/src/core/reactor.cc:1495\n (inlined by) seastar::internal::cpu_stall_detector::maybe_report() at ./build/release/seastar/./seastar/src/core/reactor.cc:1230\n (inlined by) seastar::internal::cpu_stall_detector::on_signal() at ./build/release/seastar/./seastar/src/core/reactor.cc:1250\n (inlined by) seastar::reactor::block_notifier(int) at ./build/release/seastar/./seastar/src/core/reactor.cc:1564\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\n?? at ??:0\nutils::uleb64_express_encode_impl(char*&, unsigned long, unsigned long) at ././utils/vle.hh:73\n (inlined by) void utils::uleb64_express_encode(char*&, unsigned int, unsigned long, unsigned long, T&&, T0&&) at ././utils/vle.hh:82\n (inlined by) logalloc::region_impl::object_descriptor::encode(char*&, unsigned long, unsigned long) const at ./utils/logalloc.cc:1687\n (inlined by) logalloc::region_impl::alloc_small(logalloc::region_impl::object_descriptor const&, unsigned int, unsigned long) at ./utils/logalloc.cc:1771\nlogalloc::region_impl::compact_segment_locked(logalloc::segment*, logalloc::segment_descriptor&)::'lambda'(logalloc::region_impl::object_descriptor const*, void*, unsigned long)::operator()(logalloc::region_impl::object_descriptor const*, void*, unsigned long) const at ./utils/logalloc.cc:1945\n (inlined by) void logalloc::region_impl::for_each_live(logalloc::segment*, T&&) at ./utils/logalloc.cc:1791\n (inlined by) logalloc::region_impl::compact_segment_locked(logalloc::segment*, logalloc::segment_descriptor&) at ./utils/logalloc.cc:1944\nlogalloc::region_impl::compact_segment(logalloc::segment*, logalloc::segment_descriptor&) at ./utils/logalloc.cc:2293\n (inlined by) logalloc::segment_pool::compact_segment(logalloc::segment*) at ./utils/logalloc.cc:2919\n (inlined by) logalloc::segment_pool::reclaim_segments(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:1277\nlogalloc::tracker::impl::reclaim_locked(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2693\n (inlined by) logalloc::tracker::impl::reclaim(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2663\nlogalloc::tracker::reclaim(unsigned long) at ./utils/logalloc.cc:606\n (inlined by) logalloc::tracker::reclaim(seastar::memory::reclaimer::request) at ./utils/logalloc.cc:2405\n (inlined by) logalloc::tracker::tracker()::$_0::operator()(seastar::memory::reclaimer::request) const at ./utils/logalloc.cc:594\n (inlined by) seastar::memory::reclaiming_result std::__invoke_impl(std::__invoke_other, logalloc::tracker::tracker()::$_0&, seastar::memory::reclaimer::request&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, seastar::memory::reclaiming_result>::type std::__invoke_r(logalloc::tracker::tracker()::$_0&, seastar::memory::reclaimer::request&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&, seastar::memory::reclaimer::request&&) (.llvm.16105586666665603352) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()(seastar::memory::reclaimer::request) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::memory::reclaimer::do_reclaim(unsigned long) at ./build/release/seastar/./seastar/include/seastar/core/memory.hh:238\n (inlined by) seastar::memory::cpu_pages::run_reclaimers(seastar::memory::reclaimer_scope, unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1357\n (inlined by) seastar::memory::cpu_pages::find_and_unlink_span_reclaiming(unsigned int) at ./build/release/seastar/./seastar/src/core/memory.cc:808\n (inlined by) seastar::memory::cpu_pages::allocate_large_and_trim(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:833\nseastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:940\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) __libc_malloc at ./build/release/seastar/./seastar/src/core/memory.cc:2263\n__vsyslog_internal at ??:0\nsyslog at ??:0\nseastar::logger::do_log(seastar::log_level, seastar::logger::log_writer&) at ./build/release/seastar/./seastar/src/util/log.cc:378\nvoid seastar::logger::log const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::log_level, seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at ././seastar/include/seastar/util/log.hh:263\nvoid seastar::logger::info const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at ././seastar/include/seastar/util/log.hh:359\n (inlined by) service::prepare_column_family_update_announcement(service::storage_proxy&, seastar::lw_shared_ptr, std::vector>, long) (.resume) at ./service/migration_manager.cc:605\nstd::__n4861::coroutine_handle>::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base>::promise_type::run_and_dispose() at ././seastar/include/seastar/core/coroutine.hh:129\nseastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::reactor::run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3245\nseastar::app_template::run_deprecated(int, char**, std::function&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:266\nseastar::app_template::run(int, char**, std::function ()>&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:160\nscylla_main(int, char**) at ./main.cc:821\nstd::function::operator()(int, char**) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) main at ./main.cc:2835\n__libc_start_call_main at ??:0\n__libc_start_main@GLIBC_2.2.5 at ??:0\n_start at ??:0\n\n", + "repeats": 1, + "message_chars": 10459 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-4", + "ts": "2026-06-22T23:09:22.669Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=03ad79b6-ce08-4bae-a4f9-89d504109223 during_nemesis=GrowShrinkClusterNemesis: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=52649 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-4\n2026-06-22T23:09:22.669 raft-double-cluster-size-with-schem-db-node-5b879df8-0-4 !WARNING | scylla[5234] [shard 10:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x36459bd 0x3645301 0x1e08548 0x57d47f7 0x180fd8b 0x47abab0 0x1b50ee1 0x1b4dcca 0x1b4c1e5 0x2743a59 0x1819689 0x18197c3 0x181b194 0x581db28 0x57dbd5a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\nstd::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 2, + "message_chars": 62380 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-7", + "ts": "2026-06-23T01:06:39.735Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=03ad79b6-ce08-4bae-a4f9-89d504109223 during_nemesis=GrowShrinkClusterNemesis: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=14857 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-7\n2026-06-23T01:06:39.735 raft-double-cluster-size-with-schem-db-node-5b879df8-0-7 !WARNING | scylla[5255] [shard 13:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x36459bd 0x3645301 0x1e08548 0x57d47f7 0x180fd8b 0x47abab0 0x47abc9c 0x47abed4 0x47abe49 0x18196e6 0x18197c3 0x181b194 0x581db28 0x57dbd5a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'()::operator()() const at ./service/storage_proxy.cc:1957\n (inlined by) seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>::operator()(seastar::future&&) && at ././seastar/include/seastar/core/future.hh:1672\nseastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const::'lambda'()::operator()() const at ././seastar/include/seastar/core/future.hh:1552\n (inlined by) void seastar::futurize>::satisfy_with_result_of::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const::'lambda'()>(seastar::internal::promise_base_with_type&&, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ././seastar/include/seastar/core/future.hh:2015\nseastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const at ././seastar/include/seastar/core/future.hh:1551\n (inlined by) seastar::continuation, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>, seastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&), void>::run_and_dispose() at ././seastar/include/seastar/core/future.hh:742\nseastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 3, + "message_chars": 14758 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-5b879df8-0-3", + "ts": "2026-06-23T02:03:15.738Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=c5e60187-b2cc-4b07-8896-510acc23b75e: type=REACTOR_STALLED regex=Reactor stalled line_number=110858 node=raft-double-cluster-size-with-schem-db-node-5b879df8-0-3 known_issue=https://github.com/scylladb/scylladb/issues/8828\n2026-06-23T02:03:15.738 raft-double-cluster-size-with-schem-db-node-5b879df8-0-3 !INFO | scylla[5201] Reactor stalled for 65 ms on shard 0, in scheduling group sl:default. Backtrace: 0x2b8c27c 0x2b8bf56 /opt/scylladb/libreloc/libc.so.6+0x1a28f 0x180e5c8 0x1aa5e20 0x1aa14aa 0x1aa058e 0x1aa0232 0x181d517 0x20065e5 0x2f68eba 0x592299b 0x27eef2e 0x27ef18d /opt/scylladb/libreloc/libfmt.so.11+0xe7ec /opt/scylladb/libreloc/libfmt.so.11+0x10409 0x3145080 0x3144481 /opt/scylladb/libreloc/libfmt.so.11+0xe7ec /opt/scylladb/libreloc/libfmt.so.11+0x10409 0x27e5af5 0x473a437 0x27e5948 0x473a36b 0x47456bf 0x4278e5a 0x18196e6 0x18197c3 0x181b194 0x2aafc68 0x2ab0339 0x2aafd7b 0x2aac5c4 0x2aae2ec /opt/scylladb/libreloc/libc.so.6+0x35b4 /opt/scylladb/libreloc/libc.so.6+0x3667 0x36f5184\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::backtrace_buffer::append_backtrace_oneline()::'lambda'(seastar::frame)&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::backtrace_buffer::append_backtrace_oneline() at ./build/release/seastar/./seastar/src/core/reactor.cc:822\n (inlined by) seastar::print_with_backtrace(seastar::backtrace_buffer&, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:849\nseastar::internal::cpu_stall_detector::generate_trace() at ./build/release/seastar/./seastar/src/core/reactor.cc:1495\n (inlined by) seastar::internal::cpu_stall_detector::maybe_report() at ./build/release/seastar/./seastar/src/core/reactor.cc:1230\n (inlined by) seastar::internal::cpu_stall_detector::on_signal() at ./build/release/seastar/./seastar/src/core/reactor.cc:1250\n (inlined by) seastar::reactor::block_notifier(int) at ./build/release/seastar/./seastar/src/core/reactor.cc:1564\n/app/cache/40830/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\n?? at ??:0\nutils::uleb64_express_encode_impl(char*&, unsigned long, unsigned long) at ././utils/vle.hh:75\n (inlined by) void utils::uleb64_express_encode(char*&, unsigned int, unsigned long, unsigned long, T&&, T0&&) at ././utils/vle.hh:82\n (inlined by) logalloc::region_impl::object_descriptor::encode(char*&, unsigned long, unsigned long) const at ./utils/logalloc.cc:1687\n (inlined by) logalloc::region_impl::alloc_small(logalloc::region_impl::object_descriptor const&, unsigned int, unsigned long) at ./utils/logalloc.cc:1771\nlogalloc::region_impl::compact_segment_locked(logalloc::segment*, logalloc::segment_descriptor&)::'lambda'(logalloc::region_impl::object_descriptor const*, void*, unsigned long)::operator()(logalloc::region_impl::object_descriptor const*, void*, unsigned long) const at ./utils/logalloc.cc:1945\n (inlined by) void logalloc::region_impl::for_each_live(logalloc::segment*, T&&) at ./utils/logalloc.cc:1791\n (inlined by) logalloc::region_impl::compact_segment_locked(logalloc::segment*, logalloc::segment_descriptor&) at ./utils/logalloc.cc:1944\nlogalloc::region_impl::compact_segment(logalloc::segment*, logalloc::segment_descriptor&) at ./utils/logalloc.cc:2293\n (inlined by) logalloc::segment_pool::compact_segment(logalloc::segment*) at ./utils/logalloc.cc:2919\n (inlined by) logalloc::segment_pool::reclaim_segments(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:1277\nlogalloc::tracker::impl::reclaim_locked(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2693\n (inlined by) logalloc::tracker::impl::reclaim(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2663\nlogalloc::tracker::reclaim(unsigned long) at ./utils/logalloc.cc:606\n (inlined by) logalloc::tracker::reclaim(seastar::memory::reclaimer::request) at ./utils/logalloc.cc:2405\n (inlined by) logalloc::tracker::tracker()::$_0::operator()(seastar::memory::reclaimer::request) const at ./utils/logalloc.cc:594\n (inlined by) seastar::memory::reclaiming_result std::__invoke_impl(std::__invoke_other, logalloc::tracker::tracker()::$_0&, seastar::memory::reclaimer::request&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, seastar::memory::reclaiming_result>::type std::__invoke_r(logalloc::tracker::tracker()::$_0&, seastar::memory::reclaimer::request&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&, seastar::memory::reclaimer::request&&) (.llvm.16105586666665603352) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()(seastar::memory::reclaimer::request) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::memory::reclaimer::do_reclaim(unsigned long) at ./build/release/seastar/./seastar/include/seastar/core/memory.hh:238\n (inlined by) seastar::memory::cpu_pages::run_reclaimers(seastar::memory::reclaimer_scope, unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1357\n (inlined by) seastar::memory::cpu_pages::find_and_unlink_span_reclaiming(unsigned int) at ./build/release/seastar/./seastar/src/core/memory.cc:808\n (inlined by) seastar::memory::cpu_pages::allocate_large_and_trim(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:833\nseastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:940\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new[](unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2505\nseastar::internal::log_buf::realloc_buffer_and_append(char) at ./build/release/seastar/./seastar/src/util/log.cc:141\nseastar::internal::log_buf::inserter_iterator::operator=(char) at ././seastar/include/seastar/util/log-impl.hh:77\n (inlined by) fmt::v11::detail::iterator_buffer::flush() at /usr/include/fmt/base.h:1890\n (inlined by) fmt::v11::detail::iterator_buffer::grow(fmt::v11::detail::buffer&, unsigned long) at /usr/include/fmt/base.h:1882\nfmt::v11::detail::buffer::try_reserve(unsigned long) at /usr/include/fmt/base.h:1813\n (inlined by) void fmt::v11::detail::buffer::append(char const*, char const*) at /usr/include/fmt/base.h:1832\n (inlined by) fmt::v11::basic_appender fmt::v11::detail::copy, 0>(char const*, char const*, fmt::v11::basic_appender) at /usr/include/fmt/base.h:2043\n (inlined by) fmt::v11::basic_appender fmt::v11::detail::write>(fmt::v11::basic_appender, fmt::v11::basic_string_view, fmt::v11::format_specs const&)::'lambda'(fmt::v11::basic_appender)::operator()(fmt::v11::basic_appender) const at /usr/include/fmt/format.h:2136\n (inlined by) fmt::v11::basic_appender fmt::v11::detail::write_padded, fmt::v11::basic_appender fmt::v11::detail::write>(fmt::v11::basic_appender, fmt::v11::basic_string_view, fmt::v11::format_specs const&)::'lambda'(fmt::v11::basic_appender)>(fmt::v11::basic_appender, fmt::v11::format_specs const&, unsigned long, unsigned long, fmt::v11::basic_appender fmt::v11::detail::write>(fmt::v11::basic_appender, fmt::v11::basic_string_view, fmt::v11::format_specs const&)::'lambda'(fmt::v11::basic_appender)&&) at /usr/include/fmt/format.h:1645\n (inlined by) fmt::v11::basic_appender fmt::v11::detail::write>(fmt::v11::basic_appender, fmt::v11::basic_string_view, fmt::v11::format_specs const&) at /usr/include/fmt/format.h:2133\n (inlined by) fmt::v11::basic_appender fmt::v11::detail::write>(fmt::v11::basic_appender, fmt::v11::basic_string_view, fmt::v11::format_specs const&, fmt::v11::detail::locale_ref) at /usr/include/fmt/format.h:2142\n (inlined by) decltype(fp0.out()) fmt::v11::detail::native_formatter, char, (fmt::v11::detail::type)13>::format(fmt::v11::basic_string_view const&, fmt::v11::context&) const at /usr/include/fmt/format.h:3647\n (inlined by) auto fmt::v11::formatter, char, void>::format(seastar::basic_sstring const&, fmt::v11::context&) const at ././seastar/include/seastar/core/sstring.hh:888\n (inlined by) void fmt::v11::detail::value::format_custom, fmt::v11::formatter, char, void>>(void*, fmt::v11::parse_context&, fmt::v11::context&) at /usr/include/fmt/base.h:2275\n/app/cache/40830/scylla/libreloc/libfmt.so.11: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=ba5a1c5ee9391b4c6c08d91d7e052a313f780e48, stripped\n\n?? at ??:0\nfmt::v11::detail::vformat_to(fmt::v11::detail::buffer&, fmt::v11::basic_string_view, fmt::v11::basic_format_args, fmt::v11::detail::locale_ref) at ??:0\nstd::remove_cv&>::type>::type fmt::v11::vformat_to&, 0>(fmt::v11::basic_appender&, fmt::v11::basic_string_view, fmt::v11::basic_format_args) at /usr/include/fmt/base.h:2837\n (inlined by) std::remove_cv&>::type>::type fmt::v11::format_to&, seastar::basic_sstring const&, seastar::basic_sstring const&, long const&, 0>(fmt::v11::basic_appender&, fmt::v11::fstring const&, seastar::basic_sstring const&, long const&>::t, seastar::basic_sstring const&, seastar::basic_sstring const&, long const&) at /usr/include/fmt/base.h:2856\n (inlined by) fmt::v11::formatter::format(schema const&, fmt::v11::context&) const at ./schema/schema.cc:921\nvoid fmt::v11::detail::value::format_custom>(void*, fmt::v11::parse_context&, fmt::v11::context&) at /usr/include/fmt/base.h:2275\n?? at ??:0\nfmt::v11::detail::vformat_to(fmt::v11::detail::buffer&, fmt::v11::basic_string_view, fmt::v11::basic_format_args, fmt::v11::detail::locale_ref) at ??:0\nstd::remove_cv::type>::type fmt::v11::vformat_to(seastar::internal::log_buf::inserter_iterator&, fmt::v11::basic_string_view, fmt::v11::basic_format_args) at /usr/include/fmt/base.h:2837\nstd::remove_cv::type>::type fmt::v11::format_to const&, seastar::basic_sstring const&, schema const&, schema const&, 0>(seastar::internal::log_buf::inserter_iterator&, fmt::v11::fstring const&, seastar::basic_sstring const&, schema const&, schema const&>::t, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at /usr/include/fmt/base.h:2856\n (inlined by) void seastar::logger::log const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::log_level, seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&)::'lambda'(seastar::internal::log_buf::inserter_iterator)::operator()(seastar::internal::log_buf::inserter_iterator) const at ././seastar/include/seastar/util/log.hh:258\n (inlined by) seastar::logger::lambda_log_writer const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::log_level, seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&)::'lambda'(seastar::internal::log_buf::inserter_iterator)>::operator()(seastar::internal::log_buf::inserter_iterator) at ././seastar/include/seastar/util/log.hh:88\nseastar::logger::do_log(seastar::log_level, seastar::logger::log_writer&)::$_0::operator()(seastar::internal::log_buf::inserter_iterator) const at ./build/release/seastar/./seastar/src/util/log.cc:343\n (inlined by) seastar::logger::do_log(seastar::log_level, seastar::logger::log_writer&) at ./build/release/seastar/./seastar/src/util/log.cc:363\nvoid seastar::logger::log const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::log_level, seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at ././seastar/include/seastar/util/log.hh:263\nvoid seastar::logger::info const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at ././seastar/include/seastar/util/log.hh:359\n (inlined by) service::prepare_column_family_update_announcement(service::storage_proxy&, seastar::lw_shared_ptr, std::vector>, long) (.resume) at ./service/migration_manager.cc:605\nstd::__n4861::coroutine_handle>::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base>::promise_type::run_and_dispose() at ././seastar/include/seastar/core/coroutine.hh:129\nseastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::reactor::run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3245\nseastar::app_template::run_deprecated(int, char**, std::function&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:266\nseastar::app_template::run(int, char**, std::function ()>&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:160\nscylla_main(int, char**) at ./main.cc:821\nstd::function::operator()(int, char**) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) main at ./main.cc:2835\n__libc_start_call_main at ??:0\n__libc_start_main@GLIBC_2.2.5 at ??:0\n_start at ??:0\n\n", + "repeats": 0, + "message_chars": 18875 + }, + { + "run_id": "5b879df8-da1f-4c40-96a5-1bf56209ab74", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-23T02:45:51.712Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=7d61dbde-78c1-4451-9eaf-0526afb1d615 during_nemesis=GrowShrinkClusterNemesis, source=LongevityTest.test_custom_time()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=dcfa313d-bc6e-4cd3-9b90-eb8300b30eb9 during_nemesis=GrowShrinkClusterNemesis,AddDropColumnMonkey: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=124018 node=Node raft-double-cluster-size-with-schem-loader-node-5b879df8-0-1 [34.86.28.65 | 10.150.0.36] (Type: e2-standard-2) (rack: c)\nE [2026-06-23 02:01:03.134] java.io.IOException: Operation x10 on key(s) [4d503250334d36353331]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1778 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "CRITICAL", + "event_type": "CassandraStressLogEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-6a8211ab-0-2 [35.230.170.206 | 10.150.0.24] (Type: e2-standard-2) (rack: 2)", + "ts": "2026-06-16T16:21:14.258Z", + "message": "(CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=1f71900b-36e4-42c4-977c-eb69122a7ed3 during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=22861 node=Node raft-double-cluster-size-with-schem-loader-node-6a8211ab-0-2 [35.230.170.206 | 10.150.0.24] (Type: e2-standard-2) (rack: 2)\n[2026-06-16 16:21:14.258] java.io.IOException: Operation x10 on key(s) [4c36384d333531343731]: Error executing: (ReadTimeoutException): Cassandra timeout during read query at consistency QUORUM (2 responses were required but only 1 replica responded). In case this was generated during read repair, the consistency level is not representative of the actual consistency.\n", + "repeats": 1, + "message_chars": 729 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "CRITICAL", + "event_type": "CassandraStressEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-6a8211ab-0-2 [35.230.170.206 | 10.150.0.24] (Type: e2-standard-2) (rack: 2)", + "ts": "2026-06-16T16:21:32.402Z", + "message": "(CassandraStressEvent Severity.CRITICAL) period_type=end event_id=1f71900b-36e4-42c4-977c-eb69122a7ed3 during_nemesis=GrowShrinkClusterNemesis duration=6h22m42s: node=Node raft-double-cluster-size-with-schem-loader-node-6a8211ab-0-2 [35.230.170.206 | 10.150.0.24] (Type: e2-standard-2) (rack: 2)\nstress_cmd=cassandra-stress read cl=QUORUM duration=720m no-warmup -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=3) compaction(strategy=LeveledCompactionStrategy)' -mode cql3 native -rate threads=40 -pop 'dist=uniform(1..20971520)' -col 'n=FIXED(10) size=FIXED(512)' -log interval=5\nerrors:\n\nStress command completed with bad status 1: Failed to connect over JMX; not collecting these stats\ncom.datastax.driver.core.exceptions.ReadTimeoutException: Cassandra timeout during read query at consistency QUORUM (2 responses were required but only 1 replica responded). In case this was generated during read repair, the consistency level is not representative of the actual consistency.", + "repeats": 0, + "message_chars": 1006 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1", + "ts": "2026-06-16T08:46:44.446Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=2c5a03a1-5328-48bc-9d39-1d0adbccc10b: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=6301 node=raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1\n2026-06-16T08:46:44.446 raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1 !WARNING | scylla[5379] [shard 4:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x18b766e 0x36e9c80 0x1db41f8 0x5858197 0x1f2afb3 0x1f419ed 0x48baa10 0x1bca275 0x1bc7187 0x1bc58cc 0x270f838 0x1834759 0x18348a3 0x18323a9 0x58a2fae 0x585f78a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ././seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ././seastar/src/core/memory.cc:2498\n (inlined by) std::__new_allocator::allocate(unsigned long, void const*) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/new_allocator.h:151\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\nservice::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40665/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 16, + "message_chars": 62470 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-6a8211ab-0-6", + "ts": "2026-06-16T12:04:07.765Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=2c5a03a1-5328-48bc-9d39-1d0adbccc10b during_nemesis=GrowShrinkClusterNemesis: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=93820 node=raft-double-cluster-size-with-schem-db-node-6a8211ab-0-6\n2026-06-16T12:04:07.765 raft-double-cluster-size-with-schem-db-node-6a8211ab-0-6 !WARNING | scylla[5172] [shard 9:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x18b766e 0x36e9c80 0x1db41f8 0x5858197 0x1f2afb3 0x1f419ed 0x48baa10 0x1bca275 0x1bc7187 0x1bc58cc 0x270f838 0x1834759 0x18348a3 0x18323a9 0x58a2fae 0x585f78a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ././seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ././seastar/src/core/memory.cc:2498\n (inlined by) std::__new_allocator::allocate(unsigned long, void const*) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/new_allocator.h:151\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\nservice::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40665/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 7, + "message_chars": 62511 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1", + "ts": "2026-06-16T13:10:15.325Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=2c5a03a1-5328-48bc-9d39-1d0adbccc10b: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=64619 node=raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1\n2026-06-16T13:10:15.325 raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1 !WARNING | scylla[5379] [shard 1:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x18b766e 0x36e9c80 0x1db41f8 0x5858197 0x1f2afb3 0x1f419ed 0x48baa10 0x1bca275 0x1bc7187 0x1bc58cc 0x270f838 0x1834759 0x18348a3 0x18323a9 0x58a2fae 0x585f78a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ././seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ././seastar/src/core/memory.cc:2498\n (inlined by) std::__new_allocator::allocate(unsigned long, void const*) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/new_allocator.h:151\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\nservice::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40665/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 3, + "message_chars": 62471 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-6a8211ab-0-2", + "ts": "2026-06-16T14:20:08.860Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=2c5a03a1-5328-48bc-9d39-1d0adbccc10b: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=65564 node=raft-double-cluster-size-with-schem-db-node-6a8211ab-0-2\n2026-06-16T14:20:08.860 raft-double-cluster-size-with-schem-db-node-6a8211ab-0-2 !WARNING | scylla[5185] [shard 3:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x18b766e 0x36e9c80 0x1db41f8 0x5858197 0x1f2afb3 0x1f419ed 0x48baa10 0x1bca275 0x1bc7187 0x1bc58cc 0x270f838 0x1834759 0x18348a3 0x18323a9 0x58a2fae 0x585f78a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ././seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ././seastar/src/core/memory.cc:2498\n (inlined by) std::__new_allocator::allocate(unsigned long, void const*) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/new_allocator.h:151\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\nservice::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40665/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 7, + "message_chars": 62471 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-6a8211ab-0-2", + "ts": "2026-06-16T14:44:33.780Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=ef0b20b7-1f64-48bf-bab8-54a15d1bf805: type=REACTOR_STALLED regex=Reactor stalled line_number=71215 node=raft-double-cluster-size-with-schem-db-node-6a8211ab-0-2 known_issue=https://github.com/scylladb/scylladb/issues/8828\n2026-06-16T14:44:33.780 raft-double-cluster-size-with-schem-db-node-6a8211ab-0-2 !INFO | scylla[5185] Reactor stalled for 65 ms on shard 0, in scheduling group sl:default. Backtrace: 0x5886f1e 0x587fcd4 0x587f497 0x587fe6c /opt/scylladb/libreloc/libc.so.6+0x1a28f 0x182c542 0x1bc0f7d 0x1bbea1a 0x1bc19d3 0x2b3a712 0x1f1a7f8 0x183cd38 0x1f2ae55 0x2026e68 /opt/scylladb/libreloc/libc.so.6+0xf375b /opt/scylladb/libreloc/libc.so.6+0xf3cfb 0x18f146a 0x484a78b 0x4855a7f 0x43ae12a 0x18347b6 0x18348a3 0x18323a9 0x2f17bb8 0x2f18299 0x2f17cdb 0x2f14214 0x2f1615c /opt/scylladb/libreloc/libc.so.6+0x35b4 /opt/scylladb/libreloc/libc.so.6+0x3667 0x383f244\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::backtrace_buffer::append_backtrace_oneline()::'lambda'(seastar::frame)&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\nseastar::backtrace_buffer::append_backtrace_oneline() at ./build/release/seastar/./seastar/src/core/reactor.cc:822\n (inlined by) seastar::print_with_backtrace(seastar::backtrace_buffer&, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:849\nseastar::internal::cpu_stall_detector::generate_trace() at ./build/release/seastar/./seastar/src/core/reactor.cc:1495\nseastar::internal::cpu_stall_detector::maybe_report() at ./build/release/seastar/./seastar/src/core/reactor.cc:1230\n (inlined by) seastar::internal::cpu_stall_detector::on_signal() at ./build/release/seastar/./seastar/src/core/reactor.cc:1250\n (inlined by) seastar::reactor::block_notifier(int) at ./build/release/seastar/./seastar/src/core/reactor.cc:1564\n/app/cache/40665/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\n?? at ??:0\nutils::uleb64_express_encode_impl(char*&, unsigned long, unsigned long) at ././utils/vle.hh:74\n (inlined by) void utils::uleb64_express_encode(char*&, unsigned int, unsigned long, unsigned long, T&&, T0&&) at ././utils/vle.hh:82\n (inlined by) logalloc::region_impl::object_descriptor::encode(char*&, unsigned long, unsigned long) const at ./utils/logalloc.cc:1687\n (inlined by) logalloc::region_impl::alloc_small(logalloc::region_impl::object_descriptor const&, unsigned int, unsigned long) at ./utils/logalloc.cc:1771\nlogalloc::region_impl::compact_segment_locked(logalloc::segment*, logalloc::segment_descriptor&)::'lambda'(logalloc::region_impl::object_descriptor const*, void*, unsigned long)::operator()(logalloc::region_impl::object_descriptor const*, void*, unsigned long) const at ./utils/logalloc.cc:1945\n (inlined by) void logalloc::region_impl::for_each_live(logalloc::segment*, T&&) at ./utils/logalloc.cc:1791\n (inlined by) logalloc::region_impl::compact_segment_locked(logalloc::segment*, logalloc::segment_descriptor&) at ./utils/logalloc.cc:1944\nlogalloc::region_impl::compact() at ./utils/logalloc.cc:2263\n (inlined by) logalloc::reclaim_from_evictable(logalloc::region_impl&, unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2619\n (inlined by) logalloc::tracker::impl::compact_and_evict_locked(unsigned long, unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2778\nlogalloc::tracker::impl::reclaim_locked(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2684\n (inlined by) logalloc::tracker::impl::reclaim(unsigned long, seastar::bool_class) at ./utils/logalloc.cc:2663\nlogalloc::tracker::reclaim(unsigned long) at ./utils/logalloc.cc:606\n (inlined by) logalloc::tracker::reclaim(seastar::memory::reclaimer::request) at ./utils/logalloc.cc:2405\n (inlined by) logalloc::tracker::tracker()::$_0::operator()(seastar::memory::reclaimer::request) const at ./utils/logalloc.cc:594\n (inlined by) seastar::memory::reclaiming_result std::__invoke_impl(std::__invoke_other, logalloc::tracker::tracker()::$_0&, seastar::memory::reclaimer::request&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, seastar::memory::reclaiming_result>::type std::__invoke_r(logalloc::tracker::tracker()::$_0&, seastar::memory::reclaimer::request&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&, seastar::memory::reclaimer::request&&) (.llvm.1233227360080793535) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()(seastar::memory::reclaimer::request) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::memory::reclaimer::do_reclaim(unsigned long) at ./build/release/seastar/./seastar/include/seastar/core/memory.hh:238\n (inlined by) seastar::memory::cpu_pages::run_reclaimers(seastar::memory::reclaimer_scope, unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1357\nseastar::memory::cpu_pages::find_and_unlink_span_reclaiming(unsigned int) at ./build/release/seastar/./seastar/src/core/memory.cc:808\n (inlined by) seastar::memory::cpu_pages::allocate_large_and_trim(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:833\nseastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:940\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) __libc_malloc at ./build/release/seastar/./seastar/src/core/memory.cc:2263\n__vsyslog_internal at ??:0\nsyslog at ??:0\nseastar::logger::do_log(seastar::log_level, seastar::logger::log_writer&) at ./build/release/seastar/./seastar/src/util/log.cc:378\nvoid seastar::logger::log const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::log_level, seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at ././seastar/include/seastar/util/log.hh:263\nvoid seastar::logger::info const&, seastar::basic_sstring const&, schema const&, schema const&>(seastar::logger::format_info const&>::type, std::type_identity const&>::type, std::type_identity::type, std::type_identity::type>, seastar::basic_sstring const&, seastar::basic_sstring const&, schema const&, schema const&) at ././seastar/include/seastar/util/log.hh:359\n (inlined by) service::prepare_column_family_update_announcement(service::storage_proxy&, seastar::lw_shared_ptr, std::vector>, long) (.resume) at ./service/migration_manager.cc:604\nstd::__n4861::coroutine_handle>::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base>::promise_type::run_and_dispose() at ././seastar/include/seastar/core/coroutine.hh:129\nseastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::reactor::run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3245\nseastar::app_template::run_deprecated(int, char**, std::function&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:266\nseastar::app_template::run(int, char**, std::function ()>&&) at ./build/release/seastar/./seastar/src/core/app-template.cc:160\nscylla_main(int, char**) at ./main.cc:821\nstd::function::operator()(int, char**) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) main at ./main.cc:2835\n__libc_start_call_main at ??:0\n__libc_start_main@GLIBC_2.2.5 at ??:0\n_start at ??:0\n\n", + "repeats": 0, + "message_chars": 10466 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-6a8211ab-0-6", + "ts": "2026-06-16T15:56:29.848Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=2c5a03a1-5328-48bc-9d39-1d0adbccc10b during_nemesis=GrowShrinkClusterNemesis: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=146450 node=raft-double-cluster-size-with-schem-db-node-6a8211ab-0-6\n2026-06-16T15:56:29.848 raft-double-cluster-size-with-schem-db-node-6a8211ab-0-6 !WARNING | scylla[5172] [shard 1:sl:d] seastar_memory - oversized allocation: 524288 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x18b766e 0x36e9c80 0x1db41f8 0x5858197 0x1f2afb3 0x1f419ed 0x48baa10 0x1bca275 0x1bc7187 0x1bc58cc 0x270f838 0x1834759 0x18348a3 0x18323a9 0x58a2fae 0x585f78a /opt/scylladb/libreloc/libc.so.6+0x72463 /opt/scylladb/libreloc/libc.so.6+0xf55eb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::current_backtrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:163\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\nseastar::memory::allocate(unsigned long) at ././seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ././seastar/src/core/memory.cc:2498\n (inlined by) std::__new_allocator::allocate(unsigned long, void const*) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/new_allocator.h:151\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\nservice::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\nseastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40665/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ff0267465bc3d76e21003b3bc5598fd5ee63e261, for GNU/Linux 3.2.0, not stripped\n\nstart_thread at ??:0\n__GI___clone3 at ??:0\n\n", + "repeats": 2, + "message_chars": 62512 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1 [34.186.81.0 | 10.150.0.11] (Type: z3-highmem-16-highlssd) (rack: c)", + "ts": "2026-06-16T16:23:29.110Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=34f4d82a-c0c4-41ed-913b-389b0ef9a42f duration=2h14m38s: nemesis_name=GrowShrinkClusterNemesis target_node=Node raft-double-cluster-size-with-schem-db-node-6a8211ab-0-1 [34.186.81.0 | 10.150.0.11] (Type: z3-highmem-16-highlssd) (rack: c) errors=Killed by tearDown - test fail\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1971, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 48, in disrupt\n self.runner.disrupt_grow_shrink_cluster()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4389, in disrupt_grow_shrink_cluster\n new_nodes = self._grow_cluster(rack=None)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4416, in _grow_cluster\n new_nodes = self.add_new_nodes(\n count=add_nodes_number,\n rack=rack,\n instance_type=self.tester.params.get(\"nemesis_grow_shrink_instance_type\"),\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4315, in add_new_nodes\n nodes = self._add_and_init_new_cluster_nodes(count, rack=rack, instance_type=instance_type)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1293, in _add_and_init_new_cluster_nodes\n self.cluster.wait_for_init(node_list=new_nodes, timeout=timeout, check_node_health=False)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster.py\", line 5138, in wrapper\n verify_node_setup_or_startup(start_time, startup_queue, startup_results)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster.py\", line 5068, in verify_node_setup_or_startup\n node, setup_exception = task_queue.get(block=True, timeout=5)\n ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/queue.py\", line 213, in get\n self.not_empty.wait(remaining)\n ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/threading.py\", line 373, in wait\n gotit = waiter.acquire(True, timeout)\nsdcm.exceptions.KillNemesis\n", + "repeats": 0, + "message_chars": 2487 + }, + { + "run_id": "6a8211ab-9667-4d4a-aa95-46faaf316063", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-16T16:50:39.763Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=7656b4a9-e56d-454e-85a1-85f66ff6e2db, source=LongevityTest.test_custom_time()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=1f71900b-36e4-42c4-977c-eb69122a7ed3 during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=22861 node=Node raft-double-cluster-size-with-schem-loader-node-6a8211ab-0-2 [35.230.170.206 | 10.150.0.24] (Type: e2-standard-2) (rack: 2)\nE [2026-06-16 16:21:14.258] java.io.IOException: Operation x10 on key(s) [4c36384d333531343731]: Error executing: (ReadTimeoutException): Cassandra timeout during read query at consistency QUORUM (2 responses were required but only 1 replica responded). In case this was generated during read repair, the consistency level is not representative of the actual consistency.\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1827 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "CRITICAL", + "event_type": "CassandraStressLogEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-26e1a557-1 [35.175.125.7 | 10.12.3.31] (Type: c6i.xlarge) (rack: RACK0)", + "ts": "2026-06-16T09:12:58.182Z", + "message": "(CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=01f9929e-587a-42d7-b332-1acc92bca09f during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=1117 node=Node raft-double-cluster-size-with-schem-loader-node-26e1a557-1 [35.175.125.7 | 10.12.3.31] (Type: c6i.xlarge) (rack: RACK0)\n[2026-06-16 09:12:58.161] java.io.IOException: Operation x10 on key(s) [374b33304f3639393430]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n", + "repeats": 0, + "message_chars": 617 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "CRITICAL", + "event_type": "CassandraStressEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-26e1a557-1 [35.175.125.7 | 10.12.3.31] (Type: c6i.xlarge) (rack: RACK0)", + "ts": "2026-06-16T09:13:02.642Z", + "message": "(CassandraStressEvent Severity.CRITICAL) period_type=end event_id=01f9929e-587a-42d7-b332-1acc92bca09f during_nemesis=GrowShrinkClusterNemesis duration=20m14s: node=Node raft-double-cluster-size-with-schem-loader-node-26e1a557-1 [35.175.125.7 | 10.12.3.31] (Type: c6i.xlarge) (rack: RACK0)\nstress_cmd=cassandra-stress write cl=QUORUM n=20971520 no-warmup -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=3) compaction(strategy=LeveledCompactionStrategy)' -mode cql3 native -rate threads=80 -pop seq=1..20971520 -col 'n=FIXED(10) size=FIXED(512)' -log interval=5\nerrors:\n\nStress command completed with bad status 1: Failed to connect over JMX; not collecting these stats\ncom.datastax.driver.core.exceptions.WriteTimeoutException: Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)", + "repeats": 0, + "message_chars": 878 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "CRITICAL", + "event_type": "HardTimeoutEvent", + "node": "", + "ts": "2026-06-16T09:34:29.731Z", + "message": "(HardTimeoutEvent Severity.CRITICAL) period_type=one-time event_id=8e8a797d-1c5b-463c-8ba9-cc27368b72ca during_nemesis=GrowShrinkClusterNemesis, source=HardTimeout message=operation 'DECOMMISSION' exceeded hard-timeout of 1364.0s\nTraceback (most recent call last):\n File \"/usr/local/lib/python3.14/threading.py\", line 1043, in _bootstrap\n self._bootstrap_inner()\n File \"/usr/local/lib/python3.14/threading.py\", line 1081, in _bootstrap_inner\n self._context.run(self.run)\n File \"/usr/local/lib/python3.14/threading.py\", line 1023, in run\n self._target(*self._args, **self._kwargs)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 119, in _worker\n work_item.run(ctx)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 86, in run\n result = ctx.run(self.task)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 73, in run\n return fn(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/adaptive_timeouts/__init__.py\", line 225, in _monitor_timeouts\n HardTimeoutEvent(\n", + "repeats": 0, + "message_chars": 1064 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-26e1a557-3", + "ts": "2026-06-16T08:58:54.340Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=f91b7401-3508-49f5-aea2-200595a77df4: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=17497 node=raft-double-cluster-size-with-schem-db-node-26e1a557-3\n2026-06-16T08:58:54.340 raft-double-cluster-size-with-schem-db-node-26e1a557-3 !WARNING | scylla[6621] [shard 6:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x31f03eb 0x31f00a3 0x50ccadb 0x17ff5d3 0x423fa63 0x423fc33 0x423fe73 0x423fdc7 0x180b987 0x180ba6b 0x180a223 0x51136bb 0x50d42b3 /opt/scylladb/libreloc/libc.so.6+0x8f773 /opt/scylladb/libreloc/libc.so.6+0xfabdb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'()::operator()() const at ./service/storage_proxy.cc:1957\n (inlined by) seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>::operator()(seastar::future&&) && at ././seastar/include/seastar/core/future.hh:1672\nseastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const::'lambda'()::operator()() const at ././seastar/include/seastar/core/future.hh:1552\n (inlined by) void seastar::futurize>::satisfy_with_result_of::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const::'lambda'()>(seastar::internal::promise_base_with_type&&, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ././seastar/include/seastar/core/future.hh:2015\nseastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const at ././seastar/include/seastar/core/future.hh:1551\n (inlined by) seastar::continuation, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>, seastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&), void>::run_and_dispose() at ././seastar/include/seastar/core/future.hh:742\nseastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40666/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, ARM aarch64, version 1 (GNU/Linux), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, BuildID[sha1]=9dc3bd903b17e4dc967fba6b1fce8980616ec5cc, for GNU/Linux 3.7.0, not stripped\n\nstart_thread at ??:0\nthread_start at ??:0\n\n", + "repeats": 10, + "message_chars": 14619 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "ERROR", + "event_type": "SoftTimeoutEvent", + "node": "", + "ts": "2026-06-16T09:28:09.722Z", + "message": "(SoftTimeoutEvent Severity.ERROR) period_type=one-time event_id=0e0fb25a-54b1-432b-9ee0-65fc168e7d92 during_nemesis=GrowShrinkClusterNemesis, source=SoftTimeout message=operation 'DECOMMISSION' exceeded soft-timeout of 982.0s and is still in progress\nTraceback (most recent call last):\n File \"/usr/local/lib/python3.14/threading.py\", line 1043, in _bootstrap\n self._bootstrap_inner()\n File \"/usr/local/lib/python3.14/threading.py\", line 1081, in _bootstrap_inner\n self._context.run(self.run)\n File \"/usr/local/lib/python3.14/threading.py\", line 1023, in run\n self._target(*self._args, **self._kwargs)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 119, in _worker\n work_item.run(ctx)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 86, in run\n result = ctx.run(self.task)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 73, in run\n return fn(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/adaptive_timeouts/__init__.py\", line 231, in _monitor_timeouts\n SoftTimeoutEvent(\n", + "repeats": 2, + "message_chars": 1085 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "ERROR", + "event_type": "SoftTimeoutEvent", + "node": "", + "ts": "2026-06-16T09:42:35.528Z", + "message": "(SoftTimeoutEvent Severity.ERROR) period_type=one-time event_id=5875141d-6c63-4e7c-b459-2ae01334a6dd during_nemesis=GrowShrinkClusterNemesis, source=SoftTimeout message=operation 'DECOMMISSION' is finished and took 1850.8s (soft timeout was set to 982.0s)\nTraceback (most recent call last):\n File \"/usr/local/lib/python3.14/threading.py\", line 1043, in _bootstrap\n self._bootstrap_inner()\n File \"/usr/local/lib/python3.14/threading.py\", line 1081, in _bootstrap_inner\n self._context.run(self.run)\n File \"/usr/local/lib/python3.14/threading.py\", line 1023, in run\n self._target(*self._args, **self._kwargs)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 119, in _worker\n work_item.run(ctx)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 86, in run\n result = ctx.run(self.task)\n File \"/usr/local/lib/python3.14/concurrent/futures/thread.py\", line 73, in run\n return fn(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/parallel_object.py\", line 73, in inner\n return_val = fun(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4324, in _decommission\n self.cluster.decommission(node)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster.py\", line 6410, in decommission\n with adaptive_timeout(operation=Operations.DECOMMISSION, node=node):\n File \"/usr/local/lib/python3.14/contextlib.py\", line 148, in __exit__\n next(self.gen)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/adaptive_timeouts/__init__.py\", line 305, in adaptive_timeout\n SoftTimeoutEvent(operation=operation.name, soft_timeout=soft_timeout, duration=duration).publish_or_dump()\n", + "repeats": 0, + "message_chars": 1692 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "ERROR", + "event_type": "FailedResultEvent", + "node": "", + "ts": "2026-06-16T09:42:35.839Z", + "message": "(FailedResultEvent Severity.ERROR) period_type=one-time event_id=37eb2078-0d27-4cdb-a45f-0f76e0a04eac during_nemesis=GrowShrinkClusterNemesis: message=Argus validation failed for the result in DECOMMISSION - Timeout Statistics. Please check the 'Results' tab for more details.", + "repeats": 0, + "message_chars": 276 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node raft-double-cluster-size-with-schem-db-node-26e1a557-3 [44.200.157.50 | 10.12.1.194] (Type: i8g.2xlarge) (rack: RACK2)", + "ts": "2026-06-16T09:45:36.415Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=5508f99e-c278-407b-9185-7cd2c992c03e duration=52m32s: nemesis_name=GrowShrinkClusterNemesis target_node=Node raft-double-cluster-size-with-schem-db-node-26e1a557-3 [44.200.157.50 | 10.12.1.194] (Type: i8g.2xlarge) (rack: RACK2) errors=Killed by tearDown - test fail\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1971, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 48, in disrupt\n self.runner.disrupt_grow_shrink_cluster()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4396, in disrupt_grow_shrink_cluster\n self._shrink_cluster(rack=None, new_nodes=new_nodes)\n ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4465, in _shrink_cluster\n self._decommission_nodes(\n ~~~~~~~~~~~~~~~~~~~~~~~~^\n decommission_nodes_number,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^\n ...<3 lines>...\n exact_nodes=new_nodes,\n ^^^^^^^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4363, in _decommission_nodes\n self.decommission_nodes(nodes_to_decommission)\n ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4329, in decommission_nodes\n parallel_obj.run(_decommission, ignore_exceptions=False, unpack_objects=True)\n ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/parallel_object.py\", line 97, in run\n result = future.result(time_out)\n File \"/usr/local/lib/python3.14/concurrent/futures/_base.py\", line 445, in result\n self._condition.wait(timeout)\n ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^\n File \"/usr/local/lib/python3.14/threading.py\", line 373, in wait\n gotit = waiter.acquire(True, timeout)\nsdcm.exceptions.KillNemesis\n", + "repeats": 0, + "message_chars": 2247 + }, + { + "run_id": "26e1a557-5510-4413-895d-b46039566c30", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-16T09:49:49.334Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=76c88498-93e9-41ab-b8fb-5345062f91f8, source=LongevityTest.test_custom_time()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=01f9929e-587a-42d7-b332-1acc92bca09f during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=1117 node=Node raft-double-cluster-size-with-schem-loader-node-26e1a557-1 [35.175.125.7 | 10.12.3.31] (Type: c6i.xlarge) (rack: RACK0)\nE [2026-06-16 09:12:58.161] java.io.IOException: Operation x10 on key(s) [374b33304f3639393430]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1715 + }, + { + "run_id": "2001a589-154b-46e9-a7ed-688745792bcb", + "severity": "CRITICAL", + "event_type": "CassandraStressLogEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-2001a589-2 [3.94.195.31 | 10.12.8.114] (Type: c6i.xlarge) (rack: RACK1)", + "ts": "2026-06-23T12:20:04.290Z", + "message": "(CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=972d6b3f-520a-4a4c-9ea3-b1fae5d54362 during_nemesis=GrowShrinkClusterNemesis,AddDropColumnMonkey: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=491 node=Node raft-double-cluster-size-with-schem-loader-node-2001a589-2 [3.94.195.31 | 10.12.8.114] (Type: c6i.xlarge) (rack: RACK1)\n[2026-06-23 12:20:04.214] java.io.IOException: Operation x10 on key(s) [31304d384c3533343531]: Error executing: (ReadTimeoutException): Cassandra timeout during read query at consistency QUORUM (2 responses were required but only 1 replica responded). In case this was generated during read repair, the consistency level is not representative of the actual consistency.\n", + "repeats": 0, + "message_chars": 743 + }, + { + "run_id": "2001a589-154b-46e9-a7ed-688745792bcb", + "severity": "CRITICAL", + "event_type": "CassandraStressEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-2001a589-2 [3.94.195.31 | 10.12.8.114] (Type: c6i.xlarge) (rack: RACK1)", + "ts": "2026-06-23T12:20:08.749Z", + "message": "(CassandraStressEvent Severity.CRITICAL) period_type=end event_id=972d6b3f-520a-4a4c-9ea3-b1fae5d54362 during_nemesis=GrowShrinkClusterNemesis,AddDropColumnMonkey duration=21m49s: node=Node raft-double-cluster-size-with-schem-loader-node-2001a589-2 [3.94.195.31 | 10.12.8.114] (Type: c6i.xlarge) (rack: RACK1)\nstress_cmd=cassandra-stress read cl=QUORUM duration=720m no-warmup -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=3) compaction(strategy=LeveledCompactionStrategy)' -mode cql3 native -rate threads=40 -pop 'dist=uniform(1..20971520)' -col 'n=FIXED(10) size=FIXED(512)' -log interval=5\nerrors:\n\nStress command completed with bad status 1: Failed to connect over JMX; not collecting these stats\ncom.datastax.driver.core.exceptions.ReadTimeoutException: Cassandra timeout during read query at consistency QUORUM (2 responses were required but only 1 replica responded). In case this was generated during read repair, the consistency level is not representative of the actual consistency.", + "repeats": 0, + "message_chars": 1020 + }, + { + "run_id": "2001a589-154b-46e9-a7ed-688745792bcb", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-2001a589-2", + "ts": "2026-06-23T10:30:53.899Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=0cc08ecb-95bf-4741-b5eb-978ea8e515c0: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=3520 node=raft-double-cluster-size-with-schem-db-node-2001a589-2\n2026-06-23T10:30:53.899 raft-double-cluster-size-with-schem-db-node-2001a589-2 !WARNING | scylla[6457] [shard 3:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x31a50bb 0x31a4d73 0x51ae7af 0x1809057 0x42c3143 0x1a70bab 0x1a6e53b 0x1a6d1f3 0x1fa2257 0x1815663 0x181589b 0x18139f7 0x51f5177 0x51b5f8b /opt/scylladb/libreloc/libc.so.6+0x8f773 /opt/scylladb/libreloc/libc.so.6+0xfabdb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ./service/storage_proxy.cc:1948\n (inlined by) service::abstract_write_response_handler::signal(unsigned long) at ./service/storage_proxy.cc:1817\n (inlined by) service::abstract_write_response_handler::signal(utils::tagged_uuid) at ./service/storage_proxy.cc:1730\n (inlined by) service::abstract_write_response_handler::response(utils::tagged_uuid) at ./service/storage_proxy.cc:1857\n (inlined by) service::storage_proxy::got_response(unsigned long, utils::tagged_uuid, std::optional) at ./service/storage_proxy.cc:2817\nservice::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)::operator()(service::storage_proxy&) at ./service/storage_proxy.cc:766\n (inlined by) seastar::rpc::no_wait_type std::__invoke_impl)::'lambda'(service::storage_proxy&), service::storage_proxy&>(std::__invoke_other, service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result)::'lambda'(service::storage_proxy&), service::storage_proxy&>::type std::__invoke)::'lambda'(service::storage_proxy&), service::storage_proxy&>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, service::storage_proxy&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl)::'lambda'(service::storage_proxy&), std::tuple, 0ul>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&, std::integer_sequence) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply)::'lambda'(service::storage_proxy&), std::tuple>(service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)::'lambda'(service::storage_proxy&)&&, std::tuple&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()::operator()() at ././seastar/include/seastar/core/sharded.hh:826\n (inlined by) T std::__invoke_impl seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(std::__invoke_other, seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(T&&) at ././seastar/include/seastar/core/future.hh:2032\n (inlined by) seastar::futurize::type>::type seastar::smp::submit_to seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&)::'lambda'()>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/smp.hh:355\n (inlined by) seastar::future seastar::sharded::invoke_on)::'lambda'(service::storage_proxy&), seastar::future>(unsigned int, seastar::smp_submit_to_options, T&&) at ././seastar/include/seastar/core/sharded.hh:824\n (inlined by) service::storage_proxy::remote::handle_mutation_done(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) at ./service/storage_proxy.cc:764\n (inlined by) seastar::future std::__invoke_impl, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_memfun_deref, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:76\n (inlined by) std::__invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::invoke (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) decltype(auto) std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::_S_call (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, 0ul, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, std::integer_sequence, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/functional:1020\n (inlined by) std::invoke_result (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::future (service::storage_proxy::remote::*&)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::type, std::__like_impl (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, service::storage_proxy::remote*&>::type, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>::type std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>::operator() (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(this std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/functional:949\n (inlined by) seastar::future std::__invoke_impl, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>, seastar::future>::type std::__invoke_r, std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional>(std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), std::_Bind_front (service::storage_proxy::remote::*)(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional), service::storage_proxy::remote*>>::_M_invoke(std::_Any_data const&, seastar::rpc::client_info const&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>::operator()(seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional) const at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::future std::__invoke_impl, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper&&, unsigned int&&, unsigned long&&, seastar::rpc::optional&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) decltype(auto) std::__apply_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>, 0ul, 1ul, 2ul, 3ul>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&, std::integer_sequence) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/tuple:2920\n (inlined by) decltype(auto) std::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/tuple:2935\n (inlined by) seastar::future seastar::futurize>::apply (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::reference_wrapper, unsigned int, unsigned long, seastar::rpc::optional>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, std::tuple, unsigned int, unsigned long, seastar::rpc::optional>&&) at ././seastar/include/seastar/core/future.hh:1998\n (inlined by) seastar::futurize>::type seastar::rpc::apply, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&, seastar::rpc::client_info&, seastar::rpc::opt_time_point, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::tuple>&&) at ././seastar/include/seastar/rpc/rpc_impl.hh:655\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()::operator()() at ././seastar/include/seastar/rpc/rpc_impl.hh:699\nauto std::__invoke_impl, auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize>::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2030\n (inlined by) auto seastar::futurize_invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(auto&&) at ././seastar/include/seastar/core/future.hh:2061\n (inlined by) auto seastar::internal::invoke_func_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate::holder&&, auto&&) at ././seastar/include/seastar/core/gate.hh:360\n (inlined by) auto seastar::try_with_gate (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto)::'lambda'()>(seastar::gate&, auto&&) at ././seastar/include/seastar/core/gate.hh:399\n (inlined by) auto auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto)::operator()>(auto) at ././seastar/include/seastar/rpc/rpc_impl.hh:695\n (inlined by) auto std::__invoke_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::semaphore_units&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::__invoke_result>::type std::__invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:98\n (inlined by) std::invoke_result>::type std::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/functional:122\n (inlined by) seastar::future seastar::futurize::invoke (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::semaphore_units>(auto&&, seastar::semaphore_units&&) at ././seastar/include/seastar/core/future.hh:2027\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then_impl (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1475\n (inlined by) std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)> seastar::future>::then (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::'lambda'(auto), seastar::future>(auto&&, std::source_location) at ././seastar/include/seastar/core/future.hh:1395\n (inlined by) auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) at ././seastar/include/seastar/rpc/rpc_impl.hh:693\n (inlined by) seastar::future std::__invoke_impl, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::__invoke_other, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\nstd::enable_if, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>, seastar::future>::type std::__invoke_r, auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)&, seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder>(std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:116\n (inlined by) std::_Function_handler (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder), auto seastar::rpc::recv_helper (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>, seastar::future, unsigned int, unsigned long, seastar::rpc::optional, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point>(unsigned long, seastar::rpc::signature (unsigned int, unsigned long, seastar::rpc::optional)>, std::function (seastar::rpc::client_info const&, unsigned int, unsigned long, seastar::rpc::optional)>&&, seastar::rpc::do_want_client_info, seastar::rpc::dont_want_time_point)::'lambda'(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::_M_invoke(std::_Any_data const&, seastar::shared_ptr&&, std::optional>>>&&, long&&, seastar::rpc::rcv_buf&&, seastar::gate::holder&&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\n (inlined by) std::function (seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder)>::operator()(seastar::shared_ptr, std::optional>>>, long, seastar::rpc::rcv_buf, seastar::gate::holder) const at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::rpc::server::connection::process() (.resume) at ./build/release/seastar/./seastar/src/rpc/rpc.cc:1246\nstd::__n4861::coroutine_handle::promise_type>::resume() const at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/coroutine:247\n (inlined by) seastar::internal::coroutine_traits_base::promise_type::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/coroutine.hh:171\n (inlined by) seastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40831/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, ARM aarch64, version 1 (GNU/Linux), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, BuildID[sha1]=9dc3bd903b17e4dc967fba6b1fce8980616ec5cc, for GNU/Linux 3.7.0, not stripped\n\nstart_thread at ??:0\nthread_start at ??:0\n\n", + "repeats": 7, + "message_chars": 62271 + }, + { + "run_id": "2001a589-154b-46e9-a7ed-688745792bcb", + "severity": "ERROR", + "event_type": "DatabaseLogEvent", + "node": "raft-double-cluster-size-with-schem-db-node-2001a589-2", + "ts": "2026-06-23T11:34:53.224Z", + "message": "(DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=0cc08ecb-95bf-4741-b5eb-978ea8e515c0: type=OVERSIZED_ALLOCATION regex=seastar_memory - oversized allocation: line_number=8401 node=raft-double-cluster-size-with-schem-db-node-2001a589-2\n2026-06-23T11:34:53.224 raft-double-cluster-size-with-schem-db-node-2001a589-2 !WARNING | scylla[6457] [shard 1:sl:d] seastar_memory - oversized allocation: 262144 bytes. This is non-fatal, but could lead to latency and/or fragmentation issues. Please report: at 0x31a50bb 0x31a4d73 0x51ae7af 0x1809057 0x42c3143 0x42c3313 0x42c3553 0x42c34a7 0x18156bf 0x181589b 0x18139f7 0x51f5177 0x51b5f8b /opt/scylladb/libreloc/libc.so.6+0x8f773 /opt/scylladb/libreloc/libc.so.6+0xfabdb\nBacktrace:\n[Backtrace #0]\nvoid seastar::backtrace(seastar::current_backtrace_tasklocal()::$_0&&, bool) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:85\n (inlined by) seastar::current_backtrace_tasklocal() at ./build/release/seastar/./seastar/src/util/backtrace.cc:93\nseastar::current_tasktrace() at ./build/release/seastar/./seastar/src/util/backtrace.cc:130\nseastar::memory::cpu_pages::warn_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:865\nseastar::memory::cpu_pages::check_large_allocation(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:928\n (inlined by) seastar::memory::cpu_pages::allocate_large(unsigned int, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:939\n (inlined by) seastar::memory::allocate_large(unsigned long, bool) at ./build/release/seastar/./seastar/src/core/memory.cc:1562\n (inlined by) seastar::memory::allocate_slowpath(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1709\n (inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1728\n (inlined by) operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2498\nstd::allocator::allocate(unsigned long) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/allocator.h:203\n (inlined by) seastar::circular_buffer>::expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:325\nseastar::circular_buffer>::expand() at ././seastar/include/seastar/core/circular_buffer.hh:319\n (inlined by) seastar::circular_buffer>::maybe_expand(unsigned long) at ././seastar/include/seastar/core/circular_buffer.hh:355\n (inlined by) seastar::circular_buffer>::push_back(unsigned long const&) at ././seastar/include/seastar/core/circular_buffer.hh:394\n (inlined by) service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)::operator()(service::abstract_write_response_handler*) const at ./service/storage_proxy.cc:1820\n (inlined by) void service::abstract_write_response_handler::delay(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'()::operator()() const at ./service/storage_proxy.cc:1957\n (inlined by) seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>::operator()(seastar::future&&) && at ././seastar/include/seastar/core/future.hh:1672\nseastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const::'lambda'()::operator()() const at ././seastar/include/seastar/core/future.hh:1552\n (inlined by) void seastar::futurize>::satisfy_with_result_of::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const::'lambda'()>(seastar::internal::promise_base_with_type&&, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&) at ././seastar/include/seastar/core/future.hh:2015\nseastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&)::operator()(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&) const at ././seastar/include/seastar/core/future.hh:1551\n (inlined by) seastar::continuation, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>, seastar::futurize::type seastar::future::then_wrapped_nrvo, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>>(seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, std::source_location)::'lambda'(seastar::internal::promise_base_with_type&&, seastar::future::finally_body(tracing::trace_state_ptr, service::abstract_write_response_handler::signal(unsigned long)::'lambda'(service::abstract_write_response_handler*)&&)::'lambda'(), false>&&, seastar::future_state&&), void>::run_and_dispose() at ././seastar/include/seastar/core/future.hh:742\nseastar::reactor::task_queue::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:2695\n (inlined by) seastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3201\nseastar::reactor::task_queue_group::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3185\n (inlined by) seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3353\nseastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0::operator()() const at ./build/release/seastar/./seastar/src/core/reactor.cc:4655\n (inlined by) void std::__invoke_impl(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:63\n (inlined by) std::enable_if, void>::type std::__invoke_r(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_0&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/invoke.h:113\n (inlined by) std::_Function_handler::_M_invoke(std::_Any_data const&) at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:292\nstd::function::operator()() const at /usr/lib/gcc/aarch64-redhat-linux/15/../../../../include/c++/15/bits/std_function.h:593\n (inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:83\n/app/cache/40831/scylla/libreloc/libc.so.6: ELF 64-bit LSB shared object, ARM aarch64, version 1 (GNU/Linux), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, BuildID[sha1]=9dc3bd903b17e4dc967fba6b1fce8980616ec5cc, for GNU/Linux 3.7.0, not stripped\n\nstart_thread at ??:0\nthread_start at ??:0\n\n", + "repeats": 2, + "message_chars": 14618 + }, + { + "run_id": "2001a589-154b-46e9-a7ed-688745792bcb", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-23T12:57:14.630Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=5d79a43f-7c4b-40ae-bebe-301feef9a09a during_nemesis=GrowShrinkClusterNemesis, source=LongevityTest.test_custom_time()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=972d6b3f-520a-4a4c-9ea3-b1fae5d54362 during_nemesis=GrowShrinkClusterNemesis,AddDropColumnMonkey: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=491 node=Node raft-double-cluster-size-with-schem-loader-node-2001a589-2 [3.94.195.31 | 10.12.8.114] (Type: c6i.xlarge) (rack: RACK1)\nE [2026-06-23 12:20:04.214] java.io.IOException: Operation x10 on key(s) [31304d384c3533343531]: Error executing: (ReadTimeoutException): Cassandra timeout during read query at consistency QUORUM (2 responses were required but only 1 replica responded). In case this was generated during read repair, the consistency level is not representative of the actual consistency.\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1881 + }, + { + "run_id": "97f38db2-4b40-4121-8286-387ed13fb06d", + "severity": "CRITICAL", + "event_type": "GceInstanceEvent", + "node": "longevity-large-partitions-200k-pks-loader-node-97f38db2-0-5", + "ts": "2026-06-16T12:50:55.238Z", + "message": "(GceInstanceEvent Severity.CRITICAL) period_type=one-time event_id=e8c30227-3725-4a4c-9428-91a1c211c29a: compute.instances.migrateOnHostMaintenance on node longevity-large-partitions-200k-pks-loader-node-97f38db2-0-5 at 2026-06-16 12:46:04.246063+00:00: Instance migrated during Compute Engine maintenance.", + "repeats": 4, + "message_chars": 306 + }, + { + "run_id": "97f38db2-4b40-4121-8286-387ed13fb06d", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-97f38db2-0-6 [34.139.31.103 | 10.142.0.119] (Type: n2-highmem-16) (rack: RACK0)", + "ts": "2026-06-15T16:57:01.877Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=81d95c03-b413-475b-ab74-4036f9a0b829 duration=3h12m37s: nemesis_name=RestartThenRepairNodeMonkey target_node=Node longevity-large-partitions-200k-pks-db-node-97f38db2-0-6 [34.139.31.103 | 10.142.0.119] (Type: n2-highmem-16) (rack: RACK0) errors=Failed on waiting until task: repair/d2aef3ee-0832-4f7b-b18e-774aba8ce771 reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/d2aef3ee-0832-4f7b-b18e-774aba8ce771 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 71, in wait_for\n res = retry(func, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 475, in __call__\n do = self.iter(retry_state=retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 376, in iter\n result = action(retry_state)\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 418, in exc_check\n raise retry_exc.reraise()\n ~~~~~~~~~~~~~~~~~^^\n File \"/usr/local/lib/python3.14/site-packages/tenacity/__init__.py\", line 186, in reraise\n raise self\ntenacity.RetryError: RetryError[]\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 374, in wait_for_status\n return wait.wait_for(\n ~~~~~~~~~~~~~^\n func=self.is_status_in_list,\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n ...<5 lines>...\n timeout=timeout,\n ^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/wait.py\", line 87, in wait_for\n raise raising_exc from ex\nsdcm.exceptions.WaitForTimeoutError: Wait for: Waiting until task: repair/d2aef3ee-0832-4f7b-b18e-774aba8ce771 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1971, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 109, in disrupt\n self.runner.disrupt_restart_then_repair_node()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 781, in disrupt_restart_then_repair_node\n self.run_repair()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2171, in run_repair\n self.run_repair_manager(ignore_down_hosts=ignore_down_hosts, timeout=timeout)\n ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 2141, in run_repair_manager\n task_final_status = mgr_task.wait_and_get_final_status(timeout=timeout) # timeout is 24 hours\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 431, in wait_and_get_final_status\n res = self.wait_for_status(list_status=list_final_status, timeout=timeout, step=step)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/mgmt/cli.py\", line 384, in wait_for_status\n raise WaitForTimeoutError(\n ...<3 lines>...\n ) from ex\nsdcm.exceptions.WaitForTimeoutError: Failed on waiting until task: repair/d2aef3ee-0832-4f7b-b18e-774aba8ce771 reaches status of ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: current task status RUNNING: Wait for: Waiting until task: repair/d2aef3ee-0832-4f7b-b18e-774aba8ce771 reaches status of: ['ERROR', 'ERROR (4/4)', 'STOPPED', 'DONE', 'ABORTED']: timeout - 10800 seconds - expired\n", + "repeats": 0, + "message_chars": 4079 + }, + { + "run_id": "97f38db2-4b40-4121-8286-387ed13fb06d", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node longevity-large-partitions-200k-pks-db-node-97f38db2-0-3 [34.24.77.140 | 10.142.0.113] (Type: n2-highmem-16) (rack: RACK0)", + "ts": "2026-06-16T12:54:41.951Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=82ab0441-7d3f-41e0-86c1-a8d85d3da70d duration=6h8m21s: nemesis_name=AddRemoveMvNemesis target_node=Node longevity-large-partitions-200k-pks-db-node-97f38db2-0-3 [34.24.77.140 | 10.142.0.113] (Type: n2-highmem-16) (rack: RACK0) errors=Killed by tearDown - test fail\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1971, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 901, in disrupt\n self.runner.disrupt_add_remove_mv()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 5229, in disrupt_add_remove_mv\n wait_for_view_to_be_built(self.target_node, ks_name, view_name, timeout=timeout * 2)\n ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/utils/indexes.py\", line 119, in wait_for_view_to_be_built\n time.sleep(30)\n ~~~~~~~~~~^^^^\nsdcm.exceptions.KillNemesis\n", + "repeats": 0, + "message_chars": 1140 + }, + { + "run_id": "97f38db2-4b40-4121-8286-387ed13fb06d", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-16T13:47:17.088Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=2cbb2b90-d605-4083-9e87-840cee6862f2, source=LargePartitionLongevityTest.test_large_partition_longevity()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (GceInstanceEvent Severity.CRITICAL) period_type=one-time event_id=e8c30227-3725-4a4c-9428-91a1c211c29a: compute.instances.migrateOnHostMaintenance on node longevity-large-partitions-200k-pks-loader-node-97f38db2-0-5 at 2026-06-16 12:46:04.246063+00:00: Instance migrated during Compute Engine maintenance.\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1413 + }, + { + "run_id": "736437f9-c362-42a5-b48e-589ceed1d374", + "severity": "CRITICAL", + "event_type": "CassandraStressLogEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-736437f9-1 [3.90.17.205 | 10.12.13.202] (Type: c6i.xlarge) (rack: RACK0)", + "ts": "2026-06-15T13:01:14.881Z", + "message": "(CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=436a3f79-b2fc-4631-b621-d4cab7bae824 during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=996 node=Node raft-double-cluster-size-with-schem-loader-node-736437f9-1 [3.90.17.205 | 10.12.13.202] (Type: c6i.xlarge) (rack: RACK0)\n[2026-06-15 13:01:14.872] java.io.IOException: Operation x10 on key(s) [354c34344c3037503231]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n", + "repeats": 0, + "message_chars": 617 + }, + { + "run_id": "736437f9-c362-42a5-b48e-589ceed1d374", + "severity": "CRITICAL", + "event_type": "CassandraStressEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-736437f9-1 [3.90.17.205 | 10.12.13.202] (Type: c6i.xlarge) (rack: RACK0)", + "ts": "2026-06-15T13:01:18.868Z", + "message": "(CassandraStressEvent Severity.CRITICAL) period_type=end event_id=436a3f79-b2fc-4631-b621-d4cab7bae824 duration=11m18s: node=Node raft-double-cluster-size-with-schem-loader-node-736437f9-1 [3.90.17.205 | 10.12.13.202] (Type: c6i.xlarge) (rack: RACK0)\nstress_cmd=cassandra-stress write cl=QUORUM n=20971520 no-warmup -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=3) compaction(strategy=LeveledCompactionStrategy)' -mode cql3 native -rate threads=80 -pop seq=1..20971520 -col 'n=FIXED(10) size=FIXED(512)' -log interval=5\nerrors:\n\nStress command completed with bad status 1: Failed to connect over JMX; not collecting these stats\ncom.datastax.driver.core.exceptions.WriteTimeoutException: Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)", + "repeats": 0, + "message_chars": 839 + }, + { + "run_id": "736437f9-c362-42a5-b48e-589ceed1d374", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node raft-double-cluster-size-with-schem-db-node-736437f9-1 [3.84.178.49 | 10.12.13.163] (Type: i8g.2xlarge) (rack: RACK0)", + "ts": "2026-06-15T13:01:15.354Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=71bf7ddf-9579-46d7-969f-8a0f7dd07661 duration=17s: nemesis_name=GrowShrinkClusterNemesis target_node=Node raft-double-cluster-size-with-schem-db-node-736437f9-1 [3.84.178.49 | 10.12.13.163] (Type: i8g.2xlarge) (rack: RACK0) errors=Killed by tearDown - test fail\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1971, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 48, in disrupt\n self.runner.disrupt_grow_shrink_cluster()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4389, in disrupt_grow_shrink_cluster\n new_nodes = self._grow_cluster(rack=None)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4416, in _grow_cluster\n new_nodes = self.add_new_nodes(\n count=add_nodes_number,\n rack=rack,\n instance_type=self.tester.params.get(\"nemesis_grow_shrink_instance_type\"),\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4315, in add_new_nodes\n nodes = self._add_and_init_new_cluster_nodes(count, rack=rack, instance_type=instance_type)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1284, in _add_and_init_new_cluster_nodes\n new_nodes = skip_on_capacity_issues(db_cluster=self.tester.db_cluster)(self.cluster.add_nodes)(\n **add_node_func_args\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 409, in wrapper\n return inner_func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 1186, in add_nodes\n added_nodes = super().add_nodes(\n count=count,\n ...<6 lines>...\n **kwargs,\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/utils/node_allocator.py\", line 295, in wrapper\n new_nodes = func(self, *args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 557, in add_nodes\n self._create_or_find_instances(\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^\n count=rack_count,\n ^^^^^^^^^^^^^^^^^\n ...<5 lines>...\n ami_id=image_id,\n ^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 502, in _create_or_find_instances\n return self._create_instances(\n ~~~~~~~~~~~~~~~~~~~~~~^\n count,\n ^^^^^^\n ...<5 lines>...\n ami_id=ami_id,\n ^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 277, in _create_instances\n instances = self._create_on_demand_instances(\n count,\n ...<5 lines>...\n ami_id=ami_id,\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 183, in _create_on_demand_instances\n instances = self._ec2_services[dc_idx].create_instances(**params)\n File \"/usr/local/lib/python3.14/site-packages/boto3/resources/factory.py\", line 581, in do_action\n response = action(self, *args, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/boto3/resources/action.py\", line 88, in __call__\n response = getattr(parent.meta.client, operation_name)(*args, **params)\n File \"/usr/local/lib/python3.14/site-packages/botocore/client.py\", line 602, in _api_call\n return self._make_api_call(operation_name, kwargs)\n ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/site-packages/botocore/context.py\", line 123, in wrapper\n return func(*args, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/botocore/client.py\", line 1060, in _make_api_call\n http, parsed_response = self._make_request(\n ~~~~~~~~~~~~~~~~~~^\n operation_model, request_dict, request_context\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n )\n ^\n File \"/usr/local/lib/python3.14/site-packages/botocore/client.py\", line 1084, in _make_request\n return self._endpoint.make_request(operation_model, request_dict)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/site-packages/botocore/endpoint.py\", line 119, in make_request\n return self._send_request(request_dict, operation_model)\n ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/site-packages/botocore/endpoint.py\", line 200, in _send_request\n while self._needs_retry(\n ~~~~~~~~~~~~~~~~~^\n attempts,\n ^^^^^^^^^\n ...<3 lines>...\n exception,\n ^^^^^^^^^^\n ):\n ^\n File \"/usr/local/lib/python3.14/site-packages/botocore/endpoint.py\", line 379, in _needs_retry\n time.sleep(handler_response)\n ~~~~~~~~~~^^^^^^^^^^^^^^^^^^\nsdcm.exceptions.KillNemesis\n", + "repeats": 0, + "message_chars": 4974 + }, + { + "run_id": "736437f9-c362-42a5-b48e-589ceed1d374", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-15T13:05:11.387Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=9feb337b-6102-4f6c-bc18-c23aeb4c5d6a, source=LongevityTest.test_custom_time()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=436a3f79-b2fc-4631-b621-d4cab7bae824 during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=996 node=Node raft-double-cluster-size-with-schem-loader-node-736437f9-1 [3.90.17.205 | 10.12.13.202] (Type: c6i.xlarge) (rack: RACK0)\nE [2026-06-15 13:01:14.872] java.io.IOException: Operation x10 on key(s) [354c34344c3037503231]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1715 + }, + { + "run_id": "3be1d1f3-2b5b-420d-9d50-3f854feec517", + "severity": "CRITICAL", + "event_type": "CassandraStressLogEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-3be1d1f3-1 [98.92.173.228 | 10.12.2.216] (Type: c6i.xlarge) (rack: RACK0)", + "ts": "2026-06-15T12:13:09.370Z", + "message": "(CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=21e027c4-2ceb-449e-8eae-03dc3127e542 during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=1228 node=Node raft-double-cluster-size-with-schem-loader-node-3be1d1f3-1 [98.92.173.228 | 10.12.2.216] (Type: c6i.xlarge) (rack: RACK0)\n[2026-06-15 12:13:09.352] java.io.IOException: Operation x10 on key(s) [4d503334364c4c4f3130]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n", + "repeats": 0, + "message_chars": 619 + }, + { + "run_id": "3be1d1f3-2b5b-420d-9d50-3f854feec517", + "severity": "CRITICAL", + "event_type": "CassandraStressEvent", + "node": "Node raft-double-cluster-size-with-schem-loader-node-3be1d1f3-1 [98.92.173.228 | 10.12.2.216] (Type: c6i.xlarge) (rack: RACK0)", + "ts": "2026-06-15T12:13:12.338Z", + "message": "(CassandraStressEvent Severity.CRITICAL) period_type=end event_id=21e027c4-2ceb-449e-8eae-03dc3127e542 duration=28m4s: node=Node raft-double-cluster-size-with-schem-loader-node-3be1d1f3-1 [98.92.173.228 | 10.12.2.216] (Type: c6i.xlarge) (rack: RACK0)\nstress_cmd=cassandra-stress write cl=QUORUM n=20971520 no-warmup -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=3) compaction(strategy=LeveledCompactionStrategy)' -mode cql3 native -rate threads=80 -pop seq=1..20971520 -col 'n=FIXED(10) size=FIXED(512)' -log interval=5\nerrors:\n\nStress command completed with bad status 1: Failed to connect over JMX; not collecting these stats\ncom.datastax.driver.core.exceptions.WriteTimeoutException: Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)", + "repeats": 0, + "message_chars": 839 + }, + { + "run_id": "3be1d1f3-2b5b-420d-9d50-3f854feec517", + "severity": "ERROR", + "event_type": "DisruptionEvent", + "node": "Node raft-double-cluster-size-with-schem-db-node-3be1d1f3-1 [3.227.242.65 | 10.12.0.71] (Type: i8g.2xlarge) (rack: RACK0)", + "ts": "2026-06-15T12:13:10.150Z", + "message": "(DisruptionEvent Severity.ERROR) period_type=end event_id=6f1940be-3df6-4f70-9a2a-3a085059cdbc duration=11s: nemesis_name=GrowShrinkClusterNemesis target_node=Node raft-double-cluster-size-with-schem-db-node-3be1d1f3-1 [3.227.242.65 | 10.12.0.71] (Type: i8g.2xlarge) (rack: RACK0) errors=Killed by tearDown - test fail\nTraceback (most recent call last):\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1971, in execute_nemesis\n nemesis.disrupt()\n ~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/monkey/__init__.py\", line 48, in disrupt\n self.runner.disrupt_grow_shrink_cluster()\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4389, in disrupt_grow_shrink_cluster\n new_nodes = self._grow_cluster(rack=None)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4416, in _grow_cluster\n new_nodes = self.add_new_nodes(\n count=add_nodes_number,\n rack=rack,\n instance_type=self.tester.params.get(\"nemesis_grow_shrink_instance_type\"),\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 238, in wrapped\n res = func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 4315, in add_new_nodes\n nodes = self._add_and_init_new_cluster_nodes(count, rack=rack, instance_type=instance_type)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/__init__.py\", line 1284, in _add_and_init_new_cluster_nodes\n new_nodes = skip_on_capacity_issues(db_cluster=self.tester.db_cluster)(self.cluster.add_nodes)(\n **add_node_func_args\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/utils/decorators.py\", line 409, in wrapper\n return inner_func(*args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 1186, in add_nodes\n added_nodes = super().add_nodes(\n count=count,\n ...<6 lines>...\n **kwargs,\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/nemesis/utils/node_allocator.py\", line 295, in wrapper\n new_nodes = func(self, *args, **kwargs)\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 557, in add_nodes\n self._create_or_find_instances(\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^\n count=rack_count,\n ^^^^^^^^^^^^^^^^^\n ...<5 lines>...\n ami_id=image_id,\n ^^^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 502, in _create_or_find_instances\n return self._create_instances(\n ~~~~~~~~~~~~~~~~~~~~~~^\n count,\n ^^^^^^\n ...<5 lines>...\n ami_id=ami_id,\n ^^^^^^^^^^^^^^\n )\n ^\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 297, in _create_instances\n instances = self.fallback_provision_type(\n count,\n ...<5 lines>...\n ami_id=ami_id,\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 330, in fallback_provision_type\n instances = self._create_on_demand_instances(\n count,\n ...<5 lines>...\n ami_id=ami_id,\n )\n File \"/home/ubuntu/scylla-cluster-tests/sdcm/cluster_aws.py\", line 183, in _create_on_demand_instances\n instances = self._ec2_services[dc_idx].create_instances(**params)\n File \"/usr/local/lib/python3.14/site-packages/boto3/resources/factory.py\", line 581, in do_action\n response = action(self, *args, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/boto3/resources/action.py\", line 88, in __call__\n response = getattr(parent.meta.client, operation_name)(*args, **params)\n File \"/usr/local/lib/python3.14/site-packages/botocore/client.py\", line 602, in _api_call\n return self._make_api_call(operation_name, kwargs)\n ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/site-packages/botocore/context.py\", line 123, in wrapper\n return func(*args, **kwargs)\n File \"/usr/local/lib/python3.14/site-packages/botocore/client.py\", line 1060, in _make_api_call\n http, parsed_response = self._make_request(\n ~~~~~~~~~~~~~~~~~~^\n operation_model, request_dict, request_context\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n )\n ^\n File \"/usr/local/lib/python3.14/site-packages/botocore/client.py\", line 1084, in _make_request\n return self._endpoint.make_request(operation_model, request_dict)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/site-packages/botocore/endpoint.py\", line 119, in make_request\n return self._send_request(request_dict, operation_model)\n ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.14/site-packages/botocore/endpoint.py\", line 200, in _send_request\n while self._needs_retry(\n ~~~~~~~~~~~~~~~~~^\n attempts,\n ^^^^^^^^^\n ...<3 lines>...\n exception,\n ^^^^^^^^^^\n ):\n ^\n File \"/usr/local/lib/python3.14/site-packages/botocore/endpoint.py\", line 379, in _needs_retry\n time.sleep(handler_response)\n ~~~~~~~~~~^^^^^^^^^^^^^^^^^^\nsdcm.exceptions.KillNemesis\n", + "repeats": 0, + "message_chars": 5184 + }, + { + "run_id": "3be1d1f3-2b5b-420d-9d50-3f854feec517", + "severity": "ERROR", + "event_type": "TestFrameworkEvent", + "node": "", + "ts": "2026-06-15T12:17:41.470Z", + "message": "(TestFrameworkEvent Severity.ERROR) period_type=one-time event_id=b60c3995-bea8-4664-9abe-06dfeef6feff, source=LongevityTest.test_custom_time()\nexception=self = \n\n def run(self) -> None:\n for event_tuple in self.inbound_events():\n with verbose_suppress(\"EventsAnalyzer failed to process %s\", event_tuple):\n event_class, event = event_tuple # try to unpack event from EventsDevice\n \n # Don't kill the test cause of TestResultEvent: it was done already when this event was sent out.\n if event_class == \"TestResultEvent\" or event.severity != Severity.CRITICAL:\n continue\n \n try:\n if event_class in LOADERS_EVENTS:\n raise TestFailure(f\"Stress command failed: {event}\")\n> raise TestFailure(f\"Got critical event: {event}\")\nE sdcm.sct_events.events_analyzer.TestFailure: Got critical event: (CassandraStressLogEvent Severity.CRITICAL) period_type=one-time event_id=bbe87752-8c10-4b60-9ed3-69bc717ccfe2 during_nemesis=GrowShrinkClusterNemesis: type=OperationOnKey regex=Operation x10 on key\\(s\\) \\[ line_number=1212 node=Node raft-double-cluster-size-with-schem-loader-node-3be1d1f3-1 [98.92.173.228 | 10.12.2.216] (Type: c6i.xlarge) (rack: RACK0)\nE [2026-06-15 12:13:09.352] java.io.IOException: Operation x10 on key(s) [364d3132363238504f30]: Error executing: (WriteTimeoutException): Cassandra timeout during SIMPLE write query at consistency QUORUM (2 replica were required but only 1 acknowledged the write)\n\nsdcm/sct_events/events_analyzer.py:60: TestFailure", + "repeats": 0, + "message_chars": 1717 + } +] \ No newline at end of file diff --git a/argusAI/eval/config.example.yaml b/argusAI/eval/config.example.yaml new file mode 100644 index 000000000..498524bbe --- /dev/null +++ b/argusAI/eval/config.example.yaml @@ -0,0 +1,69 @@ +# Event Summarization — evaluation config. +# +# Everything here is configurable so the same harness prices and validates any model. +# The API key is NEVER in this file — it comes from the environment: +# export OPENAI_API_KEY=sk-... +# (override the var name with `openai_api_key_env` below.) + +# --- What to summarize ------------------------------------------------------- +# Provide explicit run UUIDs, and/or a test UUID (its recent runs are auto-listed). +# Use runs that actually have ERROR/CRITICAL events with retained message bodies. +run_ids: [] +# - 24e09748-bba4-47fd-a615-bf7ea2c425eb +# test_id: 1eb20296-99ad-4857-97d0-c62e2e1754b3 +test_run_limit: 20 # how many recent runs to scan when test_id is set +max_events: 25 # cap the unique-event set so a sweep stays cheap + +# Collapse semantically-similar events the way production does (sanitize -> BGE embed -> +# cosine distance < threshold), instead of only exact-string dedup. Gives the true canonical +# set production would summarize. Needs the 'ai-eval' extra (chromadb); downloads the BGE model. +similarity_dedup: false +similarity_threshold: 0.05 # cosine distance; matches the worker (0.05 ≈ 95% similar) + +# Reuse a previously fetched set instead of hitting Argus again (from a --fetch-only run): +# events_file: argusAI/eval/out/events.json + +# --- Models to compare ------------------------------------------------------- +# `params` are passed straight through to the API call, so each model gets the knobs +# it actually supports (reasoning_effort, max_completion_tokens, temperature, ...). +models: + - name: gpt-5-nano + params: { reasoning_effort: low } + - name: gpt-5-mini + params: { reasoning_effort: low } + - name: gpt-4.1-mini + params: { temperature: 0.2 } + +# --- Prompts to sweep (file stems from argusAI/prompts/vN_*.md) --------------- +# List several to A/B them on the same events; one is enough once a winner is picked. +# Add a new argusAI/prompts/vN_*.md file to introduce a new candidate. +prompts: + - v7_summary + # - v5_surgical + # - v6_summary + # - v1_baseline + # - v2_structured + # - v3_fielded + # - v4_adaptive + +# --- Judge (frontier model scores each summary against the ORIGINAL) ---------- +judge_enabled: true +judge_model: gpt-5 +judge_params: { reasoning_effort: medium } + +# --- Provider / infra -------------------------------------------------------- +openai_api_key_env: OPENAI_API_KEY +# openai_base_url: # set for Azure/proxy/compatible endpoints +request_timeout: 90 +max_concurrency: 4 # bounded, to respect rate limits +# argus_cli: /Users/you/bin/argus # defaults to PATH, then ~/bin/argus +no_cache: false +output_dir: argusAI/eval/out + +# --- Pricing (USD per 1M tokens) — override the placeholders with real numbers - +# Unknown models cost $0 and are flagged in the report. +pricing: + gpt-5-nano: { input_per_1m: 0.05, output_per_1m: 0.40, cached_per_1m: 0.005 } + gpt-5-mini: { input_per_1m: 0.25, output_per_1m: 2.00, cached_per_1m: 0.025 } + gpt-5: { input_per_1m: 1.25, output_per_1m: 10.00, cached_per_1m: 0.125 } + gpt-4.1-mini: { input_per_1m: 0.40, output_per_1m: 1.60, cached_per_1m: 0.10 } diff --git a/argusAI/eval/config.py b/argusAI/eval/config.py new file mode 100644 index 000000000..684d99d1a --- /dev/null +++ b/argusAI/eval/config.py @@ -0,0 +1,132 @@ +"""Evaluation config: which models, which prompts, which events, and the API key. + +Everything the design mandates be configurable (model + key, plus the prompt) lives +here. The key is never written to the config file — it comes from the ``OPENAI_API_KEY`` +environment variable (or ``openai_api_key_env`` naming a different var), matching the +existing ``*_TOKEN``/``*_SECRET`` secret conventions and keeping keys out of git. +""" + +from __future__ import annotations + +import os +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +import yaml + +from .prompts import DEFAULT_PROMPT_NAME, PROMPTS + + +@dataclass +class ModelSpec: + """One candidate to evaluate. ``params`` is passed straight to the API call, so a + reasoning model can get ``reasoning_effort`` and a classic model ``temperature`` + without special-casing anywhere in the code.""" + + name: str + params: dict[str, Any] = field(default_factory=dict) + label: str | None = None + + @property + def display(self) -> str: + return self.label or self.name + + +@dataclass +class EvalConfig: + # --- what to summarize --- + run_ids: list[str] = field(default_factory=list) + test_id: str | None = None + test_run_limit: int = 20 + max_events: int | None = 30 + events_file: Path | None = None # reuse a saved events.json instead of refetching + similarity_dedup: bool = False # collapse semantically-similar events (mirrors production) + similarity_threshold: float = 0.05 # cosine distance; matches the worker + + # --- how to summarize --- + models: list[ModelSpec] = field(default_factory=list) + prompt_names: list[str] = field(default_factory=lambda: [DEFAULT_PROMPT_NAME]) + + # --- judging --- + judge_enabled: bool = True + judge_model: str = "gpt-5" + judge_params: dict[str, Any] = field(default_factory=dict) + + # --- provider / secrets --- + openai_api_key_env: str = "OPENAI_API_KEY" + openai_base_url: str | None = None + request_timeout: float = 90.0 + max_concurrency: int = 4 + + # --- infra --- + argus_cli: str | None = None + no_cache: bool = False + output_dir: Path = Path("argusAI/eval/out") + pricing: dict[str, dict] = field(default_factory=dict) + + @property + def api_key(self) -> str: + key = os.environ.get(self.openai_api_key_env, "") + if not key: + raise RuntimeError( + f"No API key found in environment variable '{self.openai_api_key_env}'. " + f"Export it, e.g.: export {self.openai_api_key_env}=sk-..." + ) + return key + + def resolved_prompts(self) -> dict[str, str]: + out: dict[str, str] = {} + for name in self.prompt_names: + if name not in PROMPTS: + raise KeyError(f"Unknown prompt '{name}'. Known: {sorted(PROMPTS)}") + out[name] = PROMPTS[name] + return out + + @classmethod + def from_yaml(cls, path: str | Path) -> "EvalConfig": + raw = yaml.safe_load(Path(path).read_text(encoding="utf-8")) or {} + return cls.from_dict(raw) + + @classmethod + def from_dict(cls, raw: dict) -> "EvalConfig": + models = [ + ModelSpec( + name=m["name"] if isinstance(m, dict) else m, + params=(m.get("params", {}) if isinstance(m, dict) else {}), + label=(m.get("label") if isinstance(m, dict) else None), + ) + for m in raw.get("models", []) + ] + displays = [m.display for m in models] + collisions = sorted({d for d in displays if displays.count(d) > 1}) + if collisions: + raise ValueError( + f"Duplicate model display name(s): {', '.join(collisions)}. Give each entry a distinct " + "'label' so configs of the same model (e.g. different params) don't merge into one series." + ) + cfg = cls( + run_ids=list(raw.get("run_ids", [])), + test_id=raw.get("test_id"), + test_run_limit=int(raw.get("test_run_limit", 20)), + max_events=raw.get("max_events", 30), + events_file=(Path(raw["events_file"]) if raw.get("events_file") else None), + similarity_dedup=bool(raw.get("similarity_dedup", False)), + similarity_threshold=float(raw.get("similarity_threshold", 0.05)), + models=models, + prompt_names=list(raw.get("prompts", [DEFAULT_PROMPT_NAME])), + judge_enabled=bool(raw.get("judge_enabled", True)), + judge_model=raw.get("judge_model", "gpt-5"), + judge_params=dict(raw.get("judge_params", {})), + openai_api_key_env=raw.get("openai_api_key_env", "OPENAI_API_KEY"), + openai_base_url=raw.get("openai_base_url"), + request_timeout=float(raw.get("request_timeout", 90.0)), + max_concurrency=int(raw.get("max_concurrency", 4)), + argus_cli=raw.get("argus_cli"), + no_cache=bool(raw.get("no_cache", False)), + output_dir=Path(raw.get("output_dir", "argusAI/eval/out")), + pricing=dict(raw.get("pricing", {})), + ) + if not cfg.models: + raise ValueError("Config must list at least one model under 'models'") + return cfg diff --git a/argusAI/eval/dedup.py b/argusAI/eval/dedup.py new file mode 100644 index 000000000..383d1297b --- /dev/null +++ b/argusAI/eval/dedup.py @@ -0,0 +1,60 @@ +"""Semantic (embedding) deduplication for the eval, mirroring the production worker. + +The harness's default collection dedups by exact message string, but production +(event_similarity_processor_v2) dedups by *similarity*: it embeds the sanitized message +with BGE-small-en and treats two events as the same when their cosine distance is < 0.05 +(i.e. > 0.95 similarity). This module runs that same pipeline — via the shared +``EventEmbedder`` the worker uses — over a collected set, so the eval measures the true +canonical set production would summarize. + +Collapsed events are merged into the canonical's ``repeats`` count (as production folds +duplicates under the canonical), and only canonicals are returned. +""" + +from __future__ import annotations + +import logging + +from chromadb.utils.distance_functions import cosine +from numpy import array + +from argusAI.utils.embedding import EventEmbedder + +from .events_source import EventSample + +LOGGER = logging.getLogger(__name__) + +# Production's duplicate threshold (event_similarity_processor_v2.py): cosine distance +# below this means "same event". Distance is 1 - cosine similarity, so 0.05 ≈ 95% similar. +DEFAULT_DISTANCE_THRESHOLD = 0.05 + + +def deduplicate_by_similarity( + events: list[EventSample], threshold: float = DEFAULT_DISTANCE_THRESHOLD +) -> list[EventSample]: + """Collapse semantically-similar events into their first-seen canonical, using the same + sanitize→embed pipeline as the worker. Returns only the canonicals, each with absorbed + duplicates added to its ``repeats``.""" + if len(events) < 2: + return events + + embeddings = [array(v, dtype=float) for v in EventEmbedder(write_log=False).embed_many([e.message for e in events])] + + canonicals: list[int] = [] # indices of kept events + collapsed = 0 + for i, emb in enumerate(embeddings): + match = next((c for c in canonicals if cosine(emb, embeddings[c]) < threshold), None) + if match is None: + canonicals.append(i) + else: + events[match].repeats += 1 + events[i].repeats + collapsed += 1 + + LOGGER.info( + "Similarity dedup: %d events -> %d canonical (collapsed %d near-duplicates, threshold %.3f)", + len(events), + len(canonicals), + collapsed, + threshold, + ) + return [events[c] for c in canonicals] diff --git a/argusAI/eval/events_source.py b/argusAI/eval/events_source.py new file mode 100644 index 000000000..30dffed28 --- /dev/null +++ b/argusAI/eval/events_source.py @@ -0,0 +1,205 @@ +"""Pull real SCT ERROR/CRITICAL events out of Argus via the ``argus`` CLI. + +We shell out to the CLI rather than talking to ScyllaDB directly so the harness can +run anywhere the operator's CLI is already authenticated (keychain creds), with no DB +credentials, no Flask config, and no VPN to the cluster. It is exactly the interface a +human uses to look at a run, which keeps the evaluation honest about what data is +actually reachable. + +Only the canonical (deduplicated) events are summarized in production — the CLI +already deduplicates server-side (``run events`` collapses repeats into +``repeated_at``), so what we fetch here mirrors the production input set. +""" + +from __future__ import annotations + +import json +import logging +import os +import shutil +import subprocess +from dataclasses import dataclass, field +from pathlib import Path + +LOGGER = logging.getLogger(__name__) + + +def _resolve_cli(explicit: str | None) -> str: + """Locate the argus binary: explicit override, then PATH, then ~/bin/argus.""" + if explicit: + return explicit + on_path = shutil.which("argus") + if on_path: + return on_path + fallback = Path.home() / "bin" / "argus" + if fallback.exists(): + return str(fallback) + raise FileNotFoundError( + "Could not find the 'argus' CLI on PATH or at ~/bin/argus. Set 'argus_cli' in the eval config to its full path." + ) + + +@dataclass +class EventSample: + """One event to summarize, plus the provenance needed to trace it back to Argus.""" + + run_id: str + severity: str + event_type: str + node: str + ts: str + message: str + repeats: int = 0 + + @property + def message_chars(self) -> int: + return len(self.message) + + def key(self) -> str: + """Dedup key: identical message text is the same summarization input, no matter + which run surfaced it — matches production, where the summary is per unique event.""" + return self.message.strip() + + def to_dict(self) -> dict: + return { + "run_id": self.run_id, + "severity": self.severity, + "event_type": self.event_type, + "node": self.node, + "ts": self.ts, + "message": self.message, + "repeats": self.repeats, + "message_chars": self.message_chars, + } + + @classmethod + def from_dict(cls, d: dict) -> "EventSample": + return cls( + run_id=d.get("run_id", ""), + severity=d.get("severity", ""), + event_type=d.get("event_type", ""), + node=d.get("node", ""), + ts=d.get("ts", ""), + message=d.get("message", ""), + repeats=d.get("repeats", 0), + ) + + +@dataclass +class EventFetcher: + argus_cli: str | None = None + no_cache: bool = False + severities: tuple[str, ...] = ("CRITICAL", "ERROR") + # The CLI's `run events --limit` is applied per severity level (and only ever returns + # CRITICAL/ERROR), so this is an upper bound on events fetched per severity, per run. + per_severity_limit: int = 100 + timeout: float = 120.0 # per CLI invocation; a hung/auth-blocked CLI must not hang the sweep + _cli: str = field(init=False, default="") + + def __post_init__(self): + self._cli = _resolve_cli(self.argus_cli) + + def _run(self, args: list[str]) -> list[dict]: + cmd = [self._cli, *args, "--non-interactive"] + if self.no_cache: + cmd.append("--no-cache") + LOGGER.debug("Running: %s", " ".join(cmd)) + try: + proc = subprocess.run(cmd, capture_output=True, text=True, check=False, timeout=self.timeout) + except subprocess.TimeoutExpired: + LOGGER.warning("argus CLI timed out after %.0fs: %s", self.timeout, " ".join(cmd)) + return [] + if proc.returncode != 0: + LOGGER.warning("argus CLI failed (%s): %s", proc.returncode, proc.stderr.strip()[:400]) + return [] + out = proc.stdout.strip() + if not out: + return [] + try: + data = json.loads(out) + except json.JSONDecodeError: + LOGGER.warning("Could not parse argus output as JSON: %s", out[:200]) + return [] + return data if isinstance(data, list) else [] + + def events_for_run(self, run_id: str) -> list[EventSample]: + rows = self._run(["run", "events", "--run-id", run_id, "--limit", str(self.per_severity_limit)]) + samples: list[EventSample] = [] + for row in rows: + severity = row.get("severity", "") + if severity not in self.severities: + continue + message = row.get("message") or "" + if not message.strip(): + continue + samples.append( + EventSample( + run_id=run_id, + severity=severity, + event_type=row.get("event_type", ""), + node=row.get("node", "") or "", + ts=row.get("ts", ""), + message=message, + repeats=len(row.get("repeated_at") or []), + ) + ) + LOGGER.info("Run %s: %d ERROR/CRITICAL events", run_id, len(samples)) + return samples + + def run_ids_for_test(self, test_id: str, limit: int) -> list[str]: + rows = self._run(["run", "list", "--test-id", test_id, "--limit", str(limit)]) + return [r["id"] for r in rows if r.get("id")] + + def collect( + self, + run_ids: list[str] | None = None, + test_id: str | None = None, + test_run_limit: int = 20, + max_events: int | None = None, + ) -> list[EventSample]: + """Gather deduplicated events from an explicit run list and/or a whole test. + + Events are deduplicated by message text across all runs (production summarizes + each unique event once); ``max_events`` caps the set so a sweep stays cheap. + """ + target_runs: list[str] = list(run_ids or []) + if test_id: + discovered = self.run_ids_for_test(test_id, test_run_limit) + LOGGER.info("Test %s: discovered %d runs", test_id, len(discovered)) + target_runs.extend(r for r in discovered if r not in target_runs) + + seen: set[str] = set() + collected: list[EventSample] = [] + for run_id in target_runs: + for sample in self.events_for_run(run_id): + k = sample.key() + if k in seen: + continue + seen.add(k) + collected.append(sample) + if max_events and len(collected) >= max_events: + LOGGER.info("Reached max_events=%d, stopping collection", max_events) + return collected + return collected + + +def save_events(samples: list[EventSample], path: Path) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps([s.to_dict() for s in samples], indent=2), encoding="utf-8") + LOGGER.info("Saved %d events to %s", len(samples), path) + + +def load_events(path: Path) -> list[EventSample]: + data = json.loads(Path(path).read_text(encoding="utf-8")) + return [EventSample.from_dict(d) for d in data] + + +def load_events_from_env_or_file(path: Path | None) -> list[EventSample]: + """Convenience for offline iteration: load a hand-curated events.json when the + CLI/Argus isn't reachable (e.g. developing the report on a plane).""" + if path and path.exists(): + return load_events(path) + env_path = os.environ.get("ARGUS_EVAL_EVENTS") + if env_path and Path(env_path).exists(): + return load_events(Path(env_path)) + return [] diff --git a/argusAI/eval/harness.py b/argusAI/eval/harness.py new file mode 100644 index 000000000..230ba735c --- /dev/null +++ b/argusAI/eval/harness.py @@ -0,0 +1,184 @@ +"""Orchestrator: events × models × prompts → summaries → judge → results.json. + +The unit of work is one (event, model, prompt) triple. All triples are independent, so +they run on a bounded thread pool (``max_concurrency``) — the same rate-limit guard the +production worker uses. A failed triple is recorded with its error and never aborts the +sweep, so one flaky model or one oversized event can't sink a whole run. +""" + +from __future__ import annotations + +import json +import logging +from concurrent.futures import ThreadPoolExecutor, as_completed +from datetime import datetime, timezone +from pathlib import Path + +import tiktoken + +from argusAI.utils.summarizer import Summarizer, SummarizerError + +from .config import EvalConfig, ModelSpec +from .events_source import EventFetcher, EventSample, load_events, save_events +from .judge import Judge +from .pricing import PricingBook +from .results import CellResult, JudgeScore + +LOGGER = logging.getLogger(__name__) + +_ENCODERS: dict[str, tiktoken.Encoding] = {} + + +def _count_tokens(model: str, text: str) -> int: + """Token count under the model's encoding, so compression is measured in the unit we pay for. + Falls back to o200k_base (GPT-4o/5 family) for models tiktoken does not yet know.""" + if not text: + return 0 + enc = _ENCODERS.get(model) + if enc is None: + try: + enc = tiktoken.encoding_for_model(model) + except KeyError: + enc = tiktoken.get_encoding("o200k_base") + _ENCODERS[model] = enc + return len(enc.encode(text)) + + +class EvalHarness: + def __init__(self, config: EvalConfig): + self.cfg = config + self.summarizer = Summarizer( + api_key=config.api_key, + base_url=config.openai_base_url, + timeout=config.request_timeout, + ) + self.pricing = PricingBook(config.pricing) + self.judge = Judge(self.summarizer, config.judge_model, config.judge_params) + + # -- data --------------------------------------------------------------- + def gather_events(self) -> list[EventSample]: + if self.cfg.events_file and Path(self.cfg.events_file).exists(): + events = load_events(Path(self.cfg.events_file)) + LOGGER.info("Loaded %d events from %s", len(events), self.cfg.events_file) + if self.cfg.max_events: + events = events[: self.cfg.max_events] + return self._maybe_dedup(events) + fetcher = EventFetcher(argus_cli=self.cfg.argus_cli, no_cache=self.cfg.no_cache) + events = fetcher.collect( + run_ids=self.cfg.run_ids, + test_id=self.cfg.test_id, + test_run_limit=self.cfg.test_run_limit, + max_events=self.cfg.max_events, + ) + events = self._maybe_dedup(events) + if events: + save_events(events, self.cfg.output_dir / "events.json") + return events + + def _maybe_dedup(self, events: list[EventSample]) -> list[EventSample]: + """Collapse semantically-similar events (mirrors production) when enabled.""" + if not self.cfg.similarity_dedup: + return events + from .dedup import deduplicate_by_similarity # noqa: PLC0415 - lazy: pulls in chromadb, an optional ('ai-eval') dep + + return deduplicate_by_similarity(events, self.cfg.similarity_threshold) + + # -- one cell ----------------------------------------------------------- + def _summarize_cell(self, event: EventSample, model: ModelSpec, prompt_name: str, prompt: str) -> CellResult: + cell = CellResult( + event_key=event.key(), + run_id=event.run_id, + event_type=event.event_type, + node=event.node, + severity=event.severity, + model=model.name, + model_label=model.display, + prompt_name=prompt_name, + input_chars=event.message_chars, + summary_chars=0, + input_tokens=_count_tokens(model.name, event.message), + ) + try: + res = self.summarizer.summarize(model.name, event.message, prompt=prompt, **model.params) + except SummarizerError as exc: + cell.error = str(exc) + LOGGER.warning("summarize failed [%s/%s]: %s", model.name, prompt_name, exc) + return cell + cell.summary = res.summary + cell.summary_chars = len(res.summary) + cell.summary_tokens = _count_tokens(model.name, res.summary) + cell.prompt_tokens = res.prompt_tokens + cell.completion_tokens = res.completion_tokens + cell.cached_tokens = res.cached_tokens + cell.latency_ms = res.latency_ms + cell.cost_usd = self.pricing.cost(model.name, res.prompt_tokens, res.completion_tokens, res.cached_tokens) + if self.cfg.judge_enabled: + # Judge.score never raises; the guard is belt-and-suspenders so one bad judge + # can't sink the sweep even if that contract regresses. + try: + cell.judge = self.judge.score(event.message, res.summary) + except Exception as exc: # noqa: BLE001 + cell.judge = JudgeScore(error=f"judge crashed: {exc}") + LOGGER.warning("judge crashed [%s/%s]: %s", model.name, prompt_name, exc) + return cell + + # -- sweep -------------------------------------------------------------- + def run(self) -> dict: + events = self.gather_events() + if not events: + raise RuntimeError( + "No events to evaluate. Provide run_ids/test_id that have ERROR/CRITICAL " + "events with retained message bodies, or point events_file at a saved set." + ) + prompts = self.cfg.resolved_prompts() + jobs = [ + (event, model, pname, ptext) + for event in events + for model in self.cfg.models + for pname, ptext in prompts.items() + ] + LOGGER.info( + "Sweeping %d events × %d models × %d prompts = %d cells (concurrency %d)", + len(events), + len(self.cfg.models), + len(prompts), + len(jobs), + self.cfg.max_concurrency, + ) + cells: list[CellResult] = [] + out_path = self.cfg.output_dir / "results.json" + + def _persist() -> dict: + results = { + "generated_at": datetime.now(timezone.utc).isoformat(), + "prompts": prompts, + "models": [m.display for m in self.cfg.models], + "judge_model": self.cfg.judge_model if self.cfg.judge_enabled else None, + "num_events": len(events), + "unknown_priced_models": sorted({m.name for m in self.cfg.models if not self.pricing.has(m.name)}), + "default_priced_models": sorted({m.name for m in self.cfg.models if self.pricing.is_default(m.name)}), + "events": [e.to_dict() for e in events], + "cells": [c.to_dict() for c in cells], + } + out_path.parent.mkdir(parents=True, exist_ok=True) + out_path.write_text(json.dumps(results, indent=2), encoding="utf-8") + return results + + # Persist whatever completed even on Ctrl-C / unexpected crash, so paid API calls + # already made are never lost (the per-cell paths above already can't raise). + done = 0 + try: + with ThreadPoolExecutor(max_workers=self.cfg.max_concurrency) as pool: + futures = {pool.submit(self._summarize_cell, *job): job for job in jobs} + for future in as_completed(futures): + try: + cells.append(future.result()) + except Exception as exc: # noqa: BLE001 - belt-and-suspenders + LOGGER.error("cell task raised unexpectedly, skipping: %s", exc) + done += 1 + if done % 10 == 0 or done == len(jobs): + LOGGER.info(" %d/%d cells done", done, len(jobs)) + finally: + results = _persist() + LOGGER.info("Wrote %d cells to %s", len(cells), out_path) + return results diff --git a/argusAI/eval/judge.py b/argusAI/eval/judge.py new file mode 100644 index 000000000..7a44902b2 --- /dev/null +++ b/argusAI/eval/judge.py @@ -0,0 +1,106 @@ +"""LLM-as-judge: score one summary against its original event. + +Everything about judging lives here — the prompt, the call, and the tolerant parsing of +the model's JSON reply — so the concept is one cohesive unit rather than being smeared +across the orchestrator and the prompt module. + +A frontier model scores each candidate summary against the ORIGINAL event (not against a +reference summary): the question is "did we lose information?", which the original answers +directly, without a second layer of model opinion. +""" + +from __future__ import annotations + +import json +import logging +from typing import Any + +from argusAI.prompts import JUDGE_PROMPT_NAME, load_prompt +from argusAI.utils.summarizer import Summarizer, SummarizerError + +from .results import JudgeScore + +LOGGER = logging.getLogger(__name__) + +JUDGE_SYSTEM = load_prompt(JUDGE_PROMPT_NAME) + + +def _judge_user(original: str, summary: str) -> str: + return f"=== ORIGINAL EVENT ===\n{original}\n\n=== CANDIDATE SUMMARY ===\n{summary}\n\nScore it." + + +def _coerce_score(value: object) -> int | None: + """Coerce a judge-supplied score to int without ever raising, or None when the field is + absent or non-numeric — models sometimes return null, "85", or "high". None lets the + caller tell a real 0 apart from a missing score.""" + try: + return int(value) # type: ignore[arg-type] + except (TypeError, ValueError): + try: + return int(float(value)) # type: ignore[arg-type] + except (TypeError, ValueError): + return None + + +def _to_int(value: object, default: int = 0) -> int: + parsed = _coerce_score(value) + return parsed if parsed is not None else default + + +def _as_str_list(value: object) -> list[str]: + """Coerce a judge-supplied list field to list[str]; tolerate a bare scalar or null.""" + if isinstance(value, list): + return [str(x) for x in value] + if value in (None, "", 0): + return [] + return [str(value)] + + +def parse_judge(raw: str) -> JudgeScore: + """Judge models are asked for bare JSON but sometimes wrap it or add trailing prose. + Decode the first JSON object and ignore anything after it; never raise — a bad judge + response must degrade to JudgeScore(error=...), not abort the sweep.""" + start = raw.find("{") + if start == -1: + return JudgeScore(error=f"no JSON in judge output: {raw[:120]}") + try: + # raw_decode stops at the end of the first value, so trailing text (or braces + # inside string values) can't over-capture the way a greedy regex would. + data, _ = json.JSONDecoder().raw_decode(raw[start:]) + except json.JSONDecodeError as exc: + return JudgeScore(error=f"judge JSON parse failed: {exc}") + if not isinstance(data, dict): + return JudgeScore(error=f"judge JSON was not an object: {type(data).__name__}") + scores = {field: _coerce_score(data.get(field)) for field in ("coverage", "faithfulness", "conciseness")} + if all(v is None for v in scores.values()): + # An object with no usable numeric score is an unjudged cell, not a genuine 0 — + # scoring it 0 would drag the model's average down instead of excluding it. + return JudgeScore(error=f"judge returned no numeric scores: {raw[start : start + 120]}") + return JudgeScore( + coverage=scores["coverage"] or 0, + faithfulness=scores["faithfulness"] or 0, + conciseness=scores["conciseness"] or 0, + dropped_critical=_as_str_list(data.get("dropped_critical")), + hallucinations=_as_str_list(data.get("hallucinations")), + verdict=str(data.get("verdict", "")), + ) + + +class Judge: + """Scores summaries with one frontier model. Reuses the harness's Summarizer client so + there's a single OpenAI connection for the whole sweep.""" + + def __init__(self, summarizer: Summarizer, model: str, params: dict[str, Any] | None = None): + self._summarizer = summarizer + self._model = model + self._params = params or {} + + def score(self, original: str, summary: str) -> JudgeScore: + """Never raises: a provider error or unparseable reply becomes JudgeScore(error=...).""" + try: + raw = self._summarizer.raw_completion( + self._model, JUDGE_SYSTEM, _judge_user(original, summary), **self._params + ) + except SummarizerError as exc: + return JudgeScore(error=str(exc)) + return parse_judge(raw) diff --git a/argusAI/eval/metrics.py b/argusAI/eval/metrics.py new file mode 100644 index 000000000..1b65330a0 --- /dev/null +++ b/argusAI/eval/metrics.py @@ -0,0 +1,103 @@ +"""Aggregation over result cells — the analysis layer between raw cells and the report. + +One place computes means over judge fields, so the charts, the summary table, and the +per-prompt breakdown all agree. Everything here reads the serialized cell dicts (as loaded +from results.json), not live objects, so it works equally on a fresh sweep or a saved run. +""" + +from __future__ import annotations + +from collections import defaultdict +from dataclasses import dataclass +from statistics import mean + + +@dataclass +class SeriesStats: + """Aggregated metrics for one series (a model, or a model·prompt pair).""" + + key: str + model: str + prompt_name: str + n: int + errors: int + avg_coverage: float + avg_faithfulness: float + avg_conciseness: float + avg_overall: float + avg_cost: float + avg_compression: float + avg_latency_ms: float + avg_completion_tokens: float + total_dropped: int + total_hallucinations: int + + +def _judged_avg(cells: list[dict], field: str) -> float: + """Average one judge field over every successfully-judged cell (skips errored/unjudged); + 0.0 when nothing was judged.""" + vals = [float(c["judge"].get(field, 0)) for c in cells if c.get("judge") and c["judge"].get("error") is None] + return mean(vals) if vals else 0.0 + + +def _count(cells: list[dict], field: str) -> int: + return sum(len((c.get("judge") or {}).get(field, []) or []) for c in cells) + + +def _avg(cells: list[dict], field: str, default: float = 0.0) -> float: + vals = [c.get(field, default) for c in cells] + return mean(vals) if vals else default + + +def _series_stats(key: str, model: str, prompt_name: str, cells: list[dict]) -> SeriesStats: + ok = [c for c in cells if not c.get("error")] + return SeriesStats( + key=key, + model=model, + prompt_name=prompt_name, + n=len(ok), + errors=len(cells) - len(ok), + avg_coverage=_judged_avg(ok, "coverage"), + avg_faithfulness=_judged_avg(ok, "faithfulness"), + avg_conciseness=_judged_avg(ok, "conciseness"), + avg_overall=_judged_avg(ok, "overall"), + avg_cost=_avg(ok, "cost_usd"), + avg_compression=_avg(ok, "compression_ratio"), + avg_latency_ms=_avg(ok, "latency_ms"), + avg_completion_tokens=_avg(ok, "completion_tokens"), + total_dropped=_count(ok, "dropped_critical"), + total_hallucinations=_count(ok, "hallucinations"), + ) + + +def aggregate_series(results: dict) -> tuple[list[SeriesStats], bool]: + """Group cells into series (model, or model·prompt when several prompts are present), + best-overall first. Returns (stats, multi_prompt).""" + cells = results.get("cells", []) + multi_prompt = len({c["prompt_name"] for c in cells}) > 1 + buckets: dict[str, list[dict]] = defaultdict(list) + labels: dict[str, tuple[str, str]] = {} + for c in cells: + model = c.get("model_label") or c["model"] + key = f"{model} · {c['prompt_name']}" if multi_prompt else model + buckets[key].append(c) + labels[key] = (model, c["prompt_name"]) + + stats = [_series_stats(key, *labels[key], cs) for key, cs in buckets.items()] + stats.sort(key=lambda s: s.avg_overall, reverse=True) + return stats, multi_prompt + + +def prompt_stat_line(cells: list[dict]) -> tuple[str, float]: + """(display stat, sort key) for one prompt's scored cells; sort key -1 when unscored.""" + if not cells: + return "not scored in this run", -1.0 + q = mean(c["judge"]["overall"] for c in cells) + stat = ( + f"Q {q:.1f} · coverage {mean(c['judge']['coverage'] for c in cells):.0f} · " + f"faithful {mean(c['judge']['faithfulness'] for c in cells):.0f} · " + f"size {mean(c['compression_ratio'] for c in cells) * 100:.0f}% of original · " + f"{_count(cells, 'dropped_critical')} dropped · " + f"{_count(cells, 'hallucinations')} hallucinated" + ) + return stat, q diff --git a/argusAI/eval/pricing.py b/argusAI/eval/pricing.py new file mode 100644 index 000000000..5c322b84f --- /dev/null +++ b/argusAI/eval/pricing.py @@ -0,0 +1,65 @@ +"""Token pricing → dollar cost. + +Prices change and new models appear, so the table is a *default* the config can extend +or override (``pricing:`` block). Values are USD per 1M tokens. ``cached`` is the +discounted input rate applied to ``cached_tokens`` (prompt caching); when a model has no +separate cached rate it falls back to the input rate. + +These defaults are placeholders — set the real numbers in your config before trusting the +cost axis of the report. Unknown models cost 0 and are flagged in the report so a missing +price never silently reads as "free". +""" + +from __future__ import annotations + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class ModelPrice: + input_per_1m: float + output_per_1m: float + cached_per_1m: float | None = None + + def cost(self, prompt_tokens: int, completion_tokens: int, cached_tokens: int = 0) -> float: + cached_rate = self.cached_per_1m if self.cached_per_1m is not None else self.input_per_1m + fresh_input = max(prompt_tokens - cached_tokens, 0) + return ( + fresh_input * self.input_per_1m + cached_tokens * cached_rate + completion_tokens * self.output_per_1m + ) / 1_000_000.0 + + +# Placeholder defaults — override in config with real, current prices. +DEFAULT_PRICING: dict[str, ModelPrice] = { + "gpt-5-mini": ModelPrice(input_per_1m=0.25, output_per_1m=2.00, cached_per_1m=0.025), + "gpt-5-nano": ModelPrice(input_per_1m=0.05, output_per_1m=0.40, cached_per_1m=0.005), + "gpt-5": ModelPrice(input_per_1m=1.25, output_per_1m=10.00, cached_per_1m=0.125), + "gpt-5.5": ModelPrice(input_per_1m=2.00, output_per_1m=16.00, cached_per_1m=0.20), + "gpt-4.1-mini": ModelPrice(input_per_1m=0.40, output_per_1m=1.60, cached_per_1m=0.10), +} + + +class PricingBook: + def __init__(self, overrides: dict[str, dict] | None = None): + self._book: dict[str, ModelPrice] = dict(DEFAULT_PRICING) + self._overridden: set[str] = set(overrides or {}) + for model, vals in (overrides or {}).items(): + self._book[model] = ModelPrice( + input_per_1m=float(vals["input_per_1m"]), + output_per_1m=float(vals["output_per_1m"]), + cached_per_1m=(float(vals["cached_per_1m"]) if vals.get("cached_per_1m") is not None else None), + ) + + def has(self, model: str) -> bool: + return model in self._book + + def is_default(self, model: str) -> bool: + """True when the model is priced only from the built-in placeholder table (not the + config's ``pricing:`` block), so its cost figures are unvetted and worth flagging.""" + return model in self._book and model not in self._overridden + + def cost(self, model: str, prompt_tokens: int, completion_tokens: int, cached_tokens: int = 0) -> float: + price = self._book.get(model) + if price is None: + return 0.0 + return price.cost(prompt_tokens, completion_tokens, cached_tokens) diff --git a/argusAI/eval/prompts.py b/argusAI/eval/prompts.py new file mode 100644 index 000000000..355f5f58a --- /dev/null +++ b/argusAI/eval/prompts.py @@ -0,0 +1,7 @@ +from __future__ import annotations + +from argusAI.prompts import PRODUCTION_PROMPT_NAME, load_summary_prompts + +PROMPTS: dict[str, str] = load_summary_prompts() + +DEFAULT_PROMPT_NAME = PRODUCTION_PROMPT_NAME diff --git a/argusAI/eval/report.py b/argusAI/eval/report.py new file mode 100644 index 000000000..964ea8c58 --- /dev/null +++ b/argusAI/eval/report.py @@ -0,0 +1,358 @@ +"""Render results.json into a self-contained, presentable HTML report. + +Two things the reviewers asked to *see* (PR #1016): a decision graph comparing models, +and the actual summaries so a human can judge whether information was lost. This module +produces both in one standalone HTML file (no external assets, no JS dependency, works +offline and in light/dark) so it can be opened, screenshotted into a deck, or published +as an Artifact. + +Charts are hand-rolled inline SVG following the dataviz method: thin marks, baseline- +anchored rounded bars, selective direct labels, a legend for >1 series, recessive axes, +and the colorblind-safe Okabe-Ito categorical palette (validated for all CVD types). +The headline is a quality-vs-cost scatter — "the cheapest model that is good enough". +""" + +from __future__ import annotations + +import html +import json +import logging +from collections import defaultdict +from pathlib import Path + +from .metrics import SeriesStats, aggregate_series, prompt_stat_line + +LOGGER = logging.getLogger(__name__) + +# Okabe-Ito qualitative palette — assigned in fixed order, never cycled. +PALETTE = ["#0072B2", "#E69F00", "#009E73", "#D55E00", "#CC79A7", "#56B4E9", "#F0E442", "#000000"] + + +# --- tiny SVG helpers ------------------------------------------------------- + + +def _hbar(title: str, rows: list[tuple[str, float, str]], vmax: float, unit: str, fmt: str = "{:.1f}") -> str: + """Horizontal bar chart. rows = [(label, value, color)]. Direct value labels.""" + row_h, gap, left, right, top = 26, 10, 160, 70, 34 + width = 720 + plot_w = width - left - right + height = top + len(rows) * (row_h + gap) + vmax = vmax or 1.0 + bars = [] + for i, (label, value, color) in enumerate(rows): + y = top + i * (row_h + gap) + w = max(2.0, plot_w * (value / vmax)) + bars.append( + f'{html.escape(label)}' + f'' + f'{fmt.format(value)}{unit}' + ) + return ( + f'
{html.escape(title)}
' + f'' + f"{''.join(bars)}
" + ) + + +def _scatter(title: str, points: list[tuple[str, float, float, str]], xlabel: str, ylabel: str) -> str: + """Quality (y) vs cost (x) scatter. points = [(label, x, y, color)].""" + width, height = 720, 420 + left, right, top, bottom = 64, 130, 34, 54 + plot_w, plot_h = width - left - right, height - top - bottom + xs = [p[1] for p in points] or [0.0] + ymax = 100.0 + xmax = max(xs) * 1.15 or 1.0 + marks = [] + # y gridlines at 0/25/50/75/100 + for gy in (0, 25, 50, 75, 100): + yy = top + plot_h * (1 - gy / ymax) + marks.append( + f'' + f'{gy}' + ) + for label, x, y, color in points: + px = left + plot_w * (x / xmax) + py = top + plot_h * (1 - y / ymax) + marks.append( + f'' + f'{html.escape(label)}' + ) + return ( + f'
{html.escape(title)}
' + f'' + f'' + f'' + f'{html.escape(xlabel)}' + f'{html.escape(ylabel)}' + f"{''.join(marks)}
" + ) + + +_CSS = """ +:root{--surface:#ffffff;--ink:#1a1a1a;--ink-2:#555;--muted:#888;--grid:#e6e6e6;--axis:#bbb;--card:#f7f7f8;--border:#e2e2e5;} +@media (prefers-color-scheme:dark){:root{--surface:#16181d;--ink:#e8e8ea;--ink-2:#aeb0b6;--muted:#7d808a;--grid:#2a2d34;--axis:#3a3d45;--card:#1e2129;--border:#2c2f37;}} +:root[data-theme=dark]{--surface:#16181d;--ink:#e8e8ea;--ink-2:#aeb0b6;--muted:#7d808a;--grid:#2a2d34;--axis:#3a3d45;--card:#1e2129;--border:#2c2f37;} +:root[data-theme=light]{--surface:#ffffff;--ink:#1a1a1a;--ink-2:#555;--muted:#888;--grid:#e6e6e6;--axis:#bbb;--card:#f7f7f8;--border:#e2e2e5;} +*{box-sizing:border-box}body{margin:0;background:var(--surface);color:var(--ink);font:15px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;padding:32px;max-width:1180px;margin:0 auto} +h1{font-size:24px;margin:0 0 4px}h2{font-size:18px;margin:36px 0 12px;border-bottom:1px solid var(--border);padding-bottom:6px} +.meta{color:var(--ink-2);font-size:13px;margin-bottom:8px} +.charts{display:flex;flex-wrap:wrap;gap:20px} +.chart{background:var(--card);border:1px solid var(--border);border-radius:10px;padding:14px 16px;margin:0;flex:1 1 340px} +.chart.wide{flex-basis:100%}figcaption{font-weight:600;font-size:14px;margin-bottom:8px} +svg{width:100%;height:auto;overflow:visible} +.lbl{fill:var(--ink);font-size:12px}.val{fill:var(--ink-2);font-size:12px}.tick{fill:var(--muted);font-size:11px} +.pt-lbl{fill:var(--ink);font-size:12px}.axis{stroke:var(--axis);stroke-width:1}.grid{stroke:var(--grid);stroke-width:1} +.axis-lbl{fill:var(--ink-2);font-size:12px} +table{border-collapse:collapse;width:100%;font-size:13px;margin-top:8px} +th,td{text-align:right;padding:7px 10px;border-bottom:1px solid var(--border)}th:first-child,td:first-child{text-align:left} +th{color:var(--ink-2);font-weight:600}tbody tr:first-child td{font-weight:600} +.legend{display:flex;flex-wrap:wrap;gap:14px;margin:6px 0 2px;font-size:13px} +.legend span{display:inline-flex;align-items:center;gap:6px}.sw{width:12px;height:12px;border-radius:3px;display:inline-block} +.event{border:1px solid var(--border);border-radius:10px;margin:14px 0;overflow:hidden} +.event>summary{cursor:pointer;padding:12px 16px;background:var(--card);font-weight:600;list-style:none} +.event>summary::-webkit-details-marker{display:none} +.ev-body{padding:12px 16px} +.orig{white-space:pre-wrap;background:var(--card);border:1px solid var(--border);border-radius:8px;padding:10px;font:12px/1.45 ui-monospace,SFMono-Regular,Menlo,monospace;max-height:280px;overflow:auto} +.sums{display:flex;flex-wrap:wrap;gap:12px;margin-top:12px} +.sum{flex:1 1 300px;border:1px solid var(--border);border-radius:8px;padding:10px} +.sum h4{margin:0 0 6px;font-size:13px;display:flex;justify-content:space-between;align-items:center} +.sum .txt{white-space:pre-wrap;font:12.5px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace} +.score{font-size:11px;color:var(--ink-2);font-weight:500} +.tag{display:inline-block;font-size:10px;padding:1px 6px;border-radius:10px;background:var(--grid);color:var(--ink-2);margin-left:4px} +.warn{color:#D55E00}.err{color:#D55E00;font-style:italic} +.pill{font-size:11px;color:var(--ink-2);font-weight:400} +.prompt{border:1px solid var(--border);border-radius:10px;margin:10px 0;overflow:hidden} +.prompt>summary{cursor:pointer;padding:11px 15px;background:var(--card);list-style:none;display:flex;justify-content:space-between;gap:14px;align-items:baseline;flex-wrap:wrap} +.prompt>summary::-webkit-details-marker{display:none} +.prompt .pname{font-weight:600} +.prompt .pstat{font-size:12px;color:var(--ink-2)} +.prompt .ptext{white-space:pre-wrap;padding:12px 15px;font:12.5px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;border-top:1px solid var(--border)} +.prompt.winner{border-color:#009E73;box-shadow:0 0 0 1px #009E73 inset} +.badge{display:inline-block;font-size:10px;font-weight:700;padding:1px 7px;border-radius:10px;background:#009E73;color:#fff;margin-left:8px;letter-spacing:.3px} +""" + + +def _legend(stats: list[SeriesStats], colors: dict[str, str]) -> str: + items = "".join( + f'{html.escape(s.key)}' for s in stats + ) + return f'
{items}
' + + +def _summary_table(stats: list[SeriesStats], judged: bool) -> str: + head = ( + "Model" + ("·prompt" if any("·" in s.key for s in stats) else "") + "" + "OverallCoverFaithConcise" + "CompressOut tokCost/evLatencyDropHallucErr" + ) + body = "" + for s in stats: + ov = f"{s.avg_overall:.1f}" if judged else "—" + body += ( + f"{html.escape(s.key)}" + f"{ov}{s.avg_coverage:.0f}{s.avg_faithfulness:.0f}" + f"{s.avg_conciseness:.0f}{s.avg_compression * 100:.0f}%" + f"{s.avg_completion_tokens:.0f}${s.avg_cost:.5f}" + f"{s.avg_latency_ms:.0f}ms{s.total_dropped}" + f"{s.total_hallucinations}{s.errors}" + ) + return f"{head}{body}
" + + +def _prompts_section(results: dict) -> str: + """Show every evaluated prompt's full text next to its aggregate score, best first + and flagged CHOSEN — so a reader can see exactly what changed prompt-to-prompt and + why the winner was picked, without leaving the page.""" + prompts = results.get("prompts", {}) + if not prompts: + return "" + scored: dict[str, list[dict]] = defaultdict(list) + for c in results.get("cells", []): + j = c.get("judge") + # Skip errored cells and cells with no judge score (judge disabled/errored) — + # otherwise mean() over c["judge"]["overall"] dereferences None and aborts the report. + if not c.get("error") and j and not j.get("error"): + scored[c["prompt_name"]].append(c) + + rows = [] + for name, text in prompts.items(): + stat, sortkey = prompt_stat_line(scored.get(name, [])) + rows.append((sortkey, name, text, stat)) + rows.sort(key=lambda r: -r[0]) + # The CHOSEN prompt is the production decision, not merely the top raw-quality score — + # v5 was picked for equal quality at far better compression. Honor an explicit + # 'chosen_prompt' in the results; fall back to the top scorer only if none is set. + chosen = results.get("chosen_prompt") + best = chosen if chosen in prompts else (rows[0][1] if rows and rows[0][0] >= 0 else None) + + out = [] + for _sortkey, name, text, stat in rows: + win = name == best + badge = 'CHOSEN' if win else "" + out.append( + f'
' + f'{html.escape(name)}{badge}' + f'{html.escape(stat)}' + f'
{html.escape(text)}
' + ) + return "".join(out) + + +def _tags(j: dict) -> str: + out = "" + drop = j.get("dropped_critical") or [] + hall = j.get("hallucinations") or [] + if drop: + out += f'dropped: {html.escape(", ".join(drop)[:80])}' + if hall: + out += f'hallucinated: {html.escape(", ".join(hall)[:80])}' + return out + + +def _summary_card(c: dict, show_prompt: bool) -> str: + """One model/prompt summary card for the per-event side-by-side view.""" + j = c.get("judge") or {} + if c.get("error"): + score, txt, tags = 'failed', html.escape(c["error"]), "" + elif not c.get("judge") or j.get("error"): + # judge disabled (null) or errored — show the summary without a misleading "Q 0". + score, txt, tags = 'judge n/a', html.escape(c.get("summary", "")), "" + else: + score = ( + f'Q {j.get("overall", 0):.0f} · ' + f"cov {j.get('coverage', 0)} · faith {j.get('faithfulness', 0)}" + ) + txt, tags = html.escape(c.get("summary", "")), _tags(j) + name = html.escape(c["model_label"]) + if show_prompt: + name += f' {html.escape(c["prompt_name"])}' + return f'

{name}{score}

{txt}
{tags}
' + + +def _event_header(ev: dict, key: str) -> str: + header = f"{html.escape(ev.get('event_type', 'event'))} · {html.escape(ev.get('severity', ''))}" + if ev.get("node"): + header += f" · {html.escape(ev['node'])}" + return header + f' ({ev.get("message_chars", len(key))} chars)' + + +def _events_section(results: dict) -> str: + by_event: dict[str, list[dict]] = defaultdict(list) + for c in results.get("cells", []): + by_event[c["event_key"]].append(c) + events = {e["message"].strip(): e for e in results.get("events", [])} + + blocks = [] + for key, cs in by_event.items(): + ev = events.get(key.strip(), {}) + show_prompt = len({x["prompt_name"] for x in cs}) > 1 + ordered = sorted(cs, key=lambda x: (x["model_label"], x["prompt_name"])) + sums = "".join(_summary_card(c, show_prompt) for c in ordered) + blocks.append( + f'
{_event_header(ev, key)}' + f'
{html.escape(ev.get("message", key))}
' + f'
{sums}
' + ) + return "".join(blocks) + + +def render(results: dict) -> str: + stats, _ = aggregate_series(results) + judged = results.get("judge_model") is not None + colors = {s.key: PALETTE[i % len(PALETTE)] for i, s in enumerate(stats)} + + charts = [] + if judged: + charts.append( + _scatter( + "Quality vs. cost — the cheapest model that's good enough", + [(s.key, s.avg_cost, s.avg_overall, colors[s.key]) for s in stats], + "Avg cost per event (USD)", + "Avg quality (0–100)", + ) + ) + charts.append( + _hbar( + "Overall quality (higher is better)", + [(s.key, s.avg_overall, colors[s.key]) for s in stats], + 100, + "", + "{:.0f}", + ) + ) + charts.append( + _hbar( + "Compression — summary size as % of original (lower = more compression)", + [(s.key, s.avg_compression * 100, colors[s.key]) for s in stats], + max((s.avg_compression * 100 for s in stats), default=100), + "%", + "{:.0f}", + ) + ) + charts.append( + _hbar( + "Avg cost per event (USD)", + [(s.key, s.avg_cost, colors[s.key]) for s in stats], + max((s.avg_cost for s in stats), default=0.001), + "", + "${:.5f}", + ) + ) + charts.append( + _hbar( + "Avg latency", + [(s.key, s.avg_latency_ms, colors[s.key]) for s in stats], + max((s.avg_latency_ms for s in stats), default=1), + "ms", + "{:.0f}", + ) + ) + + unknown = results.get("unknown_priced_models") or [] + default_priced = results.get("default_priced_models") or [] + warn = "" + if unknown: + warn += ( + f'

⚠ No pricing configured for: {html.escape(", ".join(unknown))} ' + f"— their cost shows as $0. Add them under pricing: in the config.

" + ) + if default_priced: + warn += ( + f'

⚠ Using built-in placeholder pricing for: {html.escape(", ".join(default_priced))} ' + f"— verify the cost axis, or set real rates under pricing: in the config.

" + ) + + prompts_used = results.get("prompts", {}) + prompt_note = " · ".join(sorted(prompts_used.keys())) + + return f""" + +Event Summarization — model evaluation +

Event Summarization — model evaluation

+
Generated {html.escape(results.get("generated_at", ""))} · +{results.get("num_events", 0)} unique events · {len(stats)} series · +judge: {html.escape(str(results.get("judge_model")))} · prompts: {html.escape(prompt_note)}
+{warn} +

Comparison

+{_legend(stats, colors)} +
{"".join(charts)}
+

Aggregate metrics

+{_summary_table(stats, judged)} +

Prompts evaluated (full text — click to expand)

+{('

' + html.escape(results["decision_note"]) + "

") if results.get("decision_note") else ""} +{_prompts_section(results)} +

Per-event summaries (click to expand)

+{_events_section(results)} +""" + + +def write_report(results: dict, out_path: Path) -> Path: + out_path.parent.mkdir(parents=True, exist_ok=True) + out_path.write_text(render(results), encoding="utf-8") + LOGGER.info("Wrote HTML report to %s", out_path) + return out_path + + +def report_from_file(results_path: Path, out_path: Path) -> Path: + results = json.loads(Path(results_path).read_text(encoding="utf-8")) + return write_report(results, out_path) diff --git a/argusAI/eval/results.py b/argusAI/eval/results.py new file mode 100644 index 000000000..40cdf3464 --- /dev/null +++ b/argusAI/eval/results.py @@ -0,0 +1,73 @@ +"""The serializable domain types produced by the sweep and consumed by the report. + +These are the shared vocabulary between ``harness`` (which produces them) and ``report`` +(which reads their serialized form from ``results.json``). Keeping them here — not inside +the orchestrator — means the shape of a result is defined in one obvious place. + +The on-disk JSON schema is exactly ``CellResult.to_dict()``: every dataclass field, plus +two derived keys the report relies on — ``compression_ratio`` and, when judged, +``judge.overall``. +""" + +from __future__ import annotations + +from dataclasses import asdict, dataclass, field + + +@dataclass +class JudgeScore: + """A frontier model's assessment of one summary against its original event.""" + + coverage: int = 0 + faithfulness: int = 0 + conciseness: int = 0 + dropped_critical: list[str] = field(default_factory=list) + hallucinations: list[str] = field(default_factory=list) + verdict: str = "" + error: str | None = None + + @property + def overall(self) -> float: + """Coverage and faithfulness dominate; a hallucination is worse than a terse + omission, and conciseness only breaks ties. Weights are opinionated on purpose — + adjust here if the team weighs the trade-off differently.""" + return 0.45 * self.coverage + 0.40 * self.faithfulness + 0.15 * self.conciseness + + +@dataclass +class CellResult: + """One (event, model, prompt) outcome — the atomic row of the report.""" + + event_key: str + run_id: str + event_type: str + node: str + severity: str + model: str + model_label: str + prompt_name: str + input_chars: int + summary_chars: int + input_tokens: int = 0 + summary_tokens: int = 0 + summary: str = "" + prompt_tokens: int = 0 + completion_tokens: int = 0 + cached_tokens: int = 0 + latency_ms: float = 0.0 + cost_usd: float = 0.0 + judge: JudgeScore | None = None + error: str | None = None + + @property + def compression_ratio(self) -> float: + # Measured in tokens (what the API bills), not characters. + return (self.summary_tokens / self.input_tokens) if self.input_tokens else 0.0 + + def to_dict(self) -> dict: + d = asdict(self) + if self.judge is not None: + d["judge"] = asdict(self.judge) + d["judge"]["overall"] = round(self.judge.overall, 1) + d["compression_ratio"] = round(self.compression_ratio, 3) + return d diff --git a/docs/plans/MASTER.md b/docs/plans/MASTER.md index 3ecc422b8..a91dc343c 100644 --- a/docs/plans/MASTER.md +++ b/docs/plans/MASTER.md @@ -50,4 +50,6 @@ _No plans in this domain yet._ ## Infrastructure -_No plans in this domain yet._ +| Plan | Status | File | Owner | +| ------------------- | ------- | ------------------------------------------------ | -------- | +| Event Summarization | `in_progress` | [event-summarization.md](event-summarization.md) | CodeLieutenant | diff --git a/docs/plans/event-summarization.md b/docs/plans/event-summarization.md new file mode 100644 index 000000000..9c5186f6b --- /dev/null +++ b/docs/plans/event-summarization.md @@ -0,0 +1,384 @@ +--- +status: in_progress # draft | approved | in_progress | blocked | complete +domain: infrastructure +created: 2026-06-04 +last_updated: 2026-07-22 +owner: CodeLieutenant +--- + +# Event Summarization — Design + +Refs: [ARGUS-146](https://scylladb.atlassian.net/browse/ARGUS-146) · +review discussion in [PR #1016](https://github.com/scylladb/argus/pull/1016) + +## 1. Problem Statement + +SCT ERROR/CRITICAL events are long and noisy: a single event message routinely runs hundreds +to thousands of characters (the frontend already hard-truncates at 600 chars — +`frontend/TestRun/SCT/SctEvent.svelte:30`, `MESSAGE_CUTOFF = 600`). + +The primary consumer this hurts is **Zeus**, the AI investigation service. Zeus loads a run's +events into its conversation context at the start of an investigation, and those events are +then **re-read on every subsequent step** — and most runs are investigated by Zeus multiple +times. Every re-read pays the full token cost of the raw event bodies again. Long, +low-signal-to-noise inputs also degrade LLM reasoning quality (hallucination risk). + +Summarizing each unique event **once**, with a cheap model, and storing the result turns a +per-read cost into a one-time cost: every later read (by Zeus, and optionally by humans) +consumes the short summary instead of the raw wall of text. + +For **humans** the value is contested (see the PR discussion): a summary is easier to scan, +but it is preprocessed information — a triager verifying an LLM's conclusions wants the raw +message, and a misleading summary is worse than a long one. The design therefore treats +human-facing display as **opt-in, configurable per user**: the original message stays the +default, the summary is one click away, and each user can flip which one they see first. + +## 2. Current State + +**Event pipeline (backend):** + +- `argus/backend/plugins/sct/testrun.py:79` — `SCTEvent` model (`sct_event`). PK = partition + `(run_id, severity)` + clustering `ts` (ASC). Fields incl. `event_id`, `event_type`, + `message` (required), `duplicate_id`. +- `argus/backend/plugins/sct/testrun.py:108` — `SCTUnprocessedEvent` + (`sct_unprocessed_events`): the processing queue drained by the argusAI worker. +- `argus/backend/plugins/sct/service.py:478` — `SCTService.submit_event` saves the event and + (line 512) enqueues an `SCTUnprocessedEvent` for ERROR/CRITICAL severities. +- `argus/backend/plugins/sct/service.py:528` — `SCTService.get_events` delegates to + `SCTTestRun.get_events_limited` (`testrun.py:372`), which runs `SELECT * FROM sct_event ...` + and returns raw row dicts — **any new column on `sct_event` is returned automatically**. + +**The argusAI worker** (`argusAI/`, same repo — deployed as a separate systemd service): + +- `argusAI/event_similarity_processor_v2.py` — standalone worker process. Infinite loop: + fetch up to 100 queue rows (`_process_batch`), and per event: read message → sanitize + (`MessageSanitizer`) → generate embedding (local ONNX model, fast) → **duplicate check** + via ANN search (`_mark_event_is_duplicate`, line 126; short-circuit at line 284-285: a + duplicate gets `duplicate_id` set on `sct_event` and is dequeued, skipping all remaining + steps) → store embedding → delete queue row. +- DB access is **raw CQL** via `argusAI/utils/scylla_connection.py` (`ScyllaConnection`, + prepared-statement cache). The worker never calls `cqlengine.connection.setup()` — CQLEngine + model methods (`.save()`, `.objects`) would raise in this process. Config comes from + `Config.load_yaml_config()` (plain dict, no Flask app context). +- Deployed via `argusAI/deployment/argusai_event_similarity_processor.service`. + +**Duplicate handling downstream:** the frontend groups duplicates under the canonical event +(`SctEvents.svelte`, `duplicate_id`); the CLI aggregates them too +(`cli/cmd/run_nemeses_events.go:125`, `deduplicateEvents`). Both display surfaces already +show the **canonical** event as the representative. + +**Frontend:** `frontend/TestRun/SCT/SctEvent.svelte` renders a single event; it already has a +truncate/expand toggle (`fullMessage` `$state`, line 159; button at line 366). + +**CLI (Go):** `argus run events` — `runEventsCmd` in `cli/cmd/run_nemeses_events.go:176`; +the `SCTEvent` struct is `cli/internal/models/runs.go:198`; output goes through +`out.Write(models.SCTEventsResponse{...})` with a response cache. + +**Zeus:** external service, reached through the authenticated proxy +`/api/v1/zeus/` (`argus/backend/controller/api.py:628`); it reads run events through +the Argus API. + +**Dependencies:** no OpenAI/LLM dependency exists anywhere in the repo today; `openai` is not +in `pyproject.toml`. + +## 3. Goals + +1. Every **unique** (non-duplicate) ERROR/CRITICAL event gets a stored, model-generated + summary, best-effort, within the worker's normal processing lag. Duplicates are never + summarized — the canonical event's summary covers them (this is also where the cost + saving comes from: duplicates are the bulk of event volume). +2. The summary is **stored once and reused by all investigations** — every Zeus read of the + run, and every human view, across the event's lifetime. +3. Serving is zero-cost: `get_events` payloads carry a `summary` field with no extra query. +4. **Fail silently:** an event without a summary (not yet processed, summarization failed, + feature disabled, worker down) renders exactly as today, everywhere — `summary` is `null` + and consumers fall back to `message`. No errors, no blank states. +5. Human display is **configurable per user**: which body renders first (original vs. + summary) is a user preference; the other is always one click/flag away. Default: + **original first** (summaries are opt-in for humans). +6. **Embeddings are never slowed, blocked, or altered by summarization.** The embedding path + stays byte-for-byte as-is and dequeues on its own schedule; an OpenAI outage has zero + effect on it. +7. Metrics are defined **up front** (token usage, cost, latency, coverage) so the pilot can + be priced and the model choice validated with real numbers. + +## 4. Non-Goals (decisions from the PR review) + +These were in earlier drafts and are **deliberately dropped**: + +- **No separate summary table.** The summary is a column on `sct_event`. This removes the + keying and keyspace questions entirely, and removes the attach-query from serving. +- **No second queue, worker, or systemd unit.** The existing similarity processor is the + single consumer of the single existing queue; this also eliminates the shared-queue race + that a second consumer would introduce. No new enqueue in `submit_event`. +- **No batching.** One model call per event. There are several minutes of headroom before + auto-investigation picks up a run, so per-event latency is fine; batching's + chunking/char-budget/index-mapping complexity buys little (event tokens cost the same + either way; prompt caching already discounts the repeated system prompt). +- **No truncation.** Never trim event input before summarizing — the tail of a stack trace + is exactly the detail a triager needs. Large events are sent as-is. +- **No sanitization of summarizer input.** `MessageSanitizer` strips node names, IPs, and + paths — right for embedding similarity, wrong for summaries, where those are the details + worth keeping (see the worked example in the PR discussion, which preserves node name and + event id). The summarizer receives the raw message. +- **No min-length gate.** Every unique ERROR/CRITICAL event is summarized, full stop. +- **No `status=failed` markers, no retries.** On failure: log, leave `summary` null, move + on. Null already means "fall back to the original". +- **No live model swap.** Changing the model is a config edit + worker restart. +- **No per-run digest.** Different data model and UI; out of scope. +- **No summarization before embedding.** Embeddings continue to consume the sanitized raw + message unchanged. + +## 5. Design + +### 5.1 Data model + +Add one nullable column to `SCTEvent` (`argus/backend/plugins/sct/testrun.py:79`): + +```python +summary = columns.Text() # LLM-generated summary; null until/unless summarized +``` + +No new tables. `flask sync-models` picks up the new column automatically: `SCTEvent` is +already registered in the SCT plugin's `all_models` (`plugins/sct/plugin.py:27`), and +CQLEngine's `sync_table` issues `ALTER TABLE sct_event add summary` for columns missing +from the live schema (verified in `cassandra.cqlengine.management._sync_table`). No +registration changes are needed. + +The worker writes it with a raw-CQL upsert, keyed by the event's identity: + +```sql +UPDATE sct_event SET summary = ? WHERE run_id = ? AND severity = ? AND ts = ? +``` + +This is exactly the pattern the worker already uses to set `duplicate_id` on `sct_event` +(`event_similarity_processor_v2.py:152`) — established precedent, not new machinery. A +crash-and-reprocess simply overwrites the same cell — idempotent by construction. + +### 5.2 Processing flow — one worker, parallel side-task + +Summarization lives **inside `event_similarity_processor_v2.py`** as a background task +dispatched from the existing per-event pipeline. The reconciliation of the two review +requirements ("dispatch in parallel, embedding never waits" and "summarize only +deduplicated events") is the dispatch point: the duplicate verdict requires the embedding, +so summarization is dispatched **immediately after the duplicate check resolves to +"unique"** (i.e., alongside step 4, embedding storage). From that moment the two paths are +fully independent: + +``` +_process_single_event(run_id, severity, ts): + read message ─ sanitize ─ embed ─ duplicate? + ├─ yes → mark duplicate_id, dequeue. Done (never summarized) + └─ no ─┬─ store embedding, dequeue (main loop, as today) + └─ submit summarization task (background executor) + └─ OpenAI call (raw message, no truncation) + ├─ ok → UPDATE sct_event SET summary=... + └─ fail → log; summary stays null +``` + +- **Bounded concurrency.** Tasks run on a `ThreadPoolExecutor` with a small, configurable + worker count (`EVENT_SUMMARIZATION_MAX_CONCURRENCY`) to protect OpenAI rate limits. The + main loop only *submits* — it never joins or waits on the executor, so embedding + throughput is unaffected by OpenAI latency or outage. If the executor's queue backs up, + submissions are dropped with a log line (best-effort, never backpressure the main loop). +- **Best-effort semantics.** Queue-row deletion is owned by the embedding path exactly as + today. A summarization task that fails, or is lost to a worker restart, leaves + `summary = null` forever — the event is never re-enqueued. Accepted: the fallback is the + original message, and coverage (not completeness) is the goal. +- **Disabled/keyless mode.** If `EVENT_SUMMARIZATION_ENABLED` is false or `OPENAI_API_KEY` + is missing, the dispatch is skipped entirely (one log line at startup). The worker + otherwise behaves exactly as today. +- **Shutdown.** On stop, the executor is drained with a short timeout; unfinished tasks are + abandoned (their events keep `summary = null`). + +### 5.3 Summarizer & configuration + +A thin `Summarizer` module under `argusAI/utils/` wraps the LLM call: +`summarize(model, prompt, message) -> str`. OpenAI is the first implementation; the seam +exists so a different provider is a new implementation, not a rewrite. Each call's `usage` +object is logged (see §6). + +Config keys (in `argus_web.example.yaml`, read once at worker startup via +`Config.load_yaml_config()`; changing any of them = worker restart): + +| Key | Default | Notes | +| --- | ------- | ----- | +| `OPENAI_API_KEY` | — | placeholder in the example file only; follows the existing secret conventions | +| `OPENAI_SUMMARY_MODEL` | `gpt-5-mini` | starting point; final choice is gated on the evaluation (§7) | +| `EVENT_SUMMARIZATION_ENABLED` | `false` | master switch | +| `EVENT_SUMMARIZATION_PROMPT` | built-in default | editable without a code change; the working baseline from the PR discussion: *"Summarize this error event in a way we don't lose information and use minimum tokens. Don't add anything more from your side."* | +| `EVENT_SUMMARIZATION_MAX_CONCURRENCY` | `4` | executor size / rate-limit guard | + +New dependency: `openai` in the root `pyproject.toml` (argusAI uses the root project). + +### 5.4 Serving + +`get_events_limited` already does `SELECT *` and returns raw row dicts, so the `summary` +column travels in every event payload **with zero backend code changes**. `message` stays in +the payload unchanged; the field is additive and existing API consumers are unaffected. +Duplicates carry `summary = null` by design — both display surfaces already group them under +the canonical event, which is the one carrying the summary. + +### 5.5 Web UI + +In `frontend/TestRun/SCT/SctEvent.svelte`: + +- Add `summary?: string | null` to the `SCTEvent` TS interface (`SctEvents.svelte`). +- When `event.summary` is present, the event body offers **two views** — original message + and summary — with a toggle, and a clear "AI summary" affordance on the summary view so + preprocessed text is never mistaken for raw output. +- **Which view renders first is a per-user preference.** Stored in `localStorage` + (the established pattern for view preferences — e.g. `Views.svelte`, + `TestDashboard.svelte`); default **original-first**. A server-side `User` column can + replace localStorage later if cross-device consistency is ever needed (open question). +- When `summary` is null/empty: render exactly as today, no visual change whatsoever. +- Copy-to-clipboard always copies the **original** message. + +### 5.6 CLI + +`argus run events` (`cli/cmd/run_nemeses_events.go`): + +- Add `Summary string` (with JSON tag) to the Go `SCTEvent` struct + (`cli/internal/models/runs.go:198`). +- **Default output renders the summary** where present, falling back to `message` when null + — output is never blank. This is the opposite default from the web UI: the CLI is the + primary interface for scripted/automated callers, so it optimizes for token savings first. + A `--raw` flag forces the original `message` instead. +- The duplicate-aggregation path (`deduplicateEvents`) keeps the canonical event, which is + the one carrying the summary; a promoted stand-in duplicate has `summary = null` and falls + back cleanly. +- Note: the CLI caches event responses (`cache.TTLSCTEvents`, 5 minutes — + `cli/internal/cache/keys.go:49`); a summary written after an event was cached appears + once the TTL lapses — acceptable for best-effort. + +### 5.7 Zeus integration + +The whole point of the feature is that Zeus reads summaries instead of raw messages. Since +the API payload carries both `message` and `summary`, the token saving is only realized when +Zeus **prefers `summary` when non-null** — a small Zeus-side change to coordinate (Zeus is +an external service reached via the `/api/v1/zeus/` proxy). Until Zeus adopts it, the +feature costs money without saving any; adoption is therefore part of the rollout criteria, +not an afterthought. + +Separately, and regardless of summarization: Zeus should be instructed to bound how many +events it fetches per investigation step (by time range and/or a `limit`), rather than +pulling a run's entire event history. This is good practice independent of this feature, but +matters more once events are summarized in bulk (see §11.3). + +## 6. Metrics & Observability + +Defined up front (as done for Zeus) so usage and pricing are assessable from day one. The +worker emits a structured log line **per summarization call** with: + +- `model`, `prompt_tokens`, `completion_tokens`, `cached_tokens` (straight from the OpenAI + response `usage` object), and derived cost; +- `latency_ms`, `input_chars`, `summary_chars` (compression ratio); +- outcome (`ok` / `error` + short reason). + +Plus periodic aggregate counters: events summarized, failures, dispatches skipped +(disabled / duplicate / executor full), summarization lag (event `ts` → summary written). + +These logs are the data source for the cost evaluation below and for ongoing monitoring of +coverage (what fraction of unique ERROR/CRITICAL events end up with a summary). + +## 7. Evaluation + +Three evaluations gate the defaults and the rollout; none of them require the full feature +to be built first. + +**Model quality — evaluation test (required).** Take 20–50 real production events. Generate +reference summaries with a frontier model (Opus 4.8 or GPT-5.5). Generate candidate +summaries with cheaper models (`gpt-5-mini`, …). Score each candidate against the reference +(LLM-judge and/or embedding similarity) for information preservation — did the summary keep +the failure type, node, root-cause line? Pick the cheapest model that is "good enough"; this +sets `OPENAI_SUMMARY_MODEL`. The harness lives with the argusAI tests and is re-runnable +whenever a model swap is considered. + +**Cost analysis (required, with real numbers).** The economics to validate: summarization +cost is *one* cheap-model pass per **unique** event (duplicates — the bulk of volume — are +free); the saving is `(raw_tokens − summary_tokens) × (number of Zeus reads) × +(Zeus model price)`, where the read count is large because events are loaded at investigation +start, re-read every step, and runs are investigated multiple times. The per-call `usage` +logs (§6) provide the measured inputs. Deliverable: measured break-even (how many Zeus reads +amortize one summarization) and projected monthly cost at current event volume. + +**Zeus quality PoC (required before human-facing default changes).** A manual A/B: run Zeus +investigations on the same runs with raw events vs. summaries and compare response quality. +This addresses the compounding-uncertainty concern from review (summarizer accuracy × +Zeus accuracy) with evidence rather than argument — the counter-hypothesis being that a +shorter, cleaner context *improves* Zeus's accuracy rather than degrading it. + +**Rollout.** Ship dark behind `EVENT_SUMMARIZATION_ENABLED=false`; pilot on a handful of +jobs first while watching the §6 metrics, then widen. If a job-scoped pilot gate is needed, +a temporary allowlist config key checked at dispatch time is the one-line lever; it is not +part of the steady-state design. + +## 8. Testing Requirements + +- **Worker unit tests (`argusAI/tests/`),** mirroring the v2 processor tests: OpenAI client + mocked; unique event → summarization task dispatched → `UPDATE` executed with the right + key; duplicate event → no dispatch; OpenAI error → logged, no write, loop unaffected; + disabled / missing key → no dispatch, no crash; concurrency bound respected; executor + backlog → dropped with log, main loop never blocks. +- **Backend unit tests (`argus/backend/tests/`):** `get_events` payload includes `summary` + (value when set, `null` otherwise); original `message` intact in both cases. +- **Integration (Docker ScyllaDB, `@pytest.mark.docker_required`),** extending + `argus/backend/tests/sct_events/test_event_embedding_integration.py`: submit ERROR event → + queue row appears → one worker cycle with mocked OpenAI → `sct_event.summary` populated, + queue row gone, `get_events` returns it; embedding rows identical to a run with + summarization disabled (goal 6, demonstrated). +- **Evaluation harness (§7)** checked in and runnable on demand. +- **Manual:** UI preference + toggle on a real run; `argus run events --summary`; a run with + summarization disabled shows originals everywhere with no errors. + +## 9. Success Criteria + +- A freshly submitted unique ERROR/CRITICAL event acquires a stored summary via the worker; + the summary is visible in UI and CLI with the original one toggle/flag away; duplicates + are never summarized. +- Per-user display preference works; the out-of-the-box default is original-first. +- Disabling summarization (flag off / no key / worker down / OpenAI outage) leaves the + entire system functional on original text — demonstrated, not assumed. +- Embedding pipeline output is byte-for-byte unchanged with the feature on or off. +- Token/cost metrics are being emitted and the cost analysis (§7) is produced from them. +- Zeus consumes summaries and the measured cost per investigation drops. + +## 10. Risks & Mitigations + +| Risk | Likelihood | Impact | Mitigation | +| ---- | ---------- | ------ | ---------- | +| Misleading summary misdirects a human triager | Medium | Medium | Original is the default view and always retained; summaries are opt-in per user, visibly labeled as AI-generated; copy-to-clipboard stays raw. | +| Summarizer error compounds with Zeus error, lowering end-to-end accuracy | Medium | High | Zeus quality PoC (§7) before relying on summaries; counter-effect (shorter context → better reasoning) measured, not assumed. | +| OpenAI cost exceeds the saving | Medium | High | Only unique (deduplicated) events are summarized; cheap model (~20× cheaper than frontier); per-call usage metrics from day one; measured break-even before wide rollout. | +| OpenAI outage / latency | Medium | Low | Summarization is an isolated background task; embeddings and serving are untouched; affected events keep `summary=null` and fall back. | +| Rate limits at high event volume | Medium | Medium | Bounded executor concurrency; duplicates (bulk of volume) never reach OpenAI. | +| Lost summaries on worker crash/restart (no retry) | Medium | Low | Accepted under best-effort: fallback is the original message. A backfill pass over `summary IS NULL` events can be added later if coverage proves too low. | +| Raw event content (node names, IPs, paths) sent to OpenAI | Low | Medium | Deliberate (§4 — sanitization would strip the useful details); events contain test-infrastructure data, not customer data; flag to security if that assumption ever changes. | +| Secret leakage (`OPENAI_API_KEY` in YAML) | Low | High | Existing `ZEUS_TOKEN`/`*_SECRET` conventions; placeholder only in the example file. | +| Stale CLI cache hides fresh summaries | High | Low | Accepted: TTL-bounded; summaries are not time-critical for CLI users. | + +## 11. Open Questions + +1. **Final model** — `gpt-5-mini` is the working default; the evaluation test (§7) decides. +2. **Per-user preference storage** — **decided: localStorage** (per-browser, zero backend + work, matches existing view-preference patterns). A server-side `User` column can replace + it later if cross-device consistency is ever needed; not worth the backend work up front. +3. **Zeus payload shape** — **decided: no dedicated summaries-only view.** Instead, the CLI + (§5.6) defaults to summary-first output (`--raw` for the original), and Zeus is instructed + to bound its event fetches by time range / `limit` per investigation step rather than + pulling a run's full event history — see §5.7. +4. **Record the producing model?** **Decided: no.** Dropped with the separate table (no + `model` column on `sct_event`). If production A/B of models is ever needed, comparison + happens offline via the evaluation harness instead. + +## 12. Implementation Status + +Tracked as 5 phases (`progress.json`); Zeus (§5.7) is an external service tracked separately. + +| # | Phase | Covers | Status | +| - | ----- | ------ | ------ | +| 1 | Backend worker | §5.1 `summary` column · §5.2 dispatch · §5.3 Summarizer + config · §6 per-call & aggregate metrics | **done** | +| 2 | Evaluation harness | §7 prompt/model sweep, LLM judge, token-based cost/compression, HTML report | **done** | +| 3 | Serving & tests | §5.4 (`SELECT *`, no code) · §8 backend serving test (`summary` in payload, `message` intact) done; integration test pending | in progress | +| 4 | CLI | §5.6 Go `Summary` field, summary-first output, `--raw` | todo | +| 5 | Web UI | §5.5 Svelte toggle + per-user localStorage preference | todo | diff --git a/docs/plans/progress.json b/docs/plans/progress.json index 1596a2ea8..642a3aa85 100644 --- a/docs/plans/progress.json +++ b/docs/plans/progress.json @@ -26,7 +26,17 @@ "domain": "client", "status": "in_progress", "created": "2026-06-01", - "phases_total": 7, + "phases_total": 8, "phases_done": 6 + }, + { + "id": "event-summarization", + "title": "Event Summarization", + "file": "docs/plans/event-summarization.md", + "domain": "infrastructure", + "status": "in_progress", + "created": "2026-06-08", + "phases_total": 5, + "phases_done": 2 } ] diff --git a/pyproject.toml b/pyproject.toml index 43b072a05..a9d50245a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -80,6 +80,12 @@ ai = [ "chromadb >= 1.0.15", "openai >= 1.60.0", ] +ai-eval = [ + "openai >= 1.60.0", + "PyYAML ~= 6.0.0", + "tiktoken >= 0.7.0", + "chromadb >= 1.0.15", # BGE embeddings for optional similarity dedup (mirrors the worker) +] [tool.ruff] lint.select = [ diff --git a/uv.lock b/uv.lock index 2a262aa6b..fba39b54f 100644 --- a/uv.lock +++ b/uv.lock @@ -1,9 +1,10 @@ version = 1 revision = 3 -requires-python = ">=3.12" +requires-python = ">=3.10" resolution-markers = [ "python_full_version >= '3.13'", - "python_full_version < '3.13'", + "python_full_version >= '3.11' and python_full_version < '3.13'", + "python_full_version < '3.11'", ] [[package]] @@ -20,6 +21,7 @@ name = "anyio" version = "4.12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "idna" }, { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] @@ -49,6 +51,13 @@ dependencies = [ [package.optional-dependencies] ai = [ { name = "chromadb" }, + { name = "openai" }, +] +ai-eval = [ + { name = "chromadb" }, + { name = "openai" }, + { name = "pyyaml" }, + { name = "tiktoken" }, ] dev = [ { name = "autopep8" }, @@ -94,6 +103,7 @@ requires-dist = [ { name = "boto3", marker = "extra == 'web-backend'", specifier = "~=1.38.9" }, { name = "boto3-stubs", marker = "extra == 'dev'", specifier = "~=1.38.9" }, { name = "chromadb", marker = "extra == 'ai'", specifier = ">=1.0.15" }, + { name = "chromadb", marker = "extra == 'ai-eval'", specifier = ">=1.0.15" }, { name = "click", specifier = ">=8.1.3" }, { name = "codecov", marker = "extra == 'dev'", specifier = "~=2.1.12" }, { name = "coverage", marker = "extra == 'dev'", specifier = "==7.8.2" }, @@ -106,6 +116,8 @@ requires-dist = [ { name = "jira", marker = "extra == 'web-backend'", specifier = ">=3.10.5" }, { name = "lz4", specifier = ">=4.4.4" }, { name = "nox", marker = "extra == 'dev'", specifier = "~=2025.5.1" }, + { name = "openai", marker = "extra == 'ai'", specifier = ">=1.60.0" }, + { name = "openai", marker = "extra == 'ai-eval'", specifier = ">=1.60.0" }, { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=4.2.0" }, { name = "prometheus-flask-exporter", marker = "extra == 'web-backend'", specifier = ">=0.23.2" }, { name = "pygithub", marker = "extra == 'web-backend'", specifier = ">=2.6.1" }, @@ -117,16 +129,18 @@ requires-dist = [ { name = "python-jenkins", marker = "extra == 'web-backend'", specifier = ">=1.7.0" }, { name = "python-magic", marker = "extra == 'web-backend'", specifier = "~=0.4.24" }, { name = "python-slugify", marker = "extra == 'web-backend'", specifier = "~=6.1.1" }, + { name = "pyyaml", marker = "extra == 'ai-eval'", specifier = "~=6.0.0" }, { name = "pyyaml", marker = "extra == 'web-backend'", specifier = "~=6.0.0" }, { name = "requests", specifier = ">=2.26.0" }, { name = "requests-mock", marker = "extra == 'dev'", specifier = "~=1.12.1" }, { name = "ruff", marker = "extra == 'dev'", specifier = "~=0.11.11" }, { name = "scylla-driver", marker = "extra == 'web-backend'", specifier = ">=3.29.4" }, { name = "supervisor", marker = "extra == 'docker-image'", specifier = "~=4.2.4" }, + { name = "tiktoken", marker = "extra == 'ai-eval'", specifier = ">=0.7.0" }, { name = "uwsgi", marker = "extra == 'web-backend'", specifier = "~=2.0.20" }, { name = "zstandard", marker = "extra == 'web-backend'", specifier = ">=0.22.0" }, ] -provides-extras = ["web-backend", "docker-image", "dev", "ai"] +provides-extras = ["web-backend", "docker-image", "dev", "ai", "ai-eval"] [[package]] name = "asttokens" @@ -152,6 +166,7 @@ version = "2.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pycodestyle" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/d8/30873d2b7b57dee9263e53d142da044c4600a46f2d28374b3e38b023df16/autopep8-2.3.2.tar.gz", hash = "sha256:89440a4f969197b69a995e4ce0661b031f455a9f776d2c5ba3dbd83466931758", size = 92210, upload-time = "2025-01-14T14:46:18.454Z" } wheels = [ @@ -231,6 +246,10 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c0/f6/688d2cd64bfd0b14d805ddb8a565e11ca1fb0fd6817175d58b10052b6d88/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683", size = 153725, upload-time = "2025-09-25T19:50:34.384Z" }, { url = "https://files.pythonhosted.org/packages/9f/b9/9d9a641194a730bda138b3dfe53f584d61c58cd5230e37566e83ec2ffa0d/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2", size = 150912, upload-time = "2025-09-25T19:50:35.69Z" }, { url = "https://files.pythonhosted.org/packages/27/44/d2ef5e87509158ad2187f4dd0852df80695bb1ee0cfe0a684727b01a69e0/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927", size = 144953, upload-time = "2025-09-25T19:50:37.32Z" }, + { url = "https://files.pythonhosted.org/packages/8a/75/4aa9f5a4d40d762892066ba1046000b329c7cd58e888a6db878019b282dc/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7edda91d5ab52b15636d9c30da87d2cc84f426c72b9dba7a9b4fe142ba11f534", size = 271180, upload-time = "2025-09-25T19:50:38.575Z" }, + { url = "https://files.pythonhosted.org/packages/54/79/875f9558179573d40a9cc743038ac2bf67dfb79cecb1e8b5d70e88c94c3d/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:046ad6db88edb3c5ece4369af997938fb1c19d6a699b9c1b27b0db432faae4c4", size = 273791, upload-time = "2025-09-25T19:50:39.913Z" }, + { url = "https://files.pythonhosted.org/packages/bc/fe/975adb8c216174bf70fc17535f75e85ac06ed5252ea077be10d9cff5ce24/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:dcd58e2b3a908b5ecc9b9df2f0085592506ac2d5110786018ee5e160f28e0911", size = 270746, upload-time = "2025-09-25T19:50:43.306Z" }, + { url = "https://files.pythonhosted.org/packages/e4/f8/972c96f5a2b6c4b3deca57009d93e946bbdbe2241dca9806d502f29dd3ee/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:6b8f520b61e8781efee73cba14e3e8c9556ccfb375623f4f97429544734545b4", size = 273375, upload-time = "2025-09-25T19:50:45.43Z" }, ] [[package]] @@ -263,6 +282,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "botocore-stubs" }, { name = "types-s3transfer" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/c6/b042b91c40e6e70760d6b63fe391e198bd939b7630e1c5b809b635a601ae/boto3_stubs-1.38.46.tar.gz", hash = "sha256:526789fc1f4a6f89f372424dc9a4109296f6bd18afab1abf5d281a94f5cfb770", size = 99865, upload-time = "2025-06-27T20:34:10.576Z" } wheels = [ @@ -301,8 +321,10 @@ version = "1.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "os_name == 'nt'" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10.2'" }, { name = "packaging" }, { name = "pyproject-hooks" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/18/94eaffda7b329535d91f00fe605ab1f1e5cd68b2074d03f255c7d250687d/build-1.4.0.tar.gz", hash = "sha256:f1b91b925aa322be454f8330c6fb48b465da993d1e7e7e6fa35027ec49f3c936", size = 50054, upload-time = "2026-01-08T16:41:47.696Z" } wheels = [ @@ -327,6 +349,31 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" }, + { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" }, + { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" }, + { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" }, + { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" }, + { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" }, + { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" }, + { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" }, + { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" }, + { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" }, + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, @@ -390,6 +437,38 @@ version = "3.4.4" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload-time = "2025-10-14T04:40:11.385Z" }, + { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload-time = "2025-10-14T04:40:13.135Z" }, + { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload-time = "2025-10-14T04:40:14.728Z" }, + { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload-time = "2025-10-14T04:40:16.14Z" }, + { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload-time = "2025-10-14T04:40:17.567Z" }, + { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload-time = "2025-10-14T04:40:19.08Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload-time = "2025-10-14T04:40:20.607Z" }, + { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload-time = "2025-10-14T04:40:21.719Z" }, + { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload-time = "2025-10-14T04:40:23.069Z" }, + { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload-time = "2025-10-14T04:40:24.17Z" }, + { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload-time = "2025-10-14T04:40:25.368Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload-time = "2025-10-14T04:40:26.806Z" }, + { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload-time = "2025-10-14T04:40:28.284Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload-time = "2025-10-14T04:40:29.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload-time = "2025-10-14T04:40:30.644Z" }, + { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload-time = "2025-10-14T04:40:32.108Z" }, + { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" }, + { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" }, + { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" }, + { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" }, + { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" }, + { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" }, + { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" }, + { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" }, { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, @@ -454,7 +533,8 @@ dependencies = [ { name = "jsonschema" }, { name = "kubernetes" }, { name = "mmh3" }, - { name = "numpy" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "onnxruntime" }, { name = "opentelemetry-api" }, { name = "opentelemetry-exporter-otlp-proto-grpc" }, @@ -547,6 +627,27 @@ version = "7.8.2" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/ba/07/998afa4a0ecdf9b1981ae05415dad2d4e7716e1b1f00abbd91691ac09ac9/coverage-7.8.2.tar.gz", hash = "sha256:a886d531373a1f6ff9fad2a2ba4a045b68467b779ae729ee0b3b10ac20033b27", size = 812759, upload-time = "2025-05-23T11:39:57.856Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/26/6b/7dd06399a5c0b81007e3a6af0395cd60e6a30f959f8d407d3ee04642e896/coverage-7.8.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd8ec21e1443fd7a447881332f7ce9d35b8fbd2849e761bb290b584535636b0a", size = 211573, upload-time = "2025-05-23T11:37:47.207Z" }, + { url = "https://files.pythonhosted.org/packages/f0/df/2b24090820a0bac1412955fb1a4dade6bc3b8dcef7b899c277ffaf16916d/coverage-7.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4c26c2396674816deaeae7ded0e2b42c26537280f8fe313335858ffff35019be", size = 212006, upload-time = "2025-05-23T11:37:50.289Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c4/e4e3b998e116625562a872a342419652fa6ca73f464d9faf9f52f1aff427/coverage-7.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1aec326ed237e5880bfe69ad41616d333712c7937bcefc1343145e972938f9b3", size = 241128, upload-time = "2025-05-23T11:37:52.229Z" }, + { url = "https://files.pythonhosted.org/packages/b1/67/b28904afea3e87a895da850ba587439a61699bf4b73d04d0dfd99bbd33b4/coverage-7.8.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5e818796f71702d7a13e50c70de2a1924f729228580bcba1607cccf32eea46e6", size = 239026, upload-time = "2025-05-23T11:37:53.846Z" }, + { url = "https://files.pythonhosted.org/packages/8c/0f/47bf7c5630d81bc2cd52b9e13043685dbb7c79372a7f5857279cc442b37c/coverage-7.8.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:546e537d9e24efc765c9c891328f30f826e3e4808e31f5d0f87c4ba12bbd1622", size = 240172, upload-time = "2025-05-23T11:37:55.711Z" }, + { url = "https://files.pythonhosted.org/packages/ba/38/af3eb9d36d85abc881f5aaecf8209383dbe0fa4cac2d804c55d05c51cb04/coverage-7.8.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab9b09a2349f58e73f8ebc06fac546dd623e23b063e5398343c5270072e3201c", size = 240086, upload-time = "2025-05-23T11:37:57.724Z" }, + { url = "https://files.pythonhosted.org/packages/9e/64/c40c27c2573adeba0fe16faf39a8aa57368a1f2148865d6bb24c67eadb41/coverage-7.8.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fd51355ab8a372d89fb0e6a31719e825cf8df8b6724bee942fb5b92c3f016ba3", size = 238792, upload-time = "2025-05-23T11:37:59.737Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ab/b7c85146f15457671c1412afca7c25a5696d7625e7158002aa017e2d7e3c/coverage-7.8.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0774df1e093acb6c9e4d58bce7f86656aeed6c132a16e2337692c12786b32404", size = 239096, upload-time = "2025-05-23T11:38:01.693Z" }, + { url = "https://files.pythonhosted.org/packages/d3/50/9446dad1310905fb1dc284d60d4320a5b25d4e3e33f9ea08b8d36e244e23/coverage-7.8.2-cp310-cp310-win32.whl", hash = "sha256:00f2e2f2e37f47e5f54423aeefd6c32a7dbcedc033fcd3928a4f4948e8b96af7", size = 214144, upload-time = "2025-05-23T11:38:03.68Z" }, + { url = "https://files.pythonhosted.org/packages/23/ed/792e66ad7b8b0df757db8d47af0c23659cdb5a65ef7ace8b111cacdbee89/coverage-7.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:145b07bea229821d51811bf15eeab346c236d523838eda395ea969d120d13347", size = 215043, upload-time = "2025-05-23T11:38:05.217Z" }, + { url = "https://files.pythonhosted.org/packages/6a/4d/1ff618ee9f134d0de5cc1661582c21a65e06823f41caf801aadf18811a8e/coverage-7.8.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b99058eef42e6a8dcd135afb068b3d53aff3921ce699e127602efff9956457a9", size = 211692, upload-time = "2025-05-23T11:38:08.485Z" }, + { url = "https://files.pythonhosted.org/packages/96/fa/c3c1b476de96f2bc7a8ca01a9f1fcb51c01c6b60a9d2c3e66194b2bdb4af/coverage-7.8.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5feb7f2c3e6ea94d3b877def0270dff0947b8d8c04cfa34a17be0a4dc1836879", size = 212115, upload-time = "2025-05-23T11:38:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/f7/c2/5414c5a1b286c0f3881ae5adb49be1854ac5b7e99011501f81c8c1453065/coverage-7.8.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:670a13249b957bb9050fab12d86acef7bf8f6a879b9d1a883799276e0d4c674a", size = 244740, upload-time = "2025-05-23T11:38:11.947Z" }, + { url = "https://files.pythonhosted.org/packages/cd/46/1ae01912dfb06a642ef3dd9cf38ed4996fda8fe884dab8952da616f81a2b/coverage-7.8.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0bdc8bf760459a4a4187b452213e04d039990211f98644c7292adf1e471162b5", size = 242429, upload-time = "2025-05-23T11:38:13.955Z" }, + { url = "https://files.pythonhosted.org/packages/06/58/38c676aec594bfe2a87c7683942e5a30224791d8df99bcc8439fde140377/coverage-7.8.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07a989c867986c2a75f158f03fdb413128aad29aca9d4dbce5fc755672d96f11", size = 244218, upload-time = "2025-05-23T11:38:15.631Z" }, + { url = "https://files.pythonhosted.org/packages/80/0c/95b1023e881ce45006d9abc250f76c6cdab7134a1c182d9713878dfefcb2/coverage-7.8.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2db10dedeb619a771ef0e2949ccba7b75e33905de959c2643a4607bef2f3fb3a", size = 243865, upload-time = "2025-05-23T11:38:17.622Z" }, + { url = "https://files.pythonhosted.org/packages/57/37/0ae95989285a39e0839c959fe854a3ae46c06610439350d1ab860bf020ac/coverage-7.8.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e6ea7dba4e92926b7b5f0990634b78ea02f208d04af520c73a7c876d5a8d36cb", size = 242038, upload-time = "2025-05-23T11:38:19.966Z" }, + { url = "https://files.pythonhosted.org/packages/4d/82/40e55f7c0eb5e97cc62cbd9d0746fd24e8caf57be5a408b87529416e0c70/coverage-7.8.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ef2f22795a7aca99fc3c84393a55a53dd18ab8c93fb431004e4d8f0774150f54", size = 242567, upload-time = "2025-05-23T11:38:21.912Z" }, + { url = "https://files.pythonhosted.org/packages/f9/35/66a51adc273433a253989f0d9cc7aa6bcdb4855382cf0858200afe578861/coverage-7.8.2-cp311-cp311-win32.whl", hash = "sha256:641988828bc18a6368fe72355df5f1703e44411adbe49bba5644b941ce6f2e3a", size = 214194, upload-time = "2025-05-23T11:38:23.571Z" }, + { url = "https://files.pythonhosted.org/packages/f6/8f/a543121f9f5f150eae092b08428cb4e6b6d2d134152c3357b77659d2a605/coverage-7.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:8ab4a51cb39dc1933ba627e0875046d150e88478dbe22ce145a68393e9652975", size = 215109, upload-time = "2025-05-23T11:38:25.137Z" }, + { url = "https://files.pythonhosted.org/packages/77/65/6cc84b68d4f35186463cd7ab1da1169e9abb59870c0f6a57ea6aba95f861/coverage-7.8.2-cp311-cp311-win_arm64.whl", hash = "sha256:8966a821e2083c74d88cca5b7dcccc0a3a888a596a04c0b9668a891de3a0cc53", size = 213521, upload-time = "2025-05-23T11:38:27.123Z" }, { url = "https://files.pythonhosted.org/packages/8d/2a/1da1ada2e3044fcd4a3254fb3576e160b8fe5b36d705c8a31f793423f763/coverage-7.8.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2f6fe3654468d061942591aef56686131335b7a8325684eda85dacdf311356c", size = 211876, upload-time = "2025-05-23T11:38:29.01Z" }, { url = "https://files.pythonhosted.org/packages/70/e9/3d715ffd5b6b17a8be80cd14a8917a002530a99943cc1939ad5bb2aa74b9/coverage-7.8.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76090fab50610798cc05241bf83b603477c40ee87acd358b66196ab0ca44ffa1", size = 212130, upload-time = "2025-05-23T11:38:30.675Z" }, { url = "https://files.pythonhosted.org/packages/a0/02/fdce62bb3c21649abfd91fbdcf041fb99be0d728ff00f3f9d54d97ed683e/coverage-7.8.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bd0a0a5054be160777a7920b731a0570284db5142abaaf81bcbb282b8d99279", size = 246176, upload-time = "2025-05-23T11:38:32.395Z" }, @@ -580,15 +681,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/50/63/2d624ac7d7ccd4ebbd3c6a9eba9d7fc4491a1226071360d59dd84928ccb2/coverage-7.8.2-cp313-cp313t-win32.whl", hash = "sha256:3f5673888d3676d0a745c3d0e16da338c5eea300cb1f4ada9c872981265e76d8", size = 215109, upload-time = "2025-05-23T11:39:26.722Z" }, { url = "https://files.pythonhosted.org/packages/22/5e/7053b71462e970e869111c1853afd642212568a350eba796deefdfbd0770/coverage-7.8.2-cp313-cp313t-win_amd64.whl", hash = "sha256:2c08b05ee8d7861e45dc5a2cc4195c8c66dca5ac613144eb6ebeaff2d502e73d", size = 216268, upload-time = "2025-05-23T11:39:28.429Z" }, { url = "https://files.pythonhosted.org/packages/07/69/afa41aa34147655543dbe96994f8a246daf94b361ccf5edfd5df62ce066a/coverage-7.8.2-cp313-cp313t-win_arm64.whl", hash = "sha256:1e1448bb72b387755e1ff3ef1268a06617afd94188164960dba8d0245a46004b", size = 214071, upload-time = "2025-05-23T11:39:30.55Z" }, + { url = "https://files.pythonhosted.org/packages/69/2f/572b29496d8234e4a7773200dd835a0d32d9e171f2d974f3fe04a9dbc271/coverage-7.8.2-pp39.pp310.pp311-none-any.whl", hash = "sha256:ec455eedf3ba0bbdf8f5a570012617eb305c63cb9f03428d39bf544cb2b94837", size = 203636, upload-time = "2025-05-23T11:39:52.002Z" }, { url = "https://files.pythonhosted.org/packages/a0/1a/0b9c32220ad694d66062f571cc5cedfa9997b64a591e8a500bb63de1bd40/coverage-7.8.2-py3-none-any.whl", hash = "sha256:726f32ee3713f7359696331a18daf0c3b3a70bb0ae71141b9d3c52be7c595e32", size = 203623, upload-time = "2025-05-23T11:39:53.846Z" }, ] +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + [[package]] name = "cryptography" version = "46.0.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" } wheels = [ @@ -637,6 +745,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" }, { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" }, { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" }, + { url = "https://files.pythonhosted.org/packages/d9/cd/1a8633802d766a0fa46f382a77e096d7e209e0817892929655fe0586ae32/cryptography-46.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a23582810fedb8c0bc47524558fb6c56aac3fc252cb306072fd2815da2a47c32", size = 3689163, upload-time = "2025-10-15T23:18:13.821Z" }, + { url = "https://files.pythonhosted.org/packages/4c/59/6b26512964ace6480c3e54681a9859c974172fb141c38df11eadd8416947/cryptography-46.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e7aec276d68421f9574040c26e2a7c3771060bc0cff408bae1dcb19d3ab1e63c", size = 3429474, upload-time = "2025-10-15T23:18:15.477Z" }, + { url = "https://files.pythonhosted.org/packages/06/8a/e60e46adab4362a682cf142c7dcb5bf79b782ab2199b0dcb81f55970807f/cryptography-46.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7ce938a99998ed3c8aa7e7272dca1a610401ede816d36d0693907d863b10d9ea", size = 3698132, upload-time = "2025-10-15T23:18:17.056Z" }, + { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" }, + { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" }, + { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" }, + { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" }, + { url = "https://files.pythonhosted.org/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload-time = "2025-10-15T23:18:26.227Z" }, ] [[package]] @@ -663,6 +779,7 @@ version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "packaging" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/62/55/f054de99871e7beb81935dea8a10b90cd5ce42122b1c3081d5282fdb3621/dependency_groups-1.3.1.tar.gz", hash = "sha256:78078301090517fd938c19f64a53ce98c32834dfe0dee6b88004a569a6adfefd", size = 10093, upload-time = "2025-05-02T00:34:29.452Z" } wheels = [ @@ -710,6 +827,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b0/0d/9feae160378a3553fa9a339b0e9c1a048e147a4127210e286ef18b730f03/durationpy-0.10-py3-none-any.whl", hash = "sha256:3b41e1b601234296b4fb368338fdcd3e13e0b4fb5b67345948f4f2bf9868b286", size = 3922, upload-time = "2025-05-17T13:52:36.463Z" }, ] +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + [[package]] name = "execnet" version = "2.1.2" @@ -842,6 +971,26 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/b6/e0/318c1ce3ae5a17894d5791e87aea147587c9e702f24122cc7a5c8bbaeeb1/grpcio-1.76.0.tar.gz", hash = "sha256:7be78388d6da1a25c0d5ec506523db58b18be22d9c37d8d3a32c08be4987bd73", size = 12785182, upload-time = "2025-10-21T16:23:12.106Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/88/17/ff4795dc9a34b6aee6ec379f1b66438a3789cd1315aac0cbab60d92f74b3/grpcio-1.76.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:65a20de41e85648e00305c1bb09a3598f840422e522277641145a32d42dcefcc", size = 5840037, upload-time = "2025-10-21T16:20:25.069Z" }, + { url = "https://files.pythonhosted.org/packages/4e/ff/35f9b96e3fa2f12e1dcd58a4513a2e2294a001d64dec81677361b7040c9a/grpcio-1.76.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:40ad3afe81676fd9ec6d9d406eda00933f218038433980aa19d401490e46ecde", size = 11836482, upload-time = "2025-10-21T16:20:30.113Z" }, + { url = "https://files.pythonhosted.org/packages/3e/1c/8374990f9545e99462caacea5413ed783014b3b66ace49e35c533f07507b/grpcio-1.76.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:035d90bc79eaa4bed83f524331d55e35820725c9fbb00ffa1904d5550ed7ede3", size = 6407178, upload-time = "2025-10-21T16:20:32.733Z" }, + { url = "https://files.pythonhosted.org/packages/1e/77/36fd7d7c75a6c12542c90a6d647a27935a1ecaad03e0ffdb7c42db6b04d2/grpcio-1.76.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4215d3a102bd95e2e11b5395c78562967959824156af11fa93d18fdd18050990", size = 7075684, upload-time = "2025-10-21T16:20:35.435Z" }, + { url = "https://files.pythonhosted.org/packages/38/f7/e3cdb252492278e004722306c5a8935eae91e64ea11f0af3437a7de2e2b7/grpcio-1.76.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:49ce47231818806067aea3324d4bf13825b658ad662d3b25fada0bdad9b8a6af", size = 6611133, upload-time = "2025-10-21T16:20:37.541Z" }, + { url = "https://files.pythonhosted.org/packages/7e/20/340db7af162ccd20a0893b5f3c4a5d676af7b71105517e62279b5b61d95a/grpcio-1.76.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8cc3309d8e08fd79089e13ed4819d0af72aa935dd8f435a195fd152796752ff2", size = 7195507, upload-time = "2025-10-21T16:20:39.643Z" }, + { url = "https://files.pythonhosted.org/packages/10/f0/b2160addc1487bd8fa4810857a27132fb4ce35c1b330c2f3ac45d697b106/grpcio-1.76.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:971fd5a1d6e62e00d945423a567e42eb1fa678ba89072832185ca836a94daaa6", size = 8160651, upload-time = "2025-10-21T16:20:42.492Z" }, + { url = "https://files.pythonhosted.org/packages/2c/2c/ac6f98aa113c6ef111b3f347854e99ebb7fb9d8f7bb3af1491d438f62af4/grpcio-1.76.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9d9adda641db7207e800a7f089068f6f645959f2df27e870ee81d44701dd9db3", size = 7620568, upload-time = "2025-10-21T16:20:45.995Z" }, + { url = "https://files.pythonhosted.org/packages/90/84/7852f7e087285e3ac17a2703bc4129fafee52d77c6c82af97d905566857e/grpcio-1.76.0-cp310-cp310-win32.whl", hash = "sha256:063065249d9e7e0782d03d2bca50787f53bd0fb89a67de9a7b521c4a01f1989b", size = 3998879, upload-time = "2025-10-21T16:20:48.592Z" }, + { url = "https://files.pythonhosted.org/packages/10/30/d3d2adcbb6dd3ff59d6ac3df6ef830e02b437fb5c90990429fd180e52f30/grpcio-1.76.0-cp310-cp310-win_amd64.whl", hash = "sha256:a6ae758eb08088d36812dd5d9af7a9859c05b1e0f714470ea243694b49278e7b", size = 4706892, upload-time = "2025-10-21T16:20:50.697Z" }, + { url = "https://files.pythonhosted.org/packages/a0/00/8163a1beeb6971f66b4bbe6ac9457b97948beba8dd2fc8e1281dce7f79ec/grpcio-1.76.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:2e1743fbd7f5fa713a1b0a8ac8ebabf0ec980b5d8809ec358d488e273b9cf02a", size = 5843567, upload-time = "2025-10-21T16:20:52.829Z" }, + { url = "https://files.pythonhosted.org/packages/10/c1/934202f5cf335e6d852530ce14ddb0fef21be612ba9ecbbcbd4d748ca32d/grpcio-1.76.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:a8c2cf1209497cf659a667d7dea88985e834c24b7c3b605e6254cbb5076d985c", size = 11848017, upload-time = "2025-10-21T16:20:56.705Z" }, + { url = "https://files.pythonhosted.org/packages/11/0b/8dec16b1863d74af6eb3543928600ec2195af49ca58b16334972f6775663/grpcio-1.76.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:08caea849a9d3c71a542827d6df9d5a69067b0a1efbea8a855633ff5d9571465", size = 6412027, upload-time = "2025-10-21T16:20:59.3Z" }, + { url = "https://files.pythonhosted.org/packages/d7/64/7b9e6e7ab910bea9d46f2c090380bab274a0b91fb0a2fe9b0cd399fffa12/grpcio-1.76.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f0e34c2079d47ae9f6188211db9e777c619a21d4faba6977774e8fa43b085e48", size = 7075913, upload-time = "2025-10-21T16:21:01.645Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/093c46e9546073cefa789bd76d44c5cb2abc824ca62af0c18be590ff13ba/grpcio-1.76.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8843114c0cfce61b40ad48df65abcfc00d4dba82eae8718fab5352390848c5da", size = 6615417, upload-time = "2025-10-21T16:21:03.844Z" }, + { url = "https://files.pythonhosted.org/packages/f7/b6/5709a3a68500a9c03da6fb71740dcdd5ef245e39266461a03f31a57036d8/grpcio-1.76.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8eddfb4d203a237da6f3cc8a540dad0517d274b5a1e9e636fd8d2c79b5c1d397", size = 7199683, upload-time = "2025-10-21T16:21:06.195Z" }, + { url = "https://files.pythonhosted.org/packages/91/d3/4b1f2bf16ed52ce0b508161df3a2d186e4935379a159a834cb4a7d687429/grpcio-1.76.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:32483fe2aab2c3794101c2a159070584e5db11d0aa091b2c0ea9c4fc43d0d749", size = 8163109, upload-time = "2025-10-21T16:21:08.498Z" }, + { url = "https://files.pythonhosted.org/packages/5c/61/d9043f95f5f4cf085ac5dd6137b469d41befb04bd80280952ffa2a4c3f12/grpcio-1.76.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dcfe41187da8992c5f40aa8c5ec086fa3672834d2be57a32384c08d5a05b4c00", size = 7626676, upload-time = "2025-10-21T16:21:10.693Z" }, + { url = "https://files.pythonhosted.org/packages/36/95/fd9a5152ca02d8881e4dd419cdd790e11805979f499a2e5b96488b85cf27/grpcio-1.76.0-cp311-cp311-win32.whl", hash = "sha256:2107b0c024d1b35f4083f11245c0e23846ae64d02f40b2b226684840260ed054", size = 3997688, upload-time = "2025-10-21T16:21:12.746Z" }, + { url = "https://files.pythonhosted.org/packages/60/9c/5c359c8d4c9176cfa3c61ecd4efe5affe1f38d9bae81e81ac7186b4c9cc8/grpcio-1.76.0-cp311-cp311-win_amd64.whl", hash = "sha256:522175aba7af9113c48ec10cc471b9b9bd4f6ceb36aeb4544a8e2c80ed9d252d", size = 4709315, upload-time = "2025-10-21T16:21:15.26Z" }, { url = "https://files.pythonhosted.org/packages/bf/05/8e29121994b8d959ffa0afd28996d452f291b48cfc0875619de0bde2c50c/grpcio-1.76.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:81fd9652b37b36f16138611c7e884eb82e0cec137c40d3ef7c3f9b3ed00f6ed8", size = 5799718, upload-time = "2025-10-21T16:21:17.939Z" }, { url = "https://files.pythonhosted.org/packages/d9/75/11d0e66b3cdf998c996489581bdad8900db79ebd83513e45c19548f1cba4/grpcio-1.76.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:04bbe1bfe3a68bbfd4e52402ab7d4eb59d72d02647ae2042204326cf4bbad280", size = 11825627, upload-time = "2025-10-21T16:21:20.466Z" }, { url = "https://files.pythonhosted.org/packages/28/50/2f0aa0498bc188048f5d9504dcc5c2c24f2eb1a9337cd0fa09a61a2e75f0/grpcio-1.76.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d388087771c837cdb6515539f43b9d4bf0b0f23593a24054ac16f7a960be16f4", size = 6359167, upload-time = "2025-10-21T16:21:23.122Z" }, @@ -931,6 +1080,20 @@ version = "0.7.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/e5/c07e0bcf4ec8db8164e9f6738c048b2e66aabf30e7506f440c4cc6953f60/httptools-0.7.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:11d01b0ff1fe02c4c32d60af61a4d613b74fad069e47e06e9067758c01e9ac78", size = 204531, upload-time = "2025-10-10T03:54:20.887Z" }, + { url = "https://files.pythonhosted.org/packages/7e/4f/35e3a63f863a659f92ffd92bef131f3e81cf849af26e6435b49bd9f6f751/httptools-0.7.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84d86c1e5afdc479a6fdabf570be0d3eb791df0ae727e8dbc0259ed1249998d4", size = 109408, upload-time = "2025-10-10T03:54:22.455Z" }, + { url = "https://files.pythonhosted.org/packages/f5/71/b0a9193641d9e2471ac541d3b1b869538a5fb6419d52fd2669fa9c79e4b8/httptools-0.7.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c8c751014e13d88d2be5f5f14fc8b89612fcfa92a9cc480f2bc1598357a23a05", size = 440889, upload-time = "2025-10-10T03:54:23.753Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d9/2e34811397b76718750fea44658cb0205b84566e895192115252e008b152/httptools-0.7.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:654968cb6b6c77e37b832a9be3d3ecabb243bbe7a0b8f65fbc5b6b04c8fcabed", size = 440460, upload-time = "2025-10-10T03:54:25.313Z" }, + { url = "https://files.pythonhosted.org/packages/01/3f/a04626ebeacc489866bb4d82362c0657b2262bef381d68310134be7f40bb/httptools-0.7.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b580968316348b474b020edf3988eecd5d6eec4634ee6561e72ae3a2a0e00a8a", size = 425267, upload-time = "2025-10-10T03:54:26.81Z" }, + { url = "https://files.pythonhosted.org/packages/a5/99/adcd4f66614db627b587627c8ad6f4c55f18881549bab10ecf180562e7b9/httptools-0.7.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d496e2f5245319da9d764296e86c5bb6fcf0cf7a8806d3d000717a889c8c0b7b", size = 424429, upload-time = "2025-10-10T03:54:28.174Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/ec8fc904a8fd30ba022dfa85f3bbc64c3c7cd75b669e24242c0658e22f3c/httptools-0.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:cbf8317bfccf0fed3b5680c559d3459cccf1abe9039bfa159e62e391c7270568", size = 86173, upload-time = "2025-10-10T03:54:29.5Z" }, + { url = "https://files.pythonhosted.org/packages/9c/08/17e07e8d89ab8f343c134616d72eebfe03798835058e2ab579dcc8353c06/httptools-0.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:474d3b7ab469fefcca3697a10d11a32ee2b9573250206ba1e50d5980910da657", size = 206521, upload-time = "2025-10-10T03:54:31.002Z" }, + { url = "https://files.pythonhosted.org/packages/aa/06/c9c1b41ff52f16aee526fd10fbda99fa4787938aa776858ddc4a1ea825ec/httptools-0.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3c3b7366bb6c7b96bd72d0dbe7f7d5eead261361f013be5f6d9590465ea1c70", size = 110375, upload-time = "2025-10-10T03:54:31.941Z" }, + { url = "https://files.pythonhosted.org/packages/cc/cc/10935db22fda0ee34c76f047590ca0a8bd9de531406a3ccb10a90e12ea21/httptools-0.7.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:379b479408b8747f47f3b253326183d7c009a3936518cdb70db58cffd369d9df", size = 456621, upload-time = "2025-10-10T03:54:33.176Z" }, + { url = "https://files.pythonhosted.org/packages/0e/84/875382b10d271b0c11aa5d414b44f92f8dd53e9b658aec338a79164fa548/httptools-0.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cad6b591a682dcc6cf1397c3900527f9affef1e55a06c4547264796bbd17cf5e", size = 454954, upload-time = "2025-10-10T03:54:34.226Z" }, + { url = "https://files.pythonhosted.org/packages/30/e1/44f89b280f7e46c0b1b2ccee5737d46b3bb13136383958f20b580a821ca0/httptools-0.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eb844698d11433d2139bbeeb56499102143beb582bd6c194e3ba69c22f25c274", size = 440175, upload-time = "2025-10-10T03:54:35.942Z" }, + { url = "https://files.pythonhosted.org/packages/6f/7e/b9287763159e700e335028bc1824359dc736fa9b829dacedace91a39b37e/httptools-0.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f65744d7a8bdb4bda5e1fa23e4ba16832860606fcc09d674d56e425e991539ec", size = 440310, upload-time = "2025-10-10T03:54:37.1Z" }, + { url = "https://files.pythonhosted.org/packages/b3/07/5b614f592868e07f5c94b1f301b5e14a21df4e8076215a3bccb830a687d8/httptools-0.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:135fbe974b3718eada677229312e97f3b31f8a9c8ffa3ae6f565bf808d5b6bcb", size = 86875, upload-time = "2025-10-10T03:54:38.421Z" }, { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" }, { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" }, { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" }, @@ -1066,6 +1229,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, { name = "decorator" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "jedi" }, { name = "matplotlib-inline" }, { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, @@ -1073,6 +1237,7 @@ dependencies = [ { name = "pygments" }, { name = "stack-data" }, { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a2/9f/d9a73710df947b7804bd9d93509463fb3a89e0ddc99c9fcc67279cddbeb6/ipython-8.36.0.tar.gz", hash = "sha256:24658e9fe5c5c819455043235ba59cfffded4a35936eefceceab6b192f7092ff", size = 5604997, upload-time = "2025-04-25T18:03:38.031Z" } wheels = [ @@ -1129,6 +1294,105 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/89/57/ad078d7379e390798559446607e413fc953c7510711462ab34194dba5924/jira-3.10.5-py3-none-any.whl", hash = "sha256:d4da1385c924ee693d6cc9838e56a34e31d74f0d6899934ef35bbd0d2d33997f", size = 79250, upload-time = "2025-07-28T12:18:21.368Z" }, ] +[[package]] +name = "jiter" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/1f/10936e16d8860c70698a1aa939a46aa0224813b782bce4e000e637da0b2d/jiter-0.16.0.tar.gz", hash = "sha256:7b24c3492c5f4f84a37946ad9cf504910cf6a782d6a4e0689b6673c5894b4a1c", size = 176431, upload-time = "2026-06-29T13:05:13.657Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/d8/b959609e44012a42b1f3e5ba98ea3b33c7e41e6d4b77cd8f00fd19b1d3ad/jiter-0.16.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fc4f8def331036a7b8e981b4347ebe409981edbc8308a5ea842b8c3614fa6c", size = 310082, upload-time = "2026-06-29T13:02:31.356Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3d/4d7f5667ea0e0548534ba880b84bb3d12924fd133aa83ad6c6c80fca3d76/jiter-0.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5a71d0d2014c3275043e1170bf3d4e771493cb0dcf07be54c567155f4d8ee64b", size = 315643, upload-time = "2026-06-29T13:02:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/9b/83/bed2dcb5c9f3e1ccfcbc67dda48265fe7d5ad0c9cadda5fe95f6e3b87f94/jiter-0.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:741eed508c233a76313a1c7b001f8f21b82f14327e9196ae8bd29a2cc164ae84", size = 341363, upload-time = "2026-06-29T13:02:34.853Z" }, + { url = "https://files.pythonhosted.org/packages/f4/2f/6bb3c3dda668ebc0445689c81a2b0f26a82b10843d67ed9c9b2c3edc177f/jiter-0.16.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3fb7bc819187b56dc48aa5c833aaf92257da8e07efdb9306156667bd2eeb491c", size = 365483, upload-time = "2026-06-29T13:02:36.295Z" }, + { url = "https://files.pythonhosted.org/packages/92/35/8a045ccb39164e70dcdae696413b661771f148b68b12b175c3a04d901937/jiter-0.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7c9610fd25ebccb43fca584136f5c2fbb26802447eccd430dfdbab95a0fd5126", size = 461219, upload-time = "2026-06-29T13:02:38.116Z" }, + { url = "https://files.pythonhosted.org/packages/e7/99/22292dbbf0ed0c610cfe5ddc7f3bd67237a412f121318f865196e62a07bd/jiter-0.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4a1d68ff7ca1d3b5dee20a97a3decda7d5f15003823bf6d140c81f8561d3bc5c", size = 374905, upload-time = "2026-06-29T13:02:40.357Z" }, + { url = "https://files.pythonhosted.org/packages/29/ac/2f55ccb1f0eeafa6d89d24caf52f6f0944a59290ee199e9ade62177dca42/jiter-0.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb08c276dd02dac3a284acdd02cacc630d2e3cd6572a4b85519f35cbd133c3de", size = 348320, upload-time = "2026-06-29T13:02:41.923Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/7d88b9174c40064fabc07c84a9b62e6b10f5644562ec0e0a29392edbe978/jiter-0.16.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:8fc4d94713c4697347e38faf7d6ef91547c142219bdcfc7220c4870879974244", size = 356519, upload-time = "2026-06-29T13:02:43.436Z" }, + { url = "https://files.pythonhosted.org/packages/27/57/c4a33aeef513a9d5e26e31534e0bcc752d6ea0e54c94ddb7b68bade669c2/jiter-0.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a0f05e229edb29e68cdd0ccb83cea13b64263416120cf943767a6fd72e6787f", size = 394204, upload-time = "2026-06-29T13:02:44.987Z" }, + { url = "https://files.pythonhosted.org/packages/9d/70/c6c23e76ebb3766b111bc399437bbc9f870a76e2a92e10b2a5f561d57372/jiter-0.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:2c842cbf374a8daf50b2c04212995bee34ca2ac2cdc29a901b4cdb072c9c4131", size = 521477, upload-time = "2026-06-29T13:02:46.724Z" }, + { url = "https://files.pythonhosted.org/packages/2a/d3/0001c8c0c5976af2625bb1cfb1895e8ec693b6589fe4574b8e6fc2c85501/jiter-0.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5ed466aee31294d7cdcd4d37dfe5c42c97bc29d9a5f00eacf24504358309cb9b", size = 552187, upload-time = "2026-06-29T13:02:48.144Z" }, + { url = "https://files.pythonhosted.org/packages/f6/76/311b718e07e85740e48619c0632b36f7e0b8d113984499e436452ed13a9a/jiter-0.16.0-cp310-cp310-win32.whl", hash = "sha256:b42e9ff5376819c053da25809a8d4b6fa6e473b4856ebe42e298ac958be3d7f9", size = 206513, upload-time = "2026-06-29T13:02:49.515Z" }, + { url = "https://files.pythonhosted.org/packages/db/7f/ac680eeb0777dc0eb7dc824800ba27880d7f6bc712e362d34ad8ee559f36/jiter-0.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:10438939205546132189c8e74a2d536a707841f3a25cd7c74ee91fe503407a26", size = 199505, upload-time = "2026-06-29T13:02:50.829Z" }, + { url = "https://files.pythonhosted.org/packages/4e/3f/fae6cc967d120ec89e31c5418a51176d8278b3087fbb384a9176754f353c/jiter-0.16.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:67fddeda1688f0cce2d2ae83ccf8a80f79936f2d2997d6cc2261f82fdb54a4d3", size = 309289, upload-time = "2026-06-29T13:02:52.301Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/97c6c3562c077f6247d6e6ce5c82562500b6316c0d928e97e106b7a1321a/jiter-0.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c90c0f63df322be920eda6ce622e3083d8906ba267f8220fe7873213b8b4430e", size = 315181, upload-time = "2026-06-29T13:02:53.964Z" }, + { url = "https://files.pythonhosted.org/packages/7b/89/d8d073f8aa2667e46c6c0873f86fe4a512bba4293cc730f626a076211a62/jiter-0.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64c0203212098470032aabcde9356fc168f377aade3e43def61dfe17e92f2037", size = 340939, upload-time = "2026-06-29T13:02:55.412Z" }, + { url = "https://files.pythonhosted.org/packages/87/c9/db4fda3ed73fb864139305e935e5b8b38a5a24692a5a9dd356c22f1b9c8d/jiter-0.16.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12288303c9844e61e1651d02a9a6f6633e47d39f897d6991d1427161ce6b746e", size = 364932, upload-time = "2026-06-29T13:02:57.28Z" }, + { url = "https://files.pythonhosted.org/packages/a2/74/52b5e86241057f52ddd7c9a580f90effb51f9d06239f6fc612279b91a838/jiter-0.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cf109d010b4b05a105afb3d43be36a21322d345ad3111e13d15f680afef0e5b", size = 461132, upload-time = "2026-06-29T13:02:58.994Z" }, + { url = "https://files.pythonhosted.org/packages/a9/87/544a700f7447c1f31c5d7833821a4daa5683165c2d5a094fbf5b5800c3dc/jiter-0.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62c1b7fe1f77925acf5af68b6140b8810fa87dfd4dc0a9c8568ec2fa2a10429c", size = 374857, upload-time = "2026-06-29T13:03:00.455Z" }, + { url = "https://files.pythonhosted.org/packages/40/cd/0fcc3f7d39183674d5bfa9ec640faaeb506c60be7c8f94625dfba366e37c/jiter-0.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8597d23c87f59294f83bcb6229b9ed1fccee13dbba967b46930d2f1759466fee", size = 347053, upload-time = "2026-06-29T13:03:02.045Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ae/c7e64e7932ad597fa395b61440b249ada6366716e25c6e08dd2afbd021e6/jiter-0.16.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:3126a5dbad56401989ac769aca0cb56005bfb3e2366eea0ca99d1a91c3c1ee03", size = 356153, upload-time = "2026-06-29T13:03:03.706Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/1c719044f14da814e1a060191ab19b96f3e99207bc5b4bfc6d6be34b3f80/jiter-0.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c4b4717bdb35ae456f831a6b08d01880fff399887a6bbc526a583a406e484eea", size = 393956, upload-time = "2026-06-29T13:03:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/3b/dc/7b2f303a2847207e265503853a2d964a55354cffd62a5f2936c155486798/jiter-0.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:adff21bc78edfe086c15eb495b900306076de378dc2337c132401fc39bd79c91", size = 521081, upload-time = "2026-06-29T13:03:06.886Z" }, + { url = "https://files.pythonhosted.org/packages/c2/5f/501cf6e1e09caeb420195179ffc6f62aca603f1220ec53fd80d0d70b3e56/jiter-0.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dab907db06fc593645e73109acf4581ba5b548897d28b9348dc41ddc8343b2d3", size = 552085, upload-time = "2026-06-29T13:03:08.339Z" }, + { url = "https://files.pythonhosted.org/packages/79/54/aa5be86520113b79455c3877f3d1f07a348098df4083ba3688e9537e52dd/jiter-0.16.0-cp311-cp311-win32.whl", hash = "sha256:560b2cf3fb03240cd34f27409a238547488708f05b7c3924f571a60422251ec7", size = 206755, upload-time = "2026-06-29T13:03:09.653Z" }, + { url = "https://files.pythonhosted.org/packages/64/ec/2feb893eb330bd69b413866f4d5daada33c3962f1c6f270c91ca2d87fdf9/jiter-0.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:e431cfc9caf44c1d5459ff77d4e64cbf85fddb6a35dad836a15c6a9ec23087c1", size = 199155, upload-time = "2026-06-29T13:03:10.979Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9c/ca040d94415048a3666fc237774df8151c96f8d2b661cbe3b184acc95876/jiter-0.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:2a8e9e39cf083016137aa5cadafe3188adc2ba6ba1fbf1e5d18889ad3e9ad056", size = 194403, upload-time = "2026-06-29T13:03:12.341Z" }, + { url = "https://files.pythonhosted.org/packages/83/2b/52ace16ed031354f0539749a49e4bf33797d82bea5137910835fa4b09793/jiter-0.16.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:67c3bc1760f8c99d805dcab4e644027142a53b1d5d861f18780ebdbd5d40b72a", size = 306943, upload-time = "2026-06-29T13:03:14.035Z" }, + { url = "https://files.pythonhosted.org/packages/94/2e/34957c2c1b661c252ba9bcc60ae0bddc27e0f7202c6073326a13c5390eec/jiter-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5af7780e4a26bd7d0d989592bf9ef12ebf806b74ab709223ecca37c749872ea9", size = 307779, upload-time = "2026-06-29T13:03:15.418Z" }, + { url = "https://files.pythonhosted.org/packages/88/6c/59bd309cab4460c54cf1079f3eb7fe7af6a4c895c5c957a53378693bad2b/jiter-0.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5bf78d0e05e45cfdd66558893938d59afe3d1b1a824a202039b20e607d25a72", size = 335826, upload-time = "2026-06-29T13:03:17.11Z" }, + { url = "https://files.pythonhosted.org/packages/3b/8c/f5ef7b65f0df47afa16596969defb281ebb86e96df346d62be6fd853d620/jiter-0.16.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4444a83f946605990c98f625cdd3d2725bfb818158760c5748c653170a20e0e", size = 362573, upload-time = "2026-06-29T13:03:18.781Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0b/ace4354da061ee38844a0c27dc2c21eecd27aea119e8da324bea987522d0/jiter-0.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3a23f0e4f957e1be65752d2dfac9a5a06b1917af8dc85deb639c3b9d02e31290", size = 457979, upload-time = "2026-06-29T13:03:20.293Z" }, + { url = "https://files.pythonhosted.org/packages/55/40/c0253d3772eb9dcd8e6606ee9b2d53ec8e5b814589c47f140aa585f21eaa/jiter-0.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c22a488f7b9218e245a0025a9ba6b100e2e54700831cf4cf16833a27fba3ad01", size = 372302, upload-time = "2026-06-29T13:03:21.739Z" }, + { url = "https://files.pythonhosted.org/packages/a8/d2/4839422241aa12860ce597b20068727094ba0bc480723c74924ca5bad483/jiter-0.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46add52f4ad47a08bfb1219f3e673da972191489a33016edefdb5ea55bfa8c48", size = 343805, upload-time = "2026-06-29T13:03:23.384Z" }, + { url = "https://files.pythonhosted.org/packages/e2/59/e196888a05befdda7dbe299b722d56f2f6eec65402bc34c0a3306d595feb/jiter-0.16.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:9c8a956fd72c2cf1e730d01ea080341f13aa0a97a4a33b51abebe725b7ae9ca9", size = 351107, upload-time = "2026-06-29T13:03:24.815Z" }, + { url = "https://files.pythonhosted.org/packages/ec/74/4cd9e0fca65232136400354b630fbfcd2de634e22ccbb96567725981b548/jiter-0.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:561926e0573ffe4a32498420a76d64b16c513e1ab413b9d28158a8764ac701e5", size = 388441, upload-time = "2026-06-29T13:03:26.266Z" }, + { url = "https://files.pythonhosted.org/packages/d9/8c/554691e48bc711299c0a293dd8a6179e24b2d66a54dc295421fcf64569c0/jiter-0.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:44d019fa8cdaf89bf29c71b39e3712143fdd0ac76725c6ef954f9957a5ea8730", size = 516354, upload-time = "2026-06-29T13:03:28.02Z" }, + { url = "https://files.pythonhosted.org/packages/a4/cb/01e9d69dc2cc6759d4f91e230b34489c4fdb2518992650633f9e20bece89/jiter-0.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0df91907609837f33341b8e6fe73b95991fdaa57caf1a0fbd343dffe826f386f", size = 547880, upload-time = "2026-06-29T13:03:29.534Z" }, + { url = "https://files.pythonhosted.org/packages/79/70/2953195f1c6ad00f49fa67e13df7e60acb3dd4f387101bc15abccddd905e/jiter-0.16.0-cp312-cp312-win32.whl", hash = "sha256:51d7b836acb0108d7c77df1742332cac2a1fa04a74d6dacec46e7091f0e91274", size = 203473, upload-time = "2026-06-29T13:03:31.025Z" }, + { url = "https://files.pythonhosted.org/packages/2d/05/2909a8b10699a4d560f8c502b6b2c5f3991b682b1922c1eedda242b225bd/jiter-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:1878349266f8ee36ecb1375cc5ba2f115f35fd9f0a1a4119e725e379126647f7", size = 196905, upload-time = "2026-06-29T13:03:32.472Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a9/6b82bb1c8d7790d602489b967b982a909e5d092875a6c2ade96444c8dfc5/jiter-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:2ed5738ae4af18271a51a528b8811b0cbfa4a1858de9d83359e4169855d6a331", size = 190618, upload-time = "2026-06-29T13:03:34.672Z" }, + { url = "https://files.pythonhosted.org/packages/91/c0/555fc60473d30d66894ba825e63615e3be7524fac23858356afa7a38906c/jiter-0.16.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:41977aa5654023948c2dae2a81cbf9c43343954bef1cd59a154dd15a4d84c195", size = 306203, upload-time = "2026-06-29T13:03:36.243Z" }, + { url = "https://files.pythonhosted.org/packages/d0/2b/c3eaf16f5d7c9bad66ea32f40a95bd169b29a91217fcc7f081375157e99c/jiter-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d28bb3c26762358dadf3e5bf0bccd29ae987d65e6988d2e6f49829c76b003c09", size = 306489, upload-time = "2026-06-29T13:03:37.846Z" }, + { url = "https://files.pythonhosted.org/packages/96/3f/02fdfc6705cad96127d883af5c34e4867f554f29ec7705ec1a46156400a9/jiter-0.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0542a7189c26920778658fc8fcf2af8bae05bae9924577f71804acef37996536", size = 335453, upload-time = "2026-06-29T13:03:39.221Z" }, + { url = "https://files.pythonhosted.org/packages/b2/a6/e4bda5920d4b0d7c5dfb7174ce4a6b2e4d3e11c9162c452ef0eab4cdbdbd/jiter-0.16.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8fb8de1e23a0cb2a7f53c335049c7b72b6db41aa6227cdcc0972a1de5cb39450", size = 361625, upload-time = "2026-06-29T13:03:40.597Z" }, + { url = "https://files.pythonhosted.org/packages/b7/97/4e6b59b2c6e55cbb3e183595f81ad65dcfb21c915fee5e19e335df21bc55/jiter-0.16.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b72d0b2990ca754a9102779ac98d8597b7cb31678958562214a007f909eab78e", size = 456958, upload-time = "2026-06-29T13:03:42.074Z" }, + { url = "https://files.pythonhosted.org/packages/15/e0/97e9557686d2f94f4b93786eccb7eed28e9228ad132ea8237f44727314a7/jiter-0.16.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5f91b1c27fc22a57993d5a5cb8a627cb8ed4b10502716fac1ffbfe1d19d84e8", size = 372017, upload-time = "2026-06-29T13:03:43.658Z" }, + { url = "https://files.pythonhosted.org/packages/0f/94/db768b6938e0df35c86beeba3dfbbb025c9ee5c19e1aa271f2396e50864d/jiter-0.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c682bea068a90b764577bdb78a60a4c1d1606daf9cd4c893832a37c7cc9d9026", size = 343320, upload-time = "2026-06-29T13:03:45.226Z" }, + { url = "https://files.pythonhosted.org/packages/c1/d6/5a59d938244a30735fe62d9433fd325f9021ea29d89780ea4596ea93bc89/jiter-0.16.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:8d031aabecc4f1b6276adfb42e3aabb77c89d468bf616600e8d3a11328929053", size = 350520, upload-time = "2026-06-29T13:03:46.671Z" }, + { url = "https://files.pythonhosted.org/packages/67/f8/c4a857f49c9af125f6bbcac7e3eee7f7978ed89682833062e2dbf62576b1/jiter-0.16.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:eab2cd170150e70153de16896a1774e3a1dca80154c56b54d7a812c479a7165e", size = 387550, upload-time = "2026-06-29T13:03:48.361Z" }, + { url = "https://files.pythonhosted.org/packages/8b/d6/5fbc2f7d6b67b754caa61a993a2e626e815dec47ffc2f9e35f01adfebec7/jiter-0.16.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:6edb63a46e65a82c26800a868e49b2cac30dd5a4218b88d74bc2c848c8ad60bb", size = 515424, upload-time = "2026-06-29T13:03:49.881Z" }, + { url = "https://files.pythonhosted.org/packages/ed/54/284f0164b64a5fed915fea6ba7e9ba9b3d8d37c67d59cf2e3bb99d45cdfe/jiter-0.16.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:659039cc50b5addcc35fcc87ae2c1833b7c0a8e5326ef631a75e4478447bcf84", size = 546981, upload-time = "2026-06-29T13:03:51.363Z" }, + { url = "https://files.pythonhosted.org/packages/13/c5/2a467585a576594384e1d2c43e1224deaafc085f24e243529cf98beef8e1/jiter-0.16.0-cp313-cp313-win32.whl", hash = "sha256:c9c53be232c2e206ef9cdbad81a48bfa74c3d3f08bcf8124630a8a748aad993e", size = 202853, upload-time = "2026-06-29T13:03:53.015Z" }, + { url = "https://files.pythonhosted.org/packages/88/6a/de61d04b9eec69c71719968d2f716532a3bc121170c44a39e14979c6be81/jiter-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:baad945ed47f163ad833314f8e3288c396118934f94e7bbb9e243ce4b341a4fd", size = 196160, upload-time = "2026-06-29T13:03:54.447Z" }, + { url = "https://files.pythonhosted.org/packages/19/4b/b390ed59bafb3f31d008d1218578f10327714484b334439947f7e5b11e7f/jiter-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:3c1fd2dbe1b0af19e987f03fe66c5f5bd105a2229c1aff4ab14890b24f41d21a", size = 189862, upload-time = "2026-06-29T13:03:55.754Z" }, + { url = "https://files.pythonhosted.org/packages/a7/89/bc4f1b57d5da938fd344a466396541e586d161320d70bffd929aaafcd8f4/jiter-0.16.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b2c61484666ad42726029af0c00ef4541f0f3b5cdc550221f56c2343208018ee", size = 308239, upload-time = "2026-06-29T13:03:57.205Z" }, + { url = "https://files.pythonhosted.org/packages/65/7a/c415453e5213001bf3b411ff65dec3d303b0e76a4a2cfea9768cd4960994/jiter-0.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:63efadc657488f45db1c676d81e704cac2abf3fdb892def1faea61db053127e2", size = 308928, upload-time = "2026-06-29T13:03:58.643Z" }, + { url = "https://files.pythonhosted.org/packages/11/fc/1f4fb7ebf9a724c7741994f4aae18fba1e2f3133df14521a79194952c34a/jiter-0.16.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf0d73f50e7b6935677854f6e8e31d499ca7064dd24734f703e060f5b237d883", size = 336998, upload-time = "2026-06-29T13:04:00.071Z" }, + { url = "https://files.pythonhosted.org/packages/a0/8d/72cadaac05ccfa7cc3a0a2232862e6c72443ca40cf300ba8b57f9f18b69b/jiter-0.16.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf3ea07d9bc8e7d03a9fbc051295462e6dbc295b894fd72457c3136e3e43d898", size = 362112, upload-time = "2026-06-29T13:04:01.52Z" }, + { url = "https://files.pythonhosted.org/packages/58/4a/c4b0d5f651fda90a24ffce9f8d56cde462a2e09d31ae3de3c68cef34c04e/jiter-0.16.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26798522707abb47d767db536e4148ceac1b14446bf028ee85e579a2e043cfe5", size = 459807, upload-time = "2026-06-29T13:04:03.214Z" }, + { url = "https://files.pythonhosted.org/packages/80/58/ef77879ea9aa56b50824edc5a445e226422c7a8d211f3fd2a56bcb9493cf/jiter-0.16.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bc837c1b9631be10abfe0191537fe8009838204cec7e44827401ace390ddb567", size = 373181, upload-time = "2026-06-29T13:04:04.629Z" }, + { url = "https://files.pythonhosted.org/packages/49/2e/ffbc3f254e4d8a66da3062c624a7df4b7c2b2cf9e1fe43cf394b3e104041/jiter-0.16.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49060fd70737fad59d33ba9dcc0d83247dc9e77187de26053a19c16c9f32bd69", size = 344927, upload-time = "2026-06-29T13:04:06.067Z" }, + { url = "https://files.pythonhosted.org/packages/9a/f6/0be5dc6d64a89f80aa8fec984f94dedb2973e251edcae55841d60786d578/jiter-0.16.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:adbb8edeadd431bc4477879d5d371ece7cb1334486584e0f252656dd7ffada29", size = 352754, upload-time = "2026-06-29T13:04:07.477Z" }, + { url = "https://files.pythonhosted.org/packages/da/6e/7d31243b3b91cd261dd19e9d3557fc3251a80883d3d8049c86174e7ab7af/jiter-0.16.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:31aaee5b80f672c1dc21272bcfb9cbdcfc1ea04ff50f00ed5af500b80c44fa93", size = 390553, upload-time = "2026-06-29T13:04:08.92Z" }, + { url = "https://files.pythonhosted.org/packages/25/33/51ae371fde3c88897520f62b4d5f8b27ad7103e2bb10812ff52195609853/jiter-0.16.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:6722bcef4ffc86c835574b1b2fac6b33b9fb4a889c781e67950e891591f3c55a", size = 516900, upload-time = "2026-06-29T13:04:10.407Z" }, + { url = "https://files.pythonhosted.org/packages/a0/45/6449b3d123ea439ba79507c657288f461d55049e7bcbdc2cf8eb8210f491/jiter-0.16.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:5ab4f50ff971b611d656554ea10b75f80097392c827bc32923c6eeb6386c8b00", size = 548754, upload-time = "2026-06-29T13:04:12.046Z" }, + { url = "https://files.pythonhosted.org/packages/9b/e7/fd2fb11ae3e2649333da3aa170d04d7b3000bbdc3b270f6513382fdf4e04/jiter-0.16.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:710cc51d4ebdcd3c1f70b232c1db1ea1344a075770422bbd4bede5708335acbe", size = 122381, upload-time = "2026-06-29T13:04:13.413Z" }, + { url = "https://files.pythonhosted.org/packages/26/80/f0b147a62c315a164ed2168908286ca302310824c218d3aae52b06c0c9a9/jiter-0.16.0-cp314-cp314-win32.whl", hash = "sha256:57b37fc887a32d44798e4d8ebfa7c9683ff3da1d5bf38f08d1bb3573ccb39106", size = 204578, upload-time = "2026-06-29T13:04:14.813Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e6/4758a14304b4523a6f5adb2419340086aa3593bd4327c2b25b5948a90548/jiter-0.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:cbd18dd5e2df96b580487b5745adf57ef64ad89ba2d9662fc3c19386acce7db8", size = 198154, upload-time = "2026-06-29T13:04:16.272Z" }, + { url = "https://files.pythonhosted.org/packages/26/be/41fa54a2e7ea41d6c99f1dc5b1f0fd4cb474680304b5d268dd518e81da3a/jiter-0.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:a32d2027a9fa67f109ff245a3252ece3ccc32cc56703e1deab6cc846a59e0585", size = 191458, upload-time = "2026-06-29T13:04:17.707Z" }, + { url = "https://files.pythonhosted.org/packages/81/6b/59127338b86d9fe4d99418f5a15118bea778103ee0fe9d9dd7e0af174e95/jiter-0.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2577196f4474ef3fc4779a088a23b0897bbf86f9ea3679c372d45b8383b43207", size = 316739, upload-time = "2026-06-29T13:04:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/2d/95/49461034d5388196d3dabf98748935f017b7785d8f3f5349f834bcc4ed0d/jiter-0.16.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:616e89e008a93c01104161c75b4988e58716b01d62307ebfe161e52a56d2a818", size = 340911, upload-time = "2026-06-29T13:04:21.257Z" }, + { url = "https://files.pythonhosted.org/packages/cd/97/a4369f2fb82cb3dda13b98622f31249b2e014b223fe64ee534413ad72294/jiter-0.16.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e2e9efbe042210df657bade597f66d6d75723e3d8f45a12ea6d8167ff8bbce3", size = 361747, upload-time = "2026-06-29T13:04:22.677Z" }, + { url = "https://files.pythonhosted.org/packages/28/51/49b6ed456261646e1906016a6760367a28aacd3c24805e4e5fe64116c1db/jiter-0.16.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f4d9e473a5ce7d27fef8b848df4dc16e283893d3f53b4a585e72c9595f3c284", size = 460225, upload-time = "2026-06-29T13:04:24.441Z" }, + { url = "https://files.pythonhosted.org/packages/33/b5/5689aff4f66c5b60be63106e591dbfcba2190df97d2c9c7cf052361ddb98/jiter-0.16.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d30a4a1c87713060c8d1cc59a7b6c8fb6b8ef0a6900368014c76c87922a2929", size = 373169, upload-time = "2026-06-29T13:04:25.884Z" }, + { url = "https://files.pythonhosted.org/packages/a2/96/3ae1b85ee0d6d6cab254fb7f8da018272b932bbf2d69b07e98aa2a96c746/jiter-0.16.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bae96332410f866e5900d809298b1ed82735932986c672495f9701daacd80620", size = 350332, upload-time = "2026-06-29T13:04:27.302Z" }, + { url = "https://files.pythonhosted.org/packages/15/32/c99d7bafd78986556c95bf60ce84c6cc98786eac56066c12d7f828bb6747/jiter-0.16.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:da3d7ec75dc83bb18bca888b5edfae0656a26849056c59e05a7728badd17e7af", size = 353377, upload-time = "2026-06-29T13:04:28.731Z" }, + { url = "https://files.pythonhosted.org/packages/0e/4b/f99a8e571287c3dec766bcc18528bbe8e8fb5365522ab5e6d64c93e87066/jiter-0.16.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ee6162b77d49a9939229df666dfa8af3e656b6701b54c4c84966d740e189264e", size = 387746, upload-time = "2026-06-29T13:04:30.319Z" }, + { url = "https://files.pythonhosted.org/packages/75/69/c78a5b3f71040e34eb5917df26fb7ae9a2174cad1ccbf277512507c53a6e/jiter-0.16.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:63ffdbdae7d4499f4cda14eadc12ddcabef0fc0c081191bdc2247489cb698077", size = 517292, upload-time = "2026-06-29T13:04:31.709Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f7/095b38eda4c70d03651c403f29a5590f16d12ddc5d544aac9f9cddf72277/jiter-0.16.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a111256a7193bea0759267b10385e5870949c239ed7b6ddbaaf57573edb38734", size = 549259, upload-time = "2026-06-29T13:04:33.721Z" }, + { url = "https://files.pythonhosted.org/packages/2e/c5/6a0207d90e5f656d95af98ebd0934f382d37674416f215aeda2ff8063e51/jiter-0.16.0-cp314-cp314t-win32.whl", hash = "sha256:de5ba8763e56b793561f43bed197c9ea55776daa5e9a6b91eed68a909bc9cdbf", size = 206523, upload-time = "2026-06-29T13:04:35.068Z" }, + { url = "https://files.pythonhosted.org/packages/a5/31/c757d5f30a8980fd945ce7b98be10be9e4ff59c7c42f5fd86804c2e87db8/jiter-0.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b8a3f9a6008048fe9def7bf465180564a6e458047d2ce499149cfbe73c3ae9db", size = 200366, upload-time = "2026-06-29T13:04:36.61Z" }, + { url = "https://files.pythonhosted.org/packages/7c/a2/d88de6d313d734a544a7901353ad5db67cb38dcfcd91713b7979dafc345d/jiter-0.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0fa25b09b13075c46f5bc174f2690525a925a4fc2f7c82969a2bbabff22386ce", size = 190516, upload-time = "2026-06-29T13:04:38.004Z" }, + { url = "https://files.pythonhosted.org/packages/06/d3/8e278946d43eeca2585b4dd0834a887cd71136329b837f3a16ed86a8b4b0/jiter-0.16.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:850ccb1d7eedb4200f4014b1c0e8a577de114fc3cd88faad646dcc9bc4bb12ad", size = 304518, upload-time = "2026-06-29T13:05:00.172Z" }, + { url = "https://files.pythonhosted.org/packages/72/43/28d4ef495028bf0506a413d4db3f4eb3e7288a382e0f065f306a17bbeb5e/jiter-0.16.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:e34e97bda77eb63242a410243c071e28ac7e0d8c0948c5ee658498690a4b2f2f", size = 310207, upload-time = "2026-06-29T13:05:02.123Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ca/c366b1012da1d640de975d9683acd44e4d150d9068845d0ca2610435253f/jiter-0.16.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7dc85ea77d4abbae8bad0d3538678aedee75bceec4e2f6c8dfb1c74772e5aa5", size = 342771, upload-time = "2026-06-29T13:05:03.55Z" }, + { url = "https://files.pythonhosted.org/packages/16/52/50cc4056fc1ae02e7154704e7ecc89df0afb8300222cfe8a52d3f67e4730/jiter-0.16.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17ca7fae79f6d99cd9a042b75f917eaada7b895cfc7dd2ee3a16089dcaec7a85", size = 346468, upload-time = "2026-06-29T13:05:05.452Z" }, + { url = "https://files.pythonhosted.org/packages/98/ab/664fd8c4be028b2bedd3d2ff08769c4ede23d0dbc87a77c62384a0515b5d/jiter-0.16.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:f17d61a28b4b3e0e3e2ba98490c70501403b4d196f78732439160e7fd3678127", size = 303106, upload-time = "2026-06-29T13:05:07.118Z" }, + { url = "https://files.pythonhosted.org/packages/1a/07/421f1d5b65493a76e16027b848aba6a7d28073ae75944fa4289cc914d39f/jiter-0.16.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:96e38eea538c8ddf853a35727c7be0741c76c13f04148ac5c116222f50ece3b3", size = 304658, upload-time = "2026-06-29T13:05:08.708Z" }, + { url = "https://files.pythonhosted.org/packages/0a/db/bba1155f01a01c3c37a89425d571da751bbedf5c54247b831a04cb971798/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d284fb8d94d5855d60c44fefcab4bf966f1da6fada73992b01f6f0c9bc0c6702", size = 339719, upload-time = "2026-06-29T13:05:10.41Z" }, + { url = "https://files.pythonhosted.org/packages/78/f7/18a1afcd64f35314b68c1f23afcd9994d0bc13e65cc77517afff4e83986d/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64d613743df53199b1aa256a7d328340da6d7078aac7705a7db9d7a791e9cfd2", size = 343885, upload-time = "2026-06-29T13:05:12.087Z" }, +] + [[package]] name = "jmespath" version = "1.0.1" @@ -1193,6 +1457,22 @@ version = "4.4.5" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/57/51/f1b86d93029f418033dddf9b9f79c8d2641e7454080478ee2aab5123173e/lz4-4.4.5.tar.gz", hash = "sha256:5f0b9e53c1e82e88c10d7c180069363980136b9d7a8306c4dca4f760d60c39f0", size = 172886, upload-time = "2025-11-03T13:02:36.061Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/45/2466d73d79e3940cad4b26761f356f19fd33f4409c96f100e01a5c566909/lz4-4.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d221fa421b389ab2345640a508db57da36947a437dfe31aeddb8d5c7b646c22d", size = 207396, upload-time = "2025-11-03T13:01:24.965Z" }, + { url = "https://files.pythonhosted.org/packages/72/12/7da96077a7e8918a5a57a25f1254edaf76aefb457666fcc1066deeecd609/lz4-4.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7dc1e1e2dbd872f8fae529acd5e4839efd0b141eaa8ae7ce835a9fe80fbad89f", size = 207154, upload-time = "2025-11-03T13:01:26.922Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0e/0fb54f84fd1890d4af5bc0a3c1fa69678451c1a6bd40de26ec0561bb4ec5/lz4-4.4.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e928ec2d84dc8d13285b4a9288fd6246c5cde4f5f935b479f50d986911f085e3", size = 1291053, upload-time = "2025-11-03T13:01:28.396Z" }, + { url = "https://files.pythonhosted.org/packages/15/45/8ce01cc2715a19c9e72b0e423262072c17d581a8da56e0bd4550f3d76a79/lz4-4.4.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daffa4807ef54b927451208f5f85750c545a4abbff03d740835fc444cd97f758", size = 1278586, upload-time = "2025-11-03T13:01:29.906Z" }, + { url = "https://files.pythonhosted.org/packages/6d/34/7be9b09015e18510a09b8d76c304d505a7cbc66b775ec0b8f61442316818/lz4-4.4.5-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a2b7504d2dffed3fd19d4085fe1cc30cf221263fd01030819bdd8d2bb101cf1", size = 1367315, upload-time = "2025-11-03T13:01:31.054Z" }, + { url = "https://files.pythonhosted.org/packages/2a/94/52cc3ec0d41e8d68c985ec3b2d33631f281d8b748fb44955bc0384c2627b/lz4-4.4.5-cp310-cp310-win32.whl", hash = "sha256:0846e6e78f374156ccf21c631de80967e03cc3c01c373c665789dc0c5431e7fc", size = 88173, upload-time = "2025-11-03T13:01:32.643Z" }, + { url = "https://files.pythonhosted.org/packages/ca/35/c3c0bdc409f551404355aeeabc8da343577d0e53592368062e371a3620e1/lz4-4.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:7c4e7c44b6a31de77d4dc9772b7d2561937c9588a734681f70ec547cfbc51ecd", size = 99492, upload-time = "2025-11-03T13:01:33.813Z" }, + { url = "https://files.pythonhosted.org/packages/1d/02/4d88de2f1e97f9d05fd3d278fe412b08969bc94ff34942f5a3f09318144a/lz4-4.4.5-cp310-cp310-win_arm64.whl", hash = "sha256:15551280f5656d2206b9b43262799c89b25a25460416ec554075a8dc568e4397", size = 91280, upload-time = "2025-11-03T13:01:35.081Z" }, + { url = "https://files.pythonhosted.org/packages/93/5b/6edcd23319d9e28b1bedf32768c3d1fd56eed8223960a2c47dacd2cec2af/lz4-4.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d6da84a26b3aa5da13a62e4b89ab36a396e9327de8cd48b436a3467077f8ccd4", size = 207391, upload-time = "2025-11-03T13:01:36.644Z" }, + { url = "https://files.pythonhosted.org/packages/34/36/5f9b772e85b3d5769367a79973b8030afad0d6b724444083bad09becd66f/lz4-4.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:61d0ee03e6c616f4a8b69987d03d514e8896c8b1b7cc7598ad029e5c6aedfd43", size = 207146, upload-time = "2025-11-03T13:01:37.928Z" }, + { url = "https://files.pythonhosted.org/packages/04/f4/f66da5647c0d72592081a37c8775feacc3d14d2625bbdaabd6307c274565/lz4-4.4.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:33dd86cea8375d8e5dd001e41f321d0a4b1eb7985f39be1b6a4f466cd480b8a7", size = 1292623, upload-time = "2025-11-03T13:01:39.341Z" }, + { url = "https://files.pythonhosted.org/packages/85/fc/5df0f17467cdda0cad464a9197a447027879197761b55faad7ca29c29a04/lz4-4.4.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:609a69c68e7cfcfa9d894dc06be13f2e00761485b62df4e2472f1b66f7b405fb", size = 1279982, upload-time = "2025-11-03T13:01:40.816Z" }, + { url = "https://files.pythonhosted.org/packages/25/3b/b55cb577aa148ed4e383e9700c36f70b651cd434e1c07568f0a86c9d5fbb/lz4-4.4.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:75419bb1a559af00250b8f1360d508444e80ed4b26d9d40ec5b09fe7875cb989", size = 1368674, upload-time = "2025-11-03T13:01:42.118Z" }, + { url = "https://files.pythonhosted.org/packages/fb/31/e97e8c74c59ea479598e5c55cbe0b1334f03ee74ca97726e872944ed42df/lz4-4.4.5-cp311-cp311-win32.whl", hash = "sha256:12233624f1bc2cebc414f9efb3113a03e89acce3ab6f72035577bc61b270d24d", size = 88168, upload-time = "2025-11-03T13:01:43.282Z" }, + { url = "https://files.pythonhosted.org/packages/18/47/715865a6c7071f417bef9b57c8644f29cb7a55b77742bd5d93a609274e7e/lz4-4.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:8a842ead8ca7c0ee2f396ca5d878c4c40439a527ebad2b996b0444f0074ed004", size = 99491, upload-time = "2025-11-03T13:01:44.167Z" }, + { url = "https://files.pythonhosted.org/packages/14/e7/ac120c2ca8caec5c945e6356ada2aa5cfabd83a01e3170f264a5c42c8231/lz4-4.4.5-cp311-cp311-win_arm64.whl", hash = "sha256:83bc23ef65b6ae44f3287c38cbf82c269e2e96a26e560aa551735883388dcc4b", size = 91271, upload-time = "2025-11-03T13:01:45.016Z" }, { url = "https://files.pythonhosted.org/packages/1b/ac/016e4f6de37d806f7cc8f13add0a46c9a7cfc41a5ddc2bc831d7954cf1ce/lz4-4.4.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:df5aa4cead2044bab83e0ebae56e0944cc7fcc1505c7787e9e1057d6d549897e", size = 207163, upload-time = "2025-11-03T13:01:45.895Z" }, { url = "https://files.pythonhosted.org/packages/8d/df/0fadac6e5bd31b6f34a1a8dbd4db6a7606e70715387c27368586455b7fc9/lz4-4.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6d0bf51e7745484d2092b3a51ae6eb58c3bd3ce0300cf2b2c14f76c536d5697a", size = 207150, upload-time = "2025-11-03T13:01:47.205Z" }, { url = "https://files.pythonhosted.org/packages/b7/17/34e36cc49bb16ca73fb57fbd4c5eaa61760c6b64bce91fcb4e0f4a97f852/lz4-4.4.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7b62f94b523c251cf32aa4ab555f14d39bd1a9df385b72443fd76d7c7fb051f5", size = 1292045, upload-time = "2025-11-03T13:01:48.667Z" }, @@ -1245,6 +1525,28 @@ version = "3.0.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, @@ -1329,6 +1631,38 @@ version = "5.2.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/a7/af/f28c2c2f51f31abb4725f9a64bc7863d5f491f6539bd26aee2a1d21a649e/mmh3-5.2.0.tar.gz", hash = "sha256:1efc8fec8478e9243a78bb993422cf79f8ff85cb4cf6b79647480a31e0d950a8", size = 33582, upload-time = "2025-07-29T07:43:48.49Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/2b/870f0ff5ecf312c58500f45950751f214b7068665e66e9bfd8bc2595587c/mmh3-5.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:81c504ad11c588c8629536b032940f2a359dda3b6cbfd4ad8f74cb24dcd1b0bc", size = 56119, upload-time = "2025-07-29T07:41:39.117Z" }, + { url = "https://files.pythonhosted.org/packages/3b/88/eb9a55b3f3cf43a74d6bfa8db0e2e209f966007777a1dc897c52c008314c/mmh3-5.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0b898cecff57442724a0f52bf42c2de42de63083a91008fb452887e372f9c328", size = 40634, upload-time = "2025-07-29T07:41:40.626Z" }, + { url = "https://files.pythonhosted.org/packages/d1/4c/8e4b3878bf8435c697d7ce99940a3784eb864521768069feaccaff884a17/mmh3-5.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:be1374df449465c9f2500e62eee73a39db62152a8bdfbe12ec5b5c1cd451344d", size = 40080, upload-time = "2025-07-29T07:41:41.791Z" }, + { url = "https://files.pythonhosted.org/packages/45/ac/0a254402c8c5ca424a0a9ebfe870f5665922f932830f0a11a517b6390a09/mmh3-5.2.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b0d753ad566c721faa33db7e2e0eddd74b224cdd3eaf8481d76c926603c7a00e", size = 95321, upload-time = "2025-07-29T07:41:42.659Z" }, + { url = "https://files.pythonhosted.org/packages/39/8e/29306d5eca6dfda4b899d22c95b5420db4e0ffb7e0b6389b17379654ece5/mmh3-5.2.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dfbead5575f6470c17e955b94f92d62a03dfc3d07f2e6f817d9b93dc211a1515", size = 101220, upload-time = "2025-07-29T07:41:43.572Z" }, + { url = "https://files.pythonhosted.org/packages/49/f7/0dd1368e531e52a17b5b8dd2f379cce813bff2d0978a7748a506f1231152/mmh3-5.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7434a27754049144539d2099a6d2da5d88b8bdeedf935180bf42ad59b3607aa3", size = 103991, upload-time = "2025-07-29T07:41:44.914Z" }, + { url = "https://files.pythonhosted.org/packages/35/06/abc7122c40f4abbfcef01d2dac6ec0b77ede9757e5be8b8a40a6265b1274/mmh3-5.2.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cadc16e8ea64b5d9a47363013e2bea469e121e6e7cb416a7593aeb24f2ad122e", size = 110894, upload-time = "2025-07-29T07:41:45.849Z" }, + { url = "https://files.pythonhosted.org/packages/f4/2f/837885759afa4baccb8e40456e1cf76a4f3eac835b878c727ae1286c5f82/mmh3-5.2.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d765058da196f68dc721116cab335e696e87e76720e6ef8ee5a24801af65e63d", size = 118327, upload-time = "2025-07-29T07:41:47.224Z" }, + { url = "https://files.pythonhosted.org/packages/40/cc/5683ba20a21bcfb3f1605b1c474f46d30354f728a7412201f59f453d405a/mmh3-5.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8b0c53fe0994beade1ad7c0f13bd6fec980a0664bfbe5a6a7d64500b9ab76772", size = 101701, upload-time = "2025-07-29T07:41:48.259Z" }, + { url = "https://files.pythonhosted.org/packages/0e/24/99ab3fb940150aec8a26dbdfc39b200b5592f6aeb293ec268df93e054c30/mmh3-5.2.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:49037d417419863b222ae47ee562b2de9c3416add0a45c8d7f4e864be8dc4f89", size = 96712, upload-time = "2025-07-29T07:41:49.467Z" }, + { url = "https://files.pythonhosted.org/packages/61/04/d7c4cb18f1f001ede2e8aed0f9dbbfad03d161c9eea4fffb03f14f4523e5/mmh3-5.2.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6ecb4e750d712abde046858ee6992b65c93f1f71b397fce7975c3860c07365d2", size = 110302, upload-time = "2025-07-29T07:41:50.387Z" }, + { url = "https://files.pythonhosted.org/packages/d8/bf/4dac37580cfda74425a4547500c36fa13ef581c8a756727c37af45e11e9a/mmh3-5.2.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:382a6bb3f8c6532ea084e7acc5be6ae0c6effa529240836d59352398f002e3fc", size = 111929, upload-time = "2025-07-29T07:41:51.348Z" }, + { url = "https://files.pythonhosted.org/packages/eb/b1/49f0a582c7a942fb71ddd1ec52b7d21d2544b37d2b2d994551346a15b4f6/mmh3-5.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7733ec52296fc1ba22e9b90a245c821adbb943e98c91d8a330a2254612726106", size = 100111, upload-time = "2025-07-29T07:41:53.139Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/ccec09f438caeb2506f4c63bb3b99aa08a9e09880f8fc047295154756210/mmh3-5.2.0-cp310-cp310-win32.whl", hash = "sha256:127c95336f2a98c51e7682341ab7cb0be3adb9df0819ab8505a726ed1801876d", size = 40783, upload-time = "2025-07-29T07:41:54.463Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f4/8d39a32c8203c1cdae88fdb04d1ea4aa178c20f159df97f4c5a2eaec702c/mmh3-5.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:419005f84ba1cab47a77465a2a843562dadadd6671b8758bf179d82a15ca63eb", size = 41549, upload-time = "2025-07-29T07:41:55.295Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a1/30efb1cd945e193f62574144dd92a0c9ee6463435e4e8ffce9b9e9f032f0/mmh3-5.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:d22c9dcafed659fadc605538946c041722b6d1104fe619dbf5cc73b3c8a0ded8", size = 39335, upload-time = "2025-07-29T07:41:56.194Z" }, + { url = "https://files.pythonhosted.org/packages/f7/87/399567b3796e134352e11a8b973cd470c06b2ecfad5468fe580833be442b/mmh3-5.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7901c893e704ee3c65f92d39b951f8f34ccf8e8566768c58103fb10e55afb8c1", size = 56107, upload-time = "2025-07-29T07:41:57.07Z" }, + { url = "https://files.pythonhosted.org/packages/c3/09/830af30adf8678955b247d97d3d9543dd2fd95684f3cd41c0cd9d291da9f/mmh3-5.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4a5f5536b1cbfa72318ab3bfc8a8188b949260baed186b75f0abc75b95d8c051", size = 40635, upload-time = "2025-07-29T07:41:57.903Z" }, + { url = "https://files.pythonhosted.org/packages/07/14/eaba79eef55b40d653321765ac5e8f6c9ac38780b8a7c2a2f8df8ee0fb72/mmh3-5.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cedac4f4054b8f7859e5aed41aaa31ad03fce6851901a7fdc2af0275ac533c10", size = 40078, upload-time = "2025-07-29T07:41:58.772Z" }, + { url = "https://files.pythonhosted.org/packages/bb/26/83a0f852e763f81b2265d446b13ed6d49ee49e1fc0c47b9655977e6f3d81/mmh3-5.2.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eb756caf8975882630ce4e9fbbeb9d3401242a72528230422c9ab3a0d278e60c", size = 97262, upload-time = "2025-07-29T07:41:59.678Z" }, + { url = "https://files.pythonhosted.org/packages/00/7d/b7133b10d12239aeaebf6878d7eaf0bf7d3738c44b4aba3c564588f6d802/mmh3-5.2.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:097e13c8b8a66c5753c6968b7640faefe85d8e38992703c1f666eda6ef4c3762", size = 103118, upload-time = "2025-07-29T07:42:01.197Z" }, + { url = "https://files.pythonhosted.org/packages/7b/3e/62f0b5dce2e22fd5b7d092aba285abd7959ea2b17148641e029f2eab1ffa/mmh3-5.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7c0c7845566b9686480e6a7e9044db4afb60038d5fabd19227443f0104eeee4", size = 106072, upload-time = "2025-07-29T07:42:02.601Z" }, + { url = "https://files.pythonhosted.org/packages/66/84/ea88bb816edfe65052c757a1c3408d65c4201ddbd769d4a287b0f1a628b2/mmh3-5.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:61ac226af521a572700f863d6ecddc6ece97220ce7174e311948ff8c8919a363", size = 112925, upload-time = "2025-07-29T07:42:03.632Z" }, + { url = "https://files.pythonhosted.org/packages/2e/13/c9b1c022807db575fe4db806f442d5b5784547e2e82cff36133e58ea31c7/mmh3-5.2.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:582f9dbeefe15c32a5fa528b79b088b599a1dfe290a4436351c6090f90ddebb8", size = 120583, upload-time = "2025-07-29T07:42:04.991Z" }, + { url = "https://files.pythonhosted.org/packages/8a/5f/0e2dfe1a38f6a78788b7eb2b23432cee24623aeabbc907fed07fc17d6935/mmh3-5.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ebfc46b39168ab1cd44670a32ea5489bcbc74a25795c61b6d888c5c2cf654ed", size = 99127, upload-time = "2025-07-29T07:42:05.929Z" }, + { url = "https://files.pythonhosted.org/packages/77/27/aefb7d663b67e6a0c4d61a513c83e39ba2237e8e4557fa7122a742a23de5/mmh3-5.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1556e31e4bd0ac0c17eaf220be17a09c171d7396919c3794274cb3415a9d3646", size = 98544, upload-time = "2025-07-29T07:42:06.87Z" }, + { url = "https://files.pythonhosted.org/packages/ab/97/a21cc9b1a7c6e92205a1b5fa030cdf62277d177570c06a239eca7bd6dd32/mmh3-5.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:81df0dae22cd0da87f1c978602750f33d17fb3d21fb0f326c89dc89834fea79b", size = 106262, upload-time = "2025-07-29T07:42:07.804Z" }, + { url = "https://files.pythonhosted.org/packages/43/18/db19ae82ea63c8922a880e1498a75342311f8aa0c581c4dd07711473b5f7/mmh3-5.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:eba01ec3bd4a49b9ac5ca2bc6a73ff5f3af53374b8556fcc2966dd2af9eb7779", size = 109824, upload-time = "2025-07-29T07:42:08.735Z" }, + { url = "https://files.pythonhosted.org/packages/9f/f5/41dcf0d1969125fc6f61d8618b107c79130b5af50b18a4651210ea52ab40/mmh3-5.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e9a011469b47b752e7d20de296bb34591cdfcbe76c99c2e863ceaa2aa61113d2", size = 97255, upload-time = "2025-07-29T07:42:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/32/b3/cce9eaa0efac1f0e735bb178ef9d1d2887b4927fe0ec16609d5acd492dda/mmh3-5.2.0-cp311-cp311-win32.whl", hash = "sha256:bc44fc2b886243d7c0d8daeb37864e16f232e5b56aaec27cc781d848264cfd28", size = 40779, upload-time = "2025-07-29T07:42:10.546Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e9/3fa0290122e6d5a7041b50ae500b8a9f4932478a51e48f209a3879fe0b9b/mmh3-5.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:8ebf241072cf2777a492d0e09252f8cc2b3edd07dfdb9404b9757bffeb4f2cee", size = 41549, upload-time = "2025-07-29T07:42:11.399Z" }, + { url = "https://files.pythonhosted.org/packages/3a/54/c277475b4102588e6f06b2e9095ee758dfe31a149312cdbf62d39a9f5c30/mmh3-5.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5f317a727bba0e633a12e71228bc6a4acb4f471a98b1c003163b917311ea9a9", size = 39336, upload-time = "2025-07-29T07:42:12.209Z" }, { url = "https://files.pythonhosted.org/packages/bf/6a/d5aa7edb5c08e0bd24286c7d08341a0446f9a2fbbb97d96a8a6dd81935ee/mmh3-5.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:384eda9361a7bf83a85e09447e1feafe081034af9dd428893701b959230d84be", size = 56141, upload-time = "2025-07-29T07:42:13.456Z" }, { url = "https://files.pythonhosted.org/packages/08/49/131d0fae6447bc4a7299ebdb1a6fb9d08c9f8dcf97d75ea93e8152ddf7ab/mmh3-5.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c9da0d568569cc87315cb063486d761e38458b8ad513fedd3dc9263e1b81bcd", size = 40681, upload-time = "2025-07-29T07:42:14.306Z" }, { url = "https://files.pythonhosted.org/packages/8f/6f/9221445a6bcc962b7f5ff3ba18ad55bba624bacdc7aa3fc0a518db7da8ec/mmh3-5.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86d1be5d63232e6eb93c50881aea55ff06eb86d8e08f9b5417c8c9b10db9db96", size = 40062, upload-time = "2025-07-29T07:42:15.08Z" }, @@ -1437,6 +1771,7 @@ dependencies = [ { name = "colorlog" }, { name = "dependency-groups" }, { name = "packaging" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, { name = "virtualenv" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b4/80/47712208c410defec169992e57c179f0f4d92f5dd17ba8daca50a8077e23/nox-2025.5.1.tar.gz", hash = "sha256:2a571dfa7a58acc726521ac3cd8184455ebcdcbf26401c7b737b5bc6701427b2", size = 4023334, upload-time = "2025-05-01T16:35:48.056Z" } @@ -1444,12 +1779,92 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a6/be/7b423b02b09eb856beffe76fe8c4121c99852db74dd12a422dcb72d1134e/nox-2025.5.1-py3-none-any.whl", hash = "sha256:56abd55cf37ff523c254fcec4d152ed51e5fe80e2ab8317221d8b828ac970a31", size = 71753, upload-time = "2025-05-01T16:35:46.037Z" }, ] +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + [[package]] name = "numpy" version = "2.4.1" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13'", + "python_full_version >= '3.11' and python_full_version < '3.13'", +] sdist = { url = "https://files.pythonhosted.org/packages/24/62/ae72ff66c0f1fd959925b4c11f8c2dea61f47f6acaea75a08512cdfe3fed/numpy-2.4.1.tar.gz", hash = "sha256:a1ceafc5042451a858231588a104093474c6a5c57dcc724841f5c888d237d690", size = 20721320, upload-time = "2026-01-10T06:44:59.619Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/34/2b1bc18424f3ad9af577f6ce23600319968a70575bd7db31ce66731bbef9/numpy-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0cce2a669e3c8ba02ee563c7835f92c153cf02edff1ae05e1823f1dde21b16a5", size = 16944563, upload-time = "2026-01-10T06:42:14.615Z" }, + { url = "https://files.pythonhosted.org/packages/2c/57/26e5f97d075aef3794045a6ca9eada6a4ed70eb9a40e7a4a93f9ac80d704/numpy-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:899d2c18024984814ac7e83f8f49d8e8180e2fbe1b2e252f2e7f1d06bea92425", size = 12645658, upload-time = "2026-01-10T06:42:17.298Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ba/80fc0b1e3cb2fd5c6143f00f42eb67762aa043eaa05ca924ecc3222a7849/numpy-2.4.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:09aa8a87e45b55a1c2c205d42e2808849ece5c484b2aab11fecabec3841cafba", size = 5474132, upload-time = "2026-01-10T06:42:19.637Z" }, + { url = "https://files.pythonhosted.org/packages/40/ae/0a5b9a397f0e865ec171187c78d9b57e5588afc439a04ba9cab1ebb2c945/numpy-2.4.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:edee228f76ee2dab4579fad6f51f6a305de09d444280109e0f75df247ff21501", size = 6804159, upload-time = "2026-01-10T06:42:21.44Z" }, + { url = "https://files.pythonhosted.org/packages/86/9c/841c15e691c7085caa6fd162f063eff494099c8327aeccd509d1ab1e36ab/numpy-2.4.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a92f227dbcdc9e4c3e193add1a189a9909947d4f8504c576f4a732fd0b54240a", size = 14708058, upload-time = "2026-01-10T06:42:23.546Z" }, + { url = "https://files.pythonhosted.org/packages/5d/9d/7862db06743f489e6a502a3b93136d73aea27d97b2cf91504f70a27501d6/numpy-2.4.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:538bf4ec353709c765ff75ae616c34d3c3dca1a68312727e8f2676ea644f8509", size = 16651501, upload-time = "2026-01-10T06:42:25.909Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9c/6fc34ebcbd4015c6e5f0c0ce38264010ce8a546cb6beacb457b84a75dfc8/numpy-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ac08c63cb7779b85e9d5318e6c3518b424bc1f364ac4cb2c6136f12e5ff2dccc", size = 16492627, upload-time = "2026-01-10T06:42:28.938Z" }, + { url = "https://files.pythonhosted.org/packages/aa/63/2494a8597502dacda439f61b3c0db4da59928150e62be0e99395c3ad23c5/numpy-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4f9c360ecef085e5841c539a9a12b883dff005fbd7ce46722f5e9cef52634d82", size = 18585052, upload-time = "2026-01-10T06:42:31.312Z" }, + { url = "https://files.pythonhosted.org/packages/6a/93/098e1162ae7522fc9b618d6272b77404c4656c72432ecee3abc029aa3de0/numpy-2.4.1-cp311-cp311-win32.whl", hash = "sha256:0f118ce6b972080ba0758c6087c3617b5ba243d806268623dc34216d69099ba0", size = 6236575, upload-time = "2026-01-10T06:42:33.872Z" }, + { url = "https://files.pythonhosted.org/packages/8c/de/f5e79650d23d9e12f38a7bc6b03ea0835b9575494f8ec94c11c6e773b1b1/numpy-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:18e14c4d09d55eef39a6ab5b08406e84bc6869c1e34eef45564804f90b7e0574", size = 12604479, upload-time = "2026-01-10T06:42:35.778Z" }, + { url = "https://files.pythonhosted.org/packages/dd/65/e1097a7047cff12ce3369bd003811516b20ba1078dbdec135e1cd7c16c56/numpy-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:6461de5113088b399d655d45c3897fa188766415d0f568f175ab071c8873bd73", size = 10578325, upload-time = "2026-01-10T06:42:38.518Z" }, { url = "https://files.pythonhosted.org/packages/78/7f/ec53e32bf10c813604edf07a3682616bd931d026fcde7b6d13195dfb684a/numpy-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d3703409aac693fa82c0aee023a1ae06a6e9d065dba10f5e8e80f642f1e9d0a2", size = 16656888, upload-time = "2026-01-10T06:42:40.913Z" }, { url = "https://files.pythonhosted.org/packages/b8/e0/1f9585d7dae8f14864e948fd7fa86c6cb72dee2676ca2748e63b1c5acfe0/numpy-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7211b95ca365519d3596a1d8688a95874cc94219d417504d9ecb2df99fa7bfa8", size = 12373956, upload-time = "2026-01-10T06:42:43.091Z" }, { url = "https://files.pythonhosted.org/packages/8e/43/9762e88909ff2326f5e7536fa8cb3c49fb03a7d92705f23e6e7f553d9cb3/numpy-2.4.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:5adf01965456a664fc727ed69cc71848f28d063217c63e1a0e200a118d5eec9a", size = 5202567, upload-time = "2026-01-10T06:42:45.107Z" }, @@ -1503,6 +1918,13 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/23/12/8b5fc6b9c487a09a7957188e0943c9ff08432c65e34567cabc1623b03a51/numpy-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:5de60946f14ebe15e713a6f22850c2372fa72f4ff9a432ab44aa90edcadaa65a", size = 6152482, upload-time = "2026-01-10T06:44:36.798Z" }, { url = "https://files.pythonhosted.org/packages/00/a5/9f8ca5856b8940492fc24fbe13c1bc34d65ddf4079097cf9e53164d094e1/numpy-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:8f085da926c0d491ffff3096f91078cc97ea67e7e6b65e490bc8dcda65663be2", size = 12627117, upload-time = "2026-01-10T06:44:38.828Z" }, { url = "https://files.pythonhosted.org/packages/ad/0d/eca3d962f9eef265f01a8e0d20085c6dd1f443cbffc11b6dede81fd82356/numpy-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:6436cffb4f2bf26c974344439439c95e152c9a527013f26b3577be6c2ca64295", size = 10667121, upload-time = "2026-01-10T06:44:41.644Z" }, + { url = "https://files.pythonhosted.org/packages/1e/48/d86f97919e79314a1cdee4c832178763e6e98e623e123d0bada19e92c15a/numpy-2.4.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8ad35f20be147a204e28b6a0575fbf3540c5e5f802634d4258d55b1ff5facce1", size = 16822202, upload-time = "2026-01-10T06:44:43.738Z" }, + { url = "https://files.pythonhosted.org/packages/51/e9/1e62a7f77e0f37dcfb0ad6a9744e65df00242b6ea37dfafb55debcbf5b55/numpy-2.4.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8097529164c0f3e32bb89412a0905d9100bf434d9692d9fc275e18dcf53c9344", size = 12569985, upload-time = "2026-01-10T06:44:45.945Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7e/914d54f0c801342306fdcdce3e994a56476f1b818c46c47fc21ae968088c/numpy-2.4.1-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ea66d2b41ca4a1630aae5507ee0a71647d3124d1741980138aa8f28f44dac36e", size = 5398484, upload-time = "2026-01-10T06:44:48.012Z" }, + { url = "https://files.pythonhosted.org/packages/1c/d8/9570b68584e293a33474e7b5a77ca404f1dcc655e40050a600dee81d27fb/numpy-2.4.1-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:d3f8f0df9f4b8be57b3bf74a1d087fec68f927a2fab68231fdb442bf2c12e426", size = 6713216, upload-time = "2026-01-10T06:44:49.725Z" }, + { url = "https://files.pythonhosted.org/packages/33/9b/9dd6e2db8d49eb24f86acaaa5258e5f4c8ed38209a4ee9de2d1a0ca25045/numpy-2.4.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2023ef86243690c2791fd6353e5b4848eedaa88ca8a2d129f462049f6d484696", size = 14538937, upload-time = "2026-01-10T06:44:51.498Z" }, + { url = "https://files.pythonhosted.org/packages/53/87/d5bd995b0f798a37105b876350d346eea5838bd8f77ea3d7a48392f3812b/numpy-2.4.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8361ea4220d763e54cff2fbe7d8c93526b744f7cd9ddab47afeff7e14e8503be", size = 16479830, upload-time = "2026-01-10T06:44:53.931Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c7/b801bf98514b6ae6475e941ac05c58e6411dd863ea92916bfd6d510b08c1/numpy-2.4.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:4f1b68ff47680c2925f8063402a693ede215f0257f02596b1318ecdfb1d79e33", size = 12492579, upload-time = "2026-01-10T06:44:57.094Z" }, ] [[package]] @@ -1521,12 +1943,23 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "coloredlogs" }, { name = "flatbuffers" }, - { name = "numpy" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "packaging" }, { name = "protobuf" }, { name = "sympy" }, ] wheels = [ + { url = "https://files.pythonhosted.org/packages/35/d6/311b1afea060015b56c742f3531168c1644650767f27ef40062569960587/onnxruntime-1.23.2-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:a7730122afe186a784660f6ec5807138bf9d792fa1df76556b27307ea9ebcbe3", size = 17195934, upload-time = "2025-10-27T23:06:14.143Z" }, + { url = "https://files.pythonhosted.org/packages/db/db/81bf3d7cecfbfed9092b6b4052e857a769d62ed90561b410014e0aae18db/onnxruntime-1.23.2-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:b28740f4ecef1738ea8f807461dd541b8287d5650b5be33bca7b474e3cbd1f36", size = 19153079, upload-time = "2025-10-27T23:05:57.686Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4d/a382452b17cf70a2313153c520ea4c96ab670c996cb3a95cc5d5ac7bfdac/onnxruntime-1.23.2-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f7d1fe034090a1e371b7f3ca9d3ccae2fabae8c1d8844fb7371d1ea38e8e8d2", size = 15219883, upload-time = "2025-10-22T03:46:21.66Z" }, + { url = "https://files.pythonhosted.org/packages/fb/56/179bf90679984c85b417664c26aae4f427cba7514bd2d65c43b181b7b08b/onnxruntime-1.23.2-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4ca88747e708e5c67337b0f65eed4b7d0dd70d22ac332038c9fc4635760018f7", size = 17370357, upload-time = "2025-10-22T03:46:57.968Z" }, + { url = "https://files.pythonhosted.org/packages/cd/6d/738e50c47c2fd285b1e6c8083f15dac1a5f6199213378a5f14092497296d/onnxruntime-1.23.2-cp310-cp310-win_amd64.whl", hash = "sha256:0be6a37a45e6719db5120e9986fcd30ea205ac8103fd1fb74b6c33348327a0cc", size = 13467651, upload-time = "2025-10-27T23:06:11.904Z" }, + { url = "https://files.pythonhosted.org/packages/44/be/467b00f09061572f022ffd17e49e49e5a7a789056bad95b54dfd3bee73ff/onnxruntime-1.23.2-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:6f91d2c9b0965e86827a5ba01531d5b669770b01775b23199565d6c1f136616c", size = 17196113, upload-time = "2025-10-22T03:47:33.526Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a8/3c23a8f75f93122d2b3410bfb74d06d0f8da4ac663185f91866b03f7da1b/onnxruntime-1.23.2-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:87d8b6eaf0fbeb6835a60a4265fde7a3b60157cf1b2764773ac47237b4d48612", size = 19153857, upload-time = "2025-10-22T03:46:37.578Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d8/506eed9af03d86f8db4880a4c47cd0dffee973ef7e4f4cff9f1d4bcf7d22/onnxruntime-1.23.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bbfd2fca76c855317568c1b36a885ddea2272c13cb0e395002c402f2360429a6", size = 15220095, upload-time = "2025-10-22T03:46:24.769Z" }, + { url = "https://files.pythonhosted.org/packages/e9/80/113381ba832d5e777accedc6cb41d10f9eca82321ae31ebb6bcede530cea/onnxruntime-1.23.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da44b99206e77734c5819aa2142c69e64f3b46edc3bd314f6a45a932defc0b3e", size = 17372080, upload-time = "2025-10-22T03:47:00.265Z" }, + { url = "https://files.pythonhosted.org/packages/3a/db/1b4a62e23183a0c3fe441782462c0ede9a2a65c6bbffb9582fab7c7a0d38/onnxruntime-1.23.2-cp311-cp311-win_amd64.whl", hash = "sha256:902c756d8b633ce0dedd889b7c08459433fbcf35e9c38d1c03ddc020f0648c6e", size = 13468349, upload-time = "2025-10-22T03:47:25.783Z" }, { url = "https://files.pythonhosted.org/packages/1b/9e/f748cd64161213adeef83d0cb16cb8ace1e62fa501033acdd9f9341fff57/onnxruntime-1.23.2-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:b8f029a6b98d3cf5be564d52802bb50a8489ab73409fa9db0bf583eabb7c2321", size = 17195929, upload-time = "2025-10-22T03:47:36.24Z" }, { url = "https://files.pythonhosted.org/packages/91/9d/a81aafd899b900101988ead7fb14974c8a58695338ab6a0f3d6b0100f30b/onnxruntime-1.23.2-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:218295a8acae83905f6f1aed8cacb8e3eb3bd7513a13fe4ba3b2664a19fc4a6b", size = 19157705, upload-time = "2025-10-22T03:46:40.415Z" }, { url = "https://files.pythonhosted.org/packages/3c/35/4e40f2fba272a6698d62be2cd21ddc3675edfc1a4b9ddefcc4648f115315/onnxruntime-1.23.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76ff670550dc23e58ea9bc53b5149b99a44e63b34b524f7b8547469aaa0dcb8c", size = 15226915, upload-time = "2025-10-22T03:46:27.773Z" }, @@ -1541,6 +1974,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b6/ca/862b1e7a639460f0ca25fd5b6135fb42cf9deea86d398a92e44dfda2279d/onnxruntime-1.23.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2b9233c4947907fd1818d0e581c049c41ccc39b2856cc942ff6d26317cee145", size = 17394184, upload-time = "2025-10-22T03:47:08.127Z" }, ] +[[package]] +name = "openai" +version = "2.47.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bf/61/9aeef14de759306e85175126d3d6d56ee4f5072a9512c6c171d58d02a62d/openai-2.47.0.tar.gz", hash = "sha256:4e205548acd4304f235b86202269912e55bc88270b15d2a051fa2b53b90343a6", size = 1089906, upload-time = "2026-07-22T17:47:29.723Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/69/26b032059273ad798d18fbcdbe369e871181841fd8bcb5caee32b7510039/openai-2.47.0-py3-none-any.whl", hash = "sha256:b3a1a7ad974092427ccb46d89f8852bdb67866680bcabeecc3ff5a3fdd71b15b", size = 1639987, upload-time = "2026-07-22T17:47:27.873Z" }, +] + [[package]] name = "opentelemetry-api" version = "1.39.1" @@ -1629,6 +2081,34 @@ version = "3.11.5" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/04/b8/333fdb27840f3bf04022d21b654a35f58e15407183aeb16f3b41aa053446/orjson-3.11.5.tar.gz", hash = "sha256:82393ab47b4fe44ffd0a7659fa9cfaacc717eb617c93cde83795f14af5c2e9d5", size = 5972347, upload-time = "2025-12-06T15:55:39.458Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/79/19/b22cf9dad4db20c8737041046054cbd4f38bb5a2d0e4bb60487832ce3d76/orjson-3.11.5-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:df9eadb2a6386d5ea2bfd81309c505e125cfc9ba2b1b99a97e60985b0b3665d1", size = 245719, upload-time = "2025-12-06T15:53:43.877Z" }, + { url = "https://files.pythonhosted.org/packages/03/2e/b136dd6bf30ef5143fbe76a4c142828b55ccc618be490201e9073ad954a1/orjson-3.11.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccc70da619744467d8f1f49a8cadae5ec7bbe054e5232d95f92ed8737f8c5870", size = 132467, upload-time = "2025-12-06T15:53:45.379Z" }, + { url = "https://files.pythonhosted.org/packages/ae/fc/ae99bfc1e1887d20a0268f0e2686eb5b13d0ea7bbe01de2b566febcd2130/orjson-3.11.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:073aab025294c2f6fc0807201c76fdaed86f8fc4be52c440fb78fbb759a1ac09", size = 130702, upload-time = "2025-12-06T15:53:46.659Z" }, + { url = "https://files.pythonhosted.org/packages/6e/43/ef7912144097765997170aca59249725c3ab8ef6079f93f9d708dd058df5/orjson-3.11.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:835f26fa24ba0bb8c53ae2a9328d1706135b74ec653ed933869b74b6909e63fd", size = 135907, upload-time = "2025-12-06T15:53:48.487Z" }, + { url = "https://files.pythonhosted.org/packages/3f/da/24d50e2d7f4092ddd4d784e37a3fa41f22ce8ed97abc9edd222901a96e74/orjson-3.11.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667c132f1f3651c14522a119e4dd631fad98761fa960c55e8e7430bb2a1ba4ac", size = 139935, upload-time = "2025-12-06T15:53:49.88Z" }, + { url = "https://files.pythonhosted.org/packages/02/4a/b4cb6fcbfff5b95a3a019a8648255a0fac9b221fbf6b6e72be8df2361feb/orjson-3.11.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42e8961196af655bb5e63ce6c60d25e8798cd4dfbc04f4203457fa3869322c2e", size = 137541, upload-time = "2025-12-06T15:53:51.226Z" }, + { url = "https://files.pythonhosted.org/packages/a5/99/a11bd129f18c2377c27b2846a9d9be04acec981f770d711ba0aaea563984/orjson-3.11.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75412ca06e20904c19170f8a24486c4e6c7887dea591ba18a1ab572f1300ee9f", size = 139031, upload-time = "2025-12-06T15:53:52.309Z" }, + { url = "https://files.pythonhosted.org/packages/64/29/d7b77d7911574733a036bb3e8ad7053ceb2b7d6ea42208b9dbc55b23b9ed/orjson-3.11.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6af8680328c69e15324b5af3ae38abbfcf9cbec37b5346ebfd52339c3d7e8a18", size = 141622, upload-time = "2025-12-06T15:53:53.606Z" }, + { url = "https://files.pythonhosted.org/packages/93/41/332db96c1de76b2feda4f453e91c27202cd092835936ce2b70828212f726/orjson-3.11.5-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:a86fe4ff4ea523eac8f4b57fdac319faf037d3c1be12405e6a7e86b3fbc4756a", size = 413800, upload-time = "2025-12-06T15:53:54.866Z" }, + { url = "https://files.pythonhosted.org/packages/76/e1/5a0d148dd1f89ad2f9651df67835b209ab7fcb1118658cf353425d7563e9/orjson-3.11.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e607b49b1a106ee2086633167033afbd63f76f2999e9236f638b06b112b24ea7", size = 151198, upload-time = "2025-12-06T15:53:56.383Z" }, + { url = "https://files.pythonhosted.org/packages/0d/96/8db67430d317a01ae5cf7971914f6775affdcfe99f5bff9ef3da32492ecc/orjson-3.11.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7339f41c244d0eea251637727f016b3d20050636695bc78345cce9029b189401", size = 141984, upload-time = "2025-12-06T15:53:57.746Z" }, + { url = "https://files.pythonhosted.org/packages/71/49/40d21e1aa1ac569e521069228bb29c9b5a350344ccf922a0227d93c2ed44/orjson-3.11.5-cp310-cp310-win32.whl", hash = "sha256:8be318da8413cdbbce77b8c5fac8d13f6eb0f0db41b30bb598631412619572e8", size = 135272, upload-time = "2025-12-06T15:53:59.769Z" }, + { url = "https://files.pythonhosted.org/packages/c4/7e/d0e31e78be0c100e08be64f48d2850b23bcb4d4c70d114f4e43b39f6895a/orjson-3.11.5-cp310-cp310-win_amd64.whl", hash = "sha256:b9f86d69ae822cabc2a0f6c099b43e8733dda788405cba2665595b7e8dd8d167", size = 133360, upload-time = "2025-12-06T15:54:01.25Z" }, + { url = "https://files.pythonhosted.org/packages/fd/68/6b3659daec3a81aed5ab47700adb1a577c76a5452d35b91c88efee89987f/orjson-3.11.5-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9c8494625ad60a923af6b2b0bd74107146efe9b55099e20d7740d995f338fcd8", size = 245318, upload-time = "2025-12-06T15:54:02.355Z" }, + { url = "https://files.pythonhosted.org/packages/e9/00/92db122261425f61803ccf0830699ea5567439d966cbc35856fe711bfe6b/orjson-3.11.5-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:7bb2ce0b82bc9fd1168a513ddae7a857994b780b2945a8c51db4ab1c4b751ebc", size = 129491, upload-time = "2025-12-06T15:54:03.877Z" }, + { url = "https://files.pythonhosted.org/packages/94/4f/ffdcb18356518809d944e1e1f77589845c278a1ebbb5a8297dfefcc4b4cb/orjson-3.11.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67394d3becd50b954c4ecd24ac90b5051ee7c903d167459f93e77fc6f5b4c968", size = 132167, upload-time = "2025-12-06T15:54:04.944Z" }, + { url = "https://files.pythonhosted.org/packages/97/c6/0a8caff96f4503f4f7dd44e40e90f4d14acf80d3b7a97cb88747bb712d3e/orjson-3.11.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:298d2451f375e5f17b897794bcc3e7b821c0f32b4788b9bcae47ada24d7f3cf7", size = 130516, upload-time = "2025-12-06T15:54:06.274Z" }, + { url = "https://files.pythonhosted.org/packages/4d/63/43d4dc9bd9954bff7052f700fdb501067f6fb134a003ddcea2a0bb3854ed/orjson-3.11.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa5e4244063db8e1d87e0f54c3f7522f14b2dc937e65d5241ef0076a096409fd", size = 135695, upload-time = "2025-12-06T15:54:07.702Z" }, + { url = "https://files.pythonhosted.org/packages/87/6f/27e2e76d110919cb7fcb72b26166ee676480a701bcf8fc53ac5d0edce32f/orjson-3.11.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1db2088b490761976c1b2e956d5d4e6409f3732e9d79cfa69f876c5248d1baf9", size = 139664, upload-time = "2025-12-06T15:54:08.828Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f8/5966153a5f1be49b5fbb8ca619a529fde7bc71aa0a376f2bb83fed248bcd/orjson-3.11.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c2ed66358f32c24e10ceea518e16eb3549e34f33a9d51f99ce23b0251776a1ef", size = 137289, upload-time = "2025-12-06T15:54:09.898Z" }, + { url = "https://files.pythonhosted.org/packages/a7/34/8acb12ff0299385c8bbcbb19fbe40030f23f15a6de57a9c587ebf71483fb/orjson-3.11.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2021afda46c1ed64d74b555065dbd4c2558d510d8cec5ea6a53001b3e5e82a9", size = 138784, upload-time = "2025-12-06T15:54:11.022Z" }, + { url = "https://files.pythonhosted.org/packages/ee/27/910421ea6e34a527f73d8f4ee7bdffa48357ff79c7b8d6eb6f7b82dd1176/orjson-3.11.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b42ffbed9128e547a1647a3e50bc88ab28ae9daa61713962e0d3dd35e820c125", size = 141322, upload-time = "2025-12-06T15:54:12.427Z" }, + { url = "https://files.pythonhosted.org/packages/87/a3/4b703edd1a05555d4bb1753d6ce44e1a05b7a6d7c164d5b332c795c63d70/orjson-3.11.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8d5f16195bb671a5dd3d1dbea758918bada8f6cc27de72bd64adfbd748770814", size = 413612, upload-time = "2025-12-06T15:54:13.858Z" }, + { url = "https://files.pythonhosted.org/packages/1b/36/034177f11d7eeea16d3d2c42a1883b0373978e08bc9dad387f5074c786d8/orjson-3.11.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c0e5d9f7a0227df2927d343a6e3859bebf9208b427c79bd31949abcc2fa32fa5", size = 150993, upload-time = "2025-12-06T15:54:15.189Z" }, + { url = "https://files.pythonhosted.org/packages/44/2f/ea8b24ee046a50a7d141c0227c4496b1180b215e728e3b640684f0ea448d/orjson-3.11.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:23d04c4543e78f724c4dfe656b3791b5f98e4c9253e13b2636f1af5d90e4a880", size = 141774, upload-time = "2025-12-06T15:54:16.451Z" }, + { url = "https://files.pythonhosted.org/packages/8a/12/cc440554bf8200eb23348a5744a575a342497b65261cd65ef3b28332510a/orjson-3.11.5-cp311-cp311-win32.whl", hash = "sha256:c404603df4865f8e0afe981aa3c4b62b406e6d06049564d58934860b62b7f91d", size = 135109, upload-time = "2025-12-06T15:54:17.73Z" }, + { url = "https://files.pythonhosted.org/packages/a3/83/e0c5aa06ba73a6760134b169f11fb970caa1525fa4461f94d76e692299d9/orjson-3.11.5-cp311-cp311-win_amd64.whl", hash = "sha256:9645ef655735a74da4990c24ffbd6894828fbfa117bc97c1edd98c282ecb52e1", size = 133193, upload-time = "2025-12-06T15:54:19.426Z" }, + { url = "https://files.pythonhosted.org/packages/cb/35/5b77eaebc60d735e832c5b1a20b155667645d123f09d471db0a78280fb49/orjson-3.11.5-cp311-cp311-win_arm64.whl", hash = "sha256:1cbf2735722623fcdee8e712cbaaab9e372bbcb0c7924ad711b261c2eccf4a5c", size = 126830, upload-time = "2025-12-06T15:54:20.836Z" }, { url = "https://files.pythonhosted.org/packages/ef/a4/8052a029029b096a78955eadd68ab594ce2197e24ec50e6b6d2ab3f4e33b/orjson-3.11.5-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:334e5b4bff9ad101237c2d799d9fd45737752929753bf4faf4b207335a416b7d", size = 245347, upload-time = "2025-12-06T15:54:22.061Z" }, { url = "https://files.pythonhosted.org/packages/64/67/574a7732bd9d9d79ac620c8790b4cfe0717a3d5a6eb2b539e6e8995e24a0/orjson-3.11.5-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:ff770589960a86eae279f5d8aa536196ebda8273a2a07db2a54e82b93bc86626", size = 129435, upload-time = "2025-12-06T15:54:23.615Z" }, { url = "https://files.pythonhosted.org/packages/52/8d/544e77d7a29d90cf4d9eecd0ae801c688e7f3d1adfa2ebae5e1e94d38ab9/orjson-3.11.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed24250e55efbcb0b35bed7caaec8cedf858ab2f9f2201f17b8938c618c8ca6f", size = 132074, upload-time = "2025-12-06T15:54:24.694Z" }, @@ -1871,6 +2351,44 @@ version = "1.4.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", hash = "sha256:c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053", size = 137272, upload-time = "2025-12-06T13:27:04.013Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/39/47/16d7af6fae7803f4c691856bc0d8d433ccf30e106432e2ef7707ee19a38a/pybase64-1.4.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f63aa7f29139b8a05ce5f97cdb7fad63d29071e5bdc8a638a343311fe996112a", size = 38241, upload-time = "2025-12-06T13:22:27.396Z" }, + { url = "https://files.pythonhosted.org/packages/4d/3e/268beb8d2240ab55396af4d1b45d2494935982212549b92a5f5b57079bd3/pybase64-1.4.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f5943ec1ae87a8b4fe310905bb57205ea4330c75e2c628433a7d9dd52295b588", size = 31672, upload-time = "2025-12-06T13:22:28.854Z" }, + { url = "https://files.pythonhosted.org/packages/80/14/4365fa33222edcc46b6db4973f9e22bda82adfb6ab2a01afff591f1e41c8/pybase64-1.4.3-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:5f2b8aef86f35cd5894c13681faf433a1fffc5b2e76544dcb5416a514a1a8347", size = 65978, upload-time = "2025-12-06T13:22:30.191Z" }, + { url = "https://files.pythonhosted.org/packages/1c/22/e89739d8bc9b96c68ead44b4eec42fe555683d9997e4ba65216d384920fc/pybase64-1.4.3-cp310-cp310-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6ec7e53dd09b0a8116ccf5c3265c7c7fce13c980747525be76902aef36a514a", size = 68903, upload-time = "2025-12-06T13:22:31.29Z" }, + { url = "https://files.pythonhosted.org/packages/77/e1/7e59a19f8999cdefe9eb0d56bfd701dd38263b0f6fb4a4d29fce165a1b36/pybase64-1.4.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7528604cd69c538e1dbaafded46e9e4915a2adcd6f2a60fcef6390d87ca922ea", size = 57516, upload-time = "2025-12-06T13:22:32.395Z" }, + { url = "https://files.pythonhosted.org/packages/42/ad/f47dc7e6fe32022b176868b88b671a32dab389718c8ca905cab79280aaaf/pybase64-1.4.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:4ec645f32b50593879031e09158f8681a1db9f5df0f72af86b3969a1c5d1fa2b", size = 54533, upload-time = "2025-12-06T13:22:33.457Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9a/7ab312b5a324833953b00e47b23eb4f83d45bd5c5c854b4b4e51b2a0cf5b/pybase64-1.4.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:634a000c5b3485ccc18bb9b244e0124f74b6fbc7f43eade815170237a7b34c64", size = 57187, upload-time = "2025-12-06T13:22:34.566Z" }, + { url = "https://files.pythonhosted.org/packages/2c/84/80acab1fcbaaae103e6b862ef5019192c8f2cd8758433595a202179a0d1d/pybase64-1.4.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:309ea32ad07639a485580af1be0ad447a434deb1924e76adced63ac2319cfe15", size = 57730, upload-time = "2025-12-06T13:22:35.581Z" }, + { url = "https://files.pythonhosted.org/packages/1f/24/84256d472400ea3163d7d69c44bb7e2e1027f0f1d4d20c47629a7dc4578e/pybase64-1.4.3-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:d10d517566b748d3f25f6ac7162af779360c1c6426ad5f962927ee205990d27c", size = 53036, upload-time = "2025-12-06T13:22:36.621Z" }, + { url = "https://files.pythonhosted.org/packages/a3/0f/33aecbed312ee0431798a73fa25e00dedbffdd91389ee23121fed397c550/pybase64-1.4.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a74cc0f4d835400857cc5c6d27ec854f7949491e07a04e6d66e2137812831f4c", size = 56321, upload-time = "2025-12-06T13:22:37.7Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1c/a341b050746658cbec8cab3c733aeb3ef52ce8f11e60d0d47adbdf729ebf/pybase64-1.4.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1b591d774ac09d5eb73c156a03277cb271438fbd8042bae4109ff3a827cd218c", size = 50114, upload-time = "2025-12-06T13:22:38.752Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d3/f7e6680ae6dc4ddff39112ad66e0fa6b2ec346e73881bafc08498c560bc0/pybase64-1.4.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5eb588d35a04302ef6157d17db62354a787ac6f8b1585dd0b90c33d63a97a550", size = 66570, upload-time = "2025-12-06T13:22:40.221Z" }, + { url = "https://files.pythonhosted.org/packages/4c/71/774748eecc7fe23869b7e5df028e3c4c2efa16b506b83ea3fa035ea95dc2/pybase64-1.4.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:df8b122d5be2c96962231cc4831d9c2e1eae6736fb12850cec4356d8b06fe6f8", size = 55700, upload-time = "2025-12-06T13:22:41.289Z" }, + { url = "https://files.pythonhosted.org/packages/b3/91/dd15075bb2fe0086193e1cd4bad80a43652c38d8a572f9218d46ba721802/pybase64-1.4.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:31b7a85c661fc591bbcce82fb8adaebe2941e6a83b08444b0957b77380452a4b", size = 52491, upload-time = "2025-12-06T13:22:42.628Z" }, + { url = "https://files.pythonhosted.org/packages/7b/27/f357d63ea3774c937fc47160e040419ed528827aa3d4306d5ec9826259c0/pybase64-1.4.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e6d7beaae65979fef250e25e66cf81c68a8f81910bcda1a2f43297ab486a7e4e", size = 53957, upload-time = "2025-12-06T13:22:44.615Z" }, + { url = "https://files.pythonhosted.org/packages/b3/c3/243693771701a54e67ff5ccbf4c038344f429613f5643169a7befc51f007/pybase64-1.4.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4a6276bc3a3962d172a2b5aba544d89881c4037ea954517b86b00892c703d007", size = 68422, upload-time = "2025-12-06T13:22:45.641Z" }, + { url = "https://files.pythonhosted.org/packages/75/95/f987081bf6bc1d1eda3012dae1b06ad427732ef9933a632cb8b58f9917f8/pybase64-1.4.3-cp310-cp310-win32.whl", hash = "sha256:4bdd07ef017515204ee6eaab17e1ad05f83c0ccb5af8ae24a0fe6d9cb5bb0b7a", size = 33622, upload-time = "2025-12-06T13:22:47.348Z" }, + { url = "https://files.pythonhosted.org/packages/79/28/c169a769fe90128f16d394aad87b2096dd4bf2f035ae0927108a46b617df/pybase64-1.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:5db0b6bbda15110db2740c61970a8fda3bf9c93c3166a3f57f87c7865ed1125c", size = 35799, upload-time = "2025-12-06T13:22:48.731Z" }, + { url = "https://files.pythonhosted.org/packages/ab/f2/bdbe6af0bd4f3fe5bc70e77ead7f7d523bb9d3ca3ad50ac42b9adbb9ca14/pybase64-1.4.3-cp310-cp310-win_arm64.whl", hash = "sha256:f96367dfc82598569aa02b1103ebd419298293e59e1151abda2b41728703284b", size = 31158, upload-time = "2025-12-06T13:22:50.021Z" }, + { url = "https://files.pythonhosted.org/packages/2b/63/21e981e9d3f1f123e0b0ee2130112b1956cad9752309f574862c7ae77c08/pybase64-1.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:70b0d4a4d54e216ce42c2655315378b8903933ecfa32fced453989a92b4317b2", size = 38237, upload-time = "2025-12-06T13:22:52.159Z" }, + { url = "https://files.pythonhosted.org/packages/92/fb/3f448e139516404d2a3963915cc10dc9dde7d3a67de4edba2f827adfef17/pybase64-1.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8127f110cdee7a70e576c5c9c1d4e17e92e76c191869085efbc50419f4ae3c72", size = 31673, upload-time = "2025-12-06T13:22:53.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/bb06a5b9885e7d853ac1e801c4d8abfdb4c8506deee33e53d55aa6690e67/pybase64-1.4.3-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:f9ef0388878bc15a084bd9bf73ec1b2b4ee513d11009b1506375e10a7aae5032", size = 68331, upload-time = "2025-12-06T13:22:54.197Z" }, + { url = "https://files.pythonhosted.org/packages/64/15/8d60b9ec5e658185fc2ee3333e01a6e30d717cf677b24f47cbb3a859d13c/pybase64-1.4.3-cp311-cp311-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95a57cccf106352a72ed8bc8198f6820b16cc7d55aa3867a16dea7011ae7c218", size = 71370, upload-time = "2025-12-06T13:22:55.517Z" }, + { url = "https://files.pythonhosted.org/packages/ac/29/a3e5c1667cc8c38d025a4636855de0fc117fc62e2afeb033a3c6f12c6a22/pybase64-1.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cd1c47dfceb9c7bd3de210fb4e65904053ed2d7c9dce6d107f041ff6fbd7e21", size = 59834, upload-time = "2025-12-06T13:22:56.682Z" }, + { url = "https://files.pythonhosted.org/packages/a9/00/8ffcf9810bd23f3984698be161cf7edba656fd639b818039a7be1d6405d4/pybase64-1.4.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:9fe9922698f3e2f72874b26890d53a051c431d942701bb3a37aae94da0b12107", size = 56652, upload-time = "2025-12-06T13:22:57.724Z" }, + { url = "https://files.pythonhosted.org/packages/81/62/379e347797cdea4ab686375945bc77ad8d039c688c0d4d0cfb09d247beb9/pybase64-1.4.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:af5f4bd29c86b59bb4375e0491d16ec8a67548fa99c54763aaedaf0b4b5a6632", size = 59382, upload-time = "2025-12-06T13:22:58.758Z" }, + { url = "https://files.pythonhosted.org/packages/c6/f2/9338ffe2f487086f26a2c8ca175acb3baa86fce0a756ff5670a0822bb877/pybase64-1.4.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c302f6ca7465262908131411226e02100f488f531bb5e64cb901aa3f439bccd9", size = 59990, upload-time = "2025-12-06T13:23:01.007Z" }, + { url = "https://files.pythonhosted.org/packages/f9/a4/85a6142b65b4df8625b337727aa81dc199642de3d09677804141df6ee312/pybase64-1.4.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:2f3f439fa4d7fde164ebbbb41968db7d66b064450ab6017c6c95cef0afa2b349", size = 54923, upload-time = "2025-12-06T13:23:02.369Z" }, + { url = "https://files.pythonhosted.org/packages/ac/00/e40215d25624012bf5b7416ca37f168cb75f6dd15acdb91ea1f2ea4dc4e7/pybase64-1.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7a23c6866551043f8b681a5e1e0d59469148b2920a3b4fc42b1275f25ea4217a", size = 58664, upload-time = "2025-12-06T13:23:03.378Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/d7e19a63e795c13837f2356268d95dc79d1180e756f57ced742a1e52fdeb/pybase64-1.4.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:56e6526f8565642abc5f84338cc131ce298a8ccab696b19bdf76fa6d7dc592ef", size = 52338, upload-time = "2025-12-06T13:23:04.458Z" }, + { url = "https://files.pythonhosted.org/packages/f2/32/3c746d7a310b69bdd9df77ffc85c41b80bce00a774717596f869b0d4a20e/pybase64-1.4.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6a792a8b9d866ffa413c9687d9b611553203753987a3a582d68cbc51cf23da45", size = 68993, upload-time = "2025-12-06T13:23:05.526Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b3/63cec68f9d6f6e4c0b438d14e5f1ef536a5fe63ce14b70733ac5e31d7ab8/pybase64-1.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:62ad29a5026bb22cfcd1ca484ec34b0a5ced56ddba38ceecd9359b2818c9c4f9", size = 58055, upload-time = "2025-12-06T13:23:06.931Z" }, + { url = "https://files.pythonhosted.org/packages/d5/cb/7acf7c3c06f9692093c07f109668725dc37fb9a3df0fa912b50add645195/pybase64-1.4.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:11b9d1d2d32ec358c02214363b8fc3651f6be7dd84d880ecd597a6206a80e121", size = 54430, upload-time = "2025-12-06T13:23:07.936Z" }, + { url = "https://files.pythonhosted.org/packages/33/39/4eb33ff35d173bfff4002e184ce8907f5d0a42d958d61cd9058ef3570179/pybase64-1.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0aebaa7f238caa0a0d373616016e2040c6c879ebce3ba7ab3c59029920f13640", size = 56272, upload-time = "2025-12-06T13:23:09.253Z" }, + { url = "https://files.pythonhosted.org/packages/19/97/a76d65c375a254e65b730c6f56bf528feca91305da32eceab8bcc08591e6/pybase64-1.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e504682b20c63c2b0c000e5f98a80ea867f8d97642e042a5a39818e44ba4d599", size = 70904, upload-time = "2025-12-06T13:23:10.336Z" }, + { url = "https://files.pythonhosted.org/packages/5e/2c/8338b6d3da3c265002839e92af0a80d6db88385c313c73f103dfb800c857/pybase64-1.4.3-cp311-cp311-win32.whl", hash = "sha256:e9a8b81984e3c6fb1db9e1614341b0a2d98c0033d693d90c726677db1ffa3a4c", size = 33639, upload-time = "2025-12-06T13:23:11.9Z" }, + { url = "https://files.pythonhosted.org/packages/39/dc/32efdf2f5927e5449cc341c266a1bbc5fecd5319a8807d9c5405f76e6d02/pybase64-1.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:a90a8fa16a901fabf20de824d7acce07586e6127dc2333f1de05f73b1f848319", size = 35797, upload-time = "2025-12-06T13:23:13.174Z" }, + { url = "https://files.pythonhosted.org/packages/da/59/eda4f9cb0cbce5a45f0cd06131e710674f8123a4d570772c5b9694f88559/pybase64-1.4.3-cp311-cp311-win_arm64.whl", hash = "sha256:61d87de5bc94d143622e94390ec3e11b9c1d4644fe9be3a81068ab0f91056f59", size = 31160, upload-time = "2025-12-06T13:23:15.696Z" }, { url = "https://files.pythonhosted.org/packages/86/a7/efcaa564f091a2af7f18a83c1c4875b1437db56ba39540451dc85d56f653/pybase64-1.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:18d85e5ab8b986bb32d8446aca6258ed80d1bafe3603c437690b352c648f5967", size = 38167, upload-time = "2025-12-06T13:23:16.821Z" }, { url = "https://files.pythonhosted.org/packages/db/c7/c7ad35adff2d272bf2930132db2b3eea8c44bb1b1f64eb9b2b8e57cde7b4/pybase64-1.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3f5791a3491d116d0deaf4d83268f48792998519698f8751efb191eac84320e9", size = 31673, upload-time = "2025-12-06T13:23:17.835Z" }, { url = "https://files.pythonhosted.org/packages/43/1b/9a8cab0042b464e9a876d5c65fe5127445a2436da36fda64899b119b1a1b/pybase64-1.4.3-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:f0b3f200c3e06316f6bebabd458b4e4bcd4c2ca26af7c0c766614d91968dee27", size = 68210, upload-time = "2025-12-06T13:23:18.813Z" }, @@ -1976,11 +2494,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/28/86/a236ecfc5b494e1e922da149689f690abc84248c7c1358f5605b8c9fdd60/pybase64-1.4.3-cp314-cp314t-win32.whl", hash = "sha256:343b1901103cc72362fd1f842524e3bb24978e31aea7ff11e033af7f373f66ab", size = 34513, upload-time = "2025-12-06T13:25:24.592Z" }, { url = "https://files.pythonhosted.org/packages/56/ce/ca8675f8d1352e245eb012bfc75429ee9cf1f21c3256b98d9a329d44bf0f/pybase64-1.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:57aff6f7f9dea6705afac9d706432049642de5b01080d3718acc23af87c5af76", size = 36702, upload-time = "2025-12-06T13:25:25.72Z" }, { url = "https://files.pythonhosted.org/packages/3b/30/4a675864877397179b09b720ee5fcb1cf772cf7bebc831989aff0a5f79c1/pybase64-1.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e906aa08d4331e799400829e0f5e4177e76a3281e8a4bc82ba114c6b30e405c9", size = 31904, upload-time = "2025-12-06T13:25:26.826Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7c/545fd4935a0e1ddd7147f557bf8157c73eecec9cffd523382fa7af2557de/pybase64-1.4.3-graalpy311-graalpy242_311_native-macosx_10_9_x86_64.whl", hash = "sha256:d27c1dfdb0c59a5e758e7a98bd78eaca5983c22f4a811a36f4f980d245df4611", size = 38393, upload-time = "2025-12-06T13:26:19.535Z" }, + { url = "https://files.pythonhosted.org/packages/c3/ca/ae7a96be9ddc96030d4e9dffc43635d4e136b12058b387fd47eb8301b60f/pybase64-1.4.3-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0f1a0c51d6f159511e3431b73c25db31095ee36c394e26a4349e067c62f434e5", size = 32109, upload-time = "2025-12-06T13:26:20.72Z" }, + { url = "https://files.pythonhosted.org/packages/bf/44/d4b7adc7bf4fd5b52d8d099121760c450a52c390223806b873f0b6a2d551/pybase64-1.4.3-graalpy311-graalpy242_311_native-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a492518f3078a4e3faaef310697d21df9c6bc71908cebc8c2f6fbfa16d7d6b1f", size = 43227, upload-time = "2025-12-06T13:26:21.845Z" }, + { url = "https://files.pythonhosted.org/packages/08/86/2ba2d8734ef7939debeb52cf9952e457ba7aa226cae5c0e6dd631f9b851f/pybase64-1.4.3-graalpy311-graalpy242_311_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cae1a0f47784fd16df90d8acc32011c8d5fcdd9ab392c9ec49543e5f6a9c43a4", size = 35804, upload-time = "2025-12-06T13:26:23.149Z" }, + { url = "https://files.pythonhosted.org/packages/4f/5b/19c725dc3aaa6281f2ce3ea4c1628d154a40dd99657d1381995f8096768b/pybase64-1.4.3-graalpy311-graalpy242_311_native-win_amd64.whl", hash = "sha256:03cea70676ffbd39a1ab7930a2d24c625b416cacc9d401599b1d29415a43ab6a", size = 35880, upload-time = "2025-12-06T13:26:24.663Z" }, { url = "https://files.pythonhosted.org/packages/17/45/92322aec1b6979e789b5710f73c59f2172bc37c8ce835305434796824b7b/pybase64-1.4.3-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:2baaa092f3475f3a9c87ac5198023918ea8b6c125f4c930752ab2cbe3cd1d520", size = 38746, upload-time = "2025-12-06T13:26:25.869Z" }, { url = "https://files.pythonhosted.org/packages/11/94/f1a07402870388fdfc2ecec0c718111189732f7d0f2d7fe1386e19e8fad0/pybase64-1.4.3-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:cde13c0764b1af07a631729f26df019070dad759981d6975527b7e8ecb465b6c", size = 32573, upload-time = "2025-12-06T13:26:27.792Z" }, { url = "https://files.pythonhosted.org/packages/fa/8f/43c3bb11ca9bacf81cb0b7a71500bb65b2eda6d5fe07433c09b543de97f3/pybase64-1.4.3-graalpy312-graalpy250_312_native-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5c29a582b0ea3936d02bd6fe9bf674ab6059e6e45ab71c78404ab2c913224414", size = 43461, upload-time = "2025-12-06T13:26:28.906Z" }, { url = "https://files.pythonhosted.org/packages/2d/4c/2a5258329200be57497d3972b5308558c6de42e3749c6cc2aa1cbe34b25a/pybase64-1.4.3-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b6b664758c804fa919b4f1257aa8cf68e95db76fc331de5f70bfc3a34655afe1", size = 36058, upload-time = "2025-12-06T13:26:30.092Z" }, { url = "https://files.pythonhosted.org/packages/ea/6d/41faa414cde66ec023b0ca8402a8f11cb61731c3dc27c082909cbbd1f929/pybase64-1.4.3-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:f7537fa22ae56a0bf51e4b0ffc075926ad91c618e1416330939f7ef366b58e3b", size = 36231, upload-time = "2025-12-06T13:26:31.656Z" }, + { url = "https://files.pythonhosted.org/packages/2a/cf/6e712491bd665ea8633efb0b484121893ea838d8e830e06f39f2aae37e58/pybase64-1.4.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94cf50c36bb2f8618982ee5a978c4beed9db97d35944fa96e8586dd953c7994a", size = 38007, upload-time = "2025-12-06T13:26:32.804Z" }, + { url = "https://files.pythonhosted.org/packages/38/c0/9272cae1c49176337dcdbd97511e2843faae1aaf5a5fb48569093c6cd4ce/pybase64-1.4.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:01bc3ff5ca1341685c6d2d945b035f442f7b9c3b068a5c6ee8408a41fda5754e", size = 31538, upload-time = "2025-12-06T13:26:34.001Z" }, + { url = "https://files.pythonhosted.org/packages/20/f2/17546f97befe429c73f622bbd869ceebb518c40fdb0dec4c4f98312e80a5/pybase64-1.4.3-pp310-pypy310_pp73-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:03d0aa3761a99034960496280c02aa063f856a3cc9b33771bc4eab0e4e72b5c2", size = 40682, upload-time = "2025-12-06T13:26:35.168Z" }, + { url = "https://files.pythonhosted.org/packages/92/a0/464b36d5dfb61f3da17858afaeaa876a9342d58e9f17803ce7f28b5de9e8/pybase64-1.4.3-pp310-pypy310_pp73-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7ca5b1ce768520acd6440280cdab35235b27ad2faacfcec064bc9c3377066ef1", size = 41306, upload-time = "2025-12-06T13:26:36.351Z" }, + { url = "https://files.pythonhosted.org/packages/07/c9/a748dfc0969a8d960ecf1e82c8a2a16046ffec22f8e7ece582aa3b1c6cf9/pybase64-1.4.3-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3caa1e2ddad1c50553ffaaa1c86b74b3f9fbd505bea9970326ab88fc68c4c184", size = 35452, upload-time = "2025-12-06T13:26:37.772Z" }, + { url = "https://files.pythonhosted.org/packages/95/b7/4d37bd3577d1aa6c732dc099087fe027c48873e223de3784b095e5653f8b/pybase64-1.4.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bd47076f736b27a8b0f9b30d93b6bb4f5af01b0dc8971f883ed3b75934f39a99", size = 36125, upload-time = "2025-12-06T13:26:39.78Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/160dded493c00d3376d4ad0f38a2119c5345de4a6693419ad39c3565959b/pybase64-1.4.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:277de6e03cc9090fb359365c686a2a3036d23aee6cd20d45d22b8c89d1247f17", size = 37939, upload-time = "2025-12-06T13:26:41.014Z" }, + { url = "https://files.pythonhosted.org/packages/b7/b8/a0f10be8d648d6f8f26e560d6e6955efa7df0ff1e009155717454d76f601/pybase64-1.4.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ab1dd8b1ed2d1d750260ed58ab40defaa5ba83f76a30e18b9ebd5646f6247ae5", size = 31466, upload-time = "2025-12-06T13:26:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/22/832a2f9e76cdf39b52e01e40d8feeb6a04cf105494f2c3e3126d0149717f/pybase64-1.4.3-pp311-pypy311_pp73-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:bd4d2293de9fd212e294c136cec85892460b17d24e8c18a6ba18750928037750", size = 40681, upload-time = "2025-12-06T13:26:43.782Z" }, + { url = "https://files.pythonhosted.org/packages/12/d7/6610f34a8972415fab3bb4704c174a1cc477bffbc3c36e526428d0f3957d/pybase64-1.4.3-pp311-pypy311_pp73-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2af6d0d3a691911cc4c9a625f3ddcd3af720738c21be3d5c72de05629139d393", size = 41294, upload-time = "2025-12-06T13:26:44.936Z" }, + { url = "https://files.pythonhosted.org/packages/64/25/ed24400948a6c974ab1374a233cb7e8af0a5373cea0dd8a944627d17c34a/pybase64-1.4.3-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5cfc8c49a28322d82242088378f8542ce97459866ba73150b062a7073e82629d", size = 35447, upload-time = "2025-12-06T13:26:46.098Z" }, + { url = "https://files.pythonhosted.org/packages/ee/2b/e18ee7c5ee508a82897f021c1981533eca2940b5f072fc6ed0906c03a7a7/pybase64-1.4.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:debf737e09b8bf832ba86f5ecc3d3dbd0e3021d6cd86ba4abe962d6a5a77adb3", size = 36134, upload-time = "2025-12-06T13:26:47.35Z" }, ] [[package]] @@ -2025,6 +2560,33 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" }, + { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" }, + { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" }, + { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" }, + { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" }, + { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" }, + { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" }, + { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, + { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, + { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, + { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, + { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, + { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, + { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, @@ -2081,10 +2643,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, + { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" }, + { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" }, + { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" }, + { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" }, + { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" }, + { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" }, + { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, + { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, + { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, + { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, ] [[package]] @@ -2191,9 +2773,11 @@ version = "8.3.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "iniconfig" }, { name = "packaging" }, { name = "pluggy" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891, upload-time = "2025-03-02T12:54:54.503Z" } wheels = [ @@ -2205,7 +2789,7 @@ name = "pytest-cov" version = "6.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "coverage" }, + { name = "coverage", extra = ["toml"] }, { name = "pytest" }, ] sdist = { url = "https://files.pythonhosted.org/packages/25/69/5f1e57f6c5a39f81411b550027bf72842c4567ff5fd572bed1edc9e4b5d9/pytest_cov-6.1.1.tar.gz", hash = "sha256:46935f7aaefba760e716c2ebfbe1c216240b9592966e7da99ea8292d4d3e2a0a", size = 66857, upload-time = "2025-04-05T14:07:51.592Z" } @@ -2300,6 +2884,12 @@ name = "pywin32" version = "311" source = { registry = "https://pypi.org/simple" } wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/40/44efbb0dfbd33aca6a6483191dae0716070ed99e2ecb0c53683f400a0b4f/pywin32-311-cp310-cp310-win32.whl", hash = "sha256:d03ff496d2a0cd4a5893504789d4a15399133fe82517455e78bad62efbb7f0a3", size = 8760432, upload-time = "2025-07-14T20:13:05.9Z" }, + { url = "https://files.pythonhosted.org/packages/5e/bf/360243b1e953bd254a82f12653974be395ba880e7ec23e3731d9f73921cc/pywin32-311-cp310-cp310-win_amd64.whl", hash = "sha256:797c2772017851984b97180b0bebe4b620bb86328e8a884bb626156295a63b3b", size = 9590103, upload-time = "2025-07-14T20:13:07.698Z" }, + { url = "https://files.pythonhosted.org/packages/57/38/d290720e6f138086fb3d5ffe0b6caa019a791dd57866940c82e4eeaf2012/pywin32-311-cp310-cp310-win_arm64.whl", hash = "sha256:0502d1facf1fed4839a9a51ccbcc63d952cf318f78ffc00a7e78528ac27d7a2b", size = 8778557, upload-time = "2025-07-14T20:13:11.11Z" }, + { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" }, + { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" }, + { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" }, { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, @@ -2317,6 +2907,24 @@ version = "6.0.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, @@ -2371,6 +2979,127 @@ 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.7.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/98/04b13f1ddfb63158025291c02e03eb42fbb7acb51d091d541050eb4e35e8/regex-2026.7.19.tar.gz", hash = "sha256:7e77b324909c1617cbb4c668677e2c6ae13f44d7c1de0d4f15f2e3c10f3315b5", size = 416440, upload-time = "2026-07-19T00:19:48.923Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/13/bbf7d9d1887fe4a3693527c6caa232c197ea9da91f1212e9672eff60329d/regex-2026.7.19-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:555497390743af1a65045fa4527782d10ff5b88970359412baa4a1e628fe393b", size = 494009, upload-time = "2026-07-19T00:16:13.602Z" }, + { url = "https://files.pythonhosted.org/packages/a3/19/783688e75a2bec15d50aec0d5e7e317d363808bc82a6eb6750b897bfcd7b/regex-2026.7.19-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:343a4504e3fb688c47cad451221ca5d4814f42b1e16c0065bde9cbf7f473bd52", size = 295287, upload-time = "2026-07-19T00:16:15.702Z" }, + { url = "https://files.pythonhosted.org/packages/16/01/cefe4f051302ca298d3f3e79ed6dbd933ac84485b9515acdd6a52d70cef7/regex-2026.7.19-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ebee1ee89c39c953baac6924fcde08c5bb427c4057510862f9d7c7bdb3d8665", size = 290633, upload-time = "2026-07-19T00:16:17.182Z" }, + { url = "https://files.pythonhosted.org/packages/ae/1e/1045ca2cabb12e8ec41ad0d138e9f3ff1eb079d30a6f51ccf7d709b44aad/regex-2026.7.19-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:062f8cb7a9739c4835d22bd96f370c59aba89f257adcfa53be3cc209e08d3ae0", size = 785300, upload-time = "2026-07-19T00:16:18.505Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/20e5bca184e90bf1bd187efdb53363f4a7b7b34f01d54ced5740caf104bd/regex-2026.7.19-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1123ef4211d763ee771d47916a1596e2f4915794f7aabdc1adcb20e4249a6951", size = 854079, upload-time = "2026-07-19T00:16:19.909Z" }, + { url = "https://files.pythonhosted.org/packages/09/9b/5a2e59678be3b24aa6a42b2c6d66a48daa212593e9f4096fe7ba577fa9b1/regex-2026.7.19-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6e44c0e7c5664be20aee92085153150c0a7967310a73a43c0f832b7cd35d0dd3", size = 899496, upload-time = "2026-07-19T00:16:21.453Z" }, + { url = "https://files.pythonhosted.org/packages/48/9a/7317f14ed8ed9fd998d1978b4802b07bc4d79216353c435dbcc1ddd1301f/regex-2026.7.19-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98c6ac18480fcdb33f35439183f1d2e79760ab41930309c6d951cb1f8e46694c", size = 793541, upload-time = "2026-07-19T00:16:22.991Z" }, + { url = "https://files.pythonhosted.org/packages/6f/53/833c2db3e274d3c191f4c42fe5bfa358e4c8b617d5d7312d31334965fc46/regex-2026.7.19-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4458124d71339f505bf1fb94f69fd1bb8fa9d2481eebfef27c10ef4f2b9e12f6", size = 785515, upload-time = "2026-07-19T00:16:24.654Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b9/efb2f9fa151d71db09d4015e1fb92fee47416f01c12164836bbd23e2f3c2/regex-2026.7.19-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fbf300e2070bb35038660b3be1be4b91b0024edb41517e6996320b49b92b4175", size = 769556, upload-time = "2026-07-19T00:16:26.207Z" }, + { url = "https://files.pythonhosted.org/packages/81/4d/45610c263f8eadb84e4a1fabd904d81d5176226faa9104ef498bf8a8b285/regex-2026.7.19-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b2b506b1788df5fecd270a10d5e70a95fe77b87ea2b370a318043f6f5f817ee6", size = 774130, upload-time = "2026-07-19T00:16:27.786Z" }, + { url = "https://files.pythonhosted.org/packages/40/95/1b40d87c7a9e5480bec7a87bce9fd67fc3f14b5f106c8ee66d660249072f/regex-2026.7.19-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:52579c60a6078be70a0e49c81d6e56d677f34cd439af281a0083b8c7bc75c095", size = 848694, upload-time = "2026-07-19T00:16:29.412Z" }, + { url = "https://files.pythonhosted.org/packages/17/8b/bb45968addd5b394ef9cd9184bd9c65ade1a819dbb2b92b71ad52a0c7907/regex-2026.7.19-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:2955907b7157a6660f27079edf7e0229e9c9c5325c77a2ef6a890cba91efa6f0", size = 758505, upload-time = "2026-07-19T00:16:31.006Z" }, + { url = "https://files.pythonhosted.org/packages/bf/6f/33386c672fbf43e21602135a0f29a97ee251a483f007fe51d10e9b2dbc93/regex-2026.7.19-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:89dfee3319f5ae3f75ebd5c2445a809bb320252ba5529ffdafea4ef25d79cf1a", size = 836985, upload-time = "2026-07-19T00:16:32.459Z" }, + { url = "https://files.pythonhosted.org/packages/22/f1/9112b86e9bb075619862e8e42b604794389f1958faa68fb69bde505dd90e/regex-2026.7.19-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d3143f159261b1ce5b24c261c590e5913370c3200c5e9ebbb92b5aa5e111902", size = 782610, upload-time = "2026-07-19T00:16:33.857Z" }, + { url = "https://files.pythonhosted.org/packages/3a/f9/13d460d8a385ca0b0be9e6be80a90968b9293b3e30895543ad2d1d1653e4/regex-2026.7.19-cp310-cp310-win32.whl", hash = "sha256:64729333167c2dcaaa56a331d40ee097bd9c5617ffd51dabb09eaddafb1b532e", size = 266772, upload-time = "2026-07-19T00:16:35.194Z" }, + { url = "https://files.pythonhosted.org/packages/9f/90/29addd7a03e1aea402c1f31467e25c80caabc8c3735b88a23cf73b0aa9c2/regex-2026.7.19-cp310-cp310-win_amd64.whl", hash = "sha256:1c398716054621aa300b3d411f467dda903806c5da0df6945ab73982b8d115db", size = 277967, upload-time = "2026-07-19T00:16:36.847Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ba/ecfce06fe66c122bc6f77ae284887a9282e4411fe1e6268c5266611ca054/regex-2026.7.19-cp310-cp310-win_arm64.whl", hash = "sha256:064f1760a5a4ade65c5419be23e782f29147528e8a66e0c42dd4cedb8d4e9fc6", size = 276963, upload-time = "2026-07-19T00:16:38.315Z" }, + { url = "https://files.pythonhosted.org/packages/05/e5/cef4de2bac939280b68d32adc659478845238a8274f2f79c465063f590ad/regex-2026.7.19-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ac777001cdfc28b72477d93c8564bb7583081ea8fb45cdca3d568e0a4f87183c", size = 494012, upload-time = "2026-07-19T00:16:39.927Z" }, + { url = "https://files.pythonhosted.org/packages/ff/87/e86f51eb117457bb7803132ffe5cb6e2841e2b5bea4cc85d397f3c6e257d/regex-2026.7.19-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:59787bd5f8c70aa339084e961d2996b53fbdeab4d5393bba5c1fe1fc32e02bae", size = 295281, upload-time = "2026-07-19T00:16:41.433Z" }, + { url = "https://files.pythonhosted.org/packages/41/2e/2360c41d8080a3d9ec7e5c90fad6eab3b50192869d10e9a5609e48c8177b/regex-2026.7.19-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:90c633e7e8d6bf4e992b8b36ce69e018f834b641dd6de8cea6d78c06ffa119c5", size = 290615, upload-time = "2026-07-19T00:16:43.058Z" }, + { url = "https://files.pythonhosted.org/packages/cf/69/b65ba4344efbc771b28fe5dde84cbbb6c8f9551165952fe78def5b9dde6a/regex-2026.7.19-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87ccab0db8d5f4fbb0272642113c1adb2ffc698c16d3a0944580222331fa7a20", size = 791804, upload-time = "2026-07-19T00:16:44.662Z" }, + { url = "https://files.pythonhosted.org/packages/81/b6/a40dfa0dc6224b36f620c00296eacc830489cbf8c2837b6750dfe6170375/regex-2026.7.19-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e50d748a32da622f256e8d505867f5d3c43a837c6a9f0efb149655fadd1042a", size = 861723, upload-time = "2026-07-19T00:16:46.412Z" }, + { url = "https://files.pythonhosted.org/packages/e3/02/735991dee71abd83196a7962f7ed8bf5aa05720ff06e2d3ff896a85e2bbb/regex-2026.7.19-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bf1516fe58fc104f39b2d1dbe2d5e27d0cd45c4be2e42ba6ee0cc763701ec3c7", size = 905932, upload-time = "2026-07-19T00:16:47.956Z" }, + { url = "https://files.pythonhosted.org/packages/45/6c/e7098d8b846ccdbf431d8c081b61e496526a27a28094ed09e0dce21b3f54/regex-2026.7.19-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09f3e5287f94f17b709dc9a9e70865855feee835c861613be144218ce4ca82cc", size = 801407, upload-time = "2026-07-19T00:16:49.43Z" }, + { url = "https://files.pythonhosted.org/packages/8a/18/34b69274e2649bcc7d9b089c2b2983fb2632d8ecf667e359593be9072e79/regex-2026.7.19-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6383cd2ed53a646c659ba1fe65727db76437fdaa069e697a0b44a51d5843d864", size = 774448, upload-time = "2026-07-19T00:16:51.352Z" }, + { url = "https://files.pythonhosted.org/packages/bb/e6/0a72247d025585fd3800b98e040b84d562a88af6303347100484849f4f01/regex-2026.7.19-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:09d3007fc76249a83cdd33de160d50e6cb77f54e09d8fa9e7148e10607ce24af", size = 783297, upload-time = "2026-07-19T00:16:53.071Z" }, + { url = "https://files.pythonhosted.org/packages/b1/aa/c4f65ae7dd02a36b323a70c4cff326e1f3442361aaebc9311100a130d54f/regex-2026.7.19-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:6f8c6e7a1cfa3dc9d0ee2de0e65e834537fa29992cc3976ffec914afc35c5dd5", size = 854736, upload-time = "2026-07-19T00:16:54.607Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/668082bcc817b9e694189b84997aeba7385b7779faa6711788679c482e35/regex-2026.7.19-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:b2ea4a3e8357be8849e833beeae757ac3c7a6b3fc055c03c808a53c91ad30d82", size = 763298, upload-time = "2026-07-19T00:16:56.289Z" }, + { url = "https://files.pythonhosted.org/packages/4b/fb/2d07ad555e7af88aa5f867fdafa47a8d945ee237c20af3ebceb46a820835/regex-2026.7.19-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:80115dd39481fd3a4b4080220799dbcacb921a844de4b827264ececacbe17c78", size = 844430, upload-time = "2026-07-19T00:16:57.933Z" }, + { url = "https://files.pythonhosted.org/packages/51/15/c82a471fe3dce56f03745635b43aa456c40dc0db089e07ef148b331507d1/regex-2026.7.19-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6ce43a0269d68cee79a7d1ade7def53c20f8f2a047b92d7b5d5bcc73ae88327", size = 789683, upload-time = "2026-07-19T00:16:59.583Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f4/7532a2c59d56f5398902c20de60f0c9a5d1cd364e42a051b48e1b210be7b/regex-2026.7.19-cp311-cp311-win32.whl", hash = "sha256:9be2a6647740dd3cca6acb24e87f03d7632cd280dbce9bbe40c26353a215a45d", size = 266778, upload-time = "2026-07-19T00:17:01.032Z" }, + { url = "https://files.pythonhosted.org/packages/83/2b/cf1bc631db154eb95520d9d5dbc2371ff77a0f014bbf7d748fed8496aa63/regex-2026.7.19-cp311-cp311-win_amd64.whl", hash = "sha256:8d3469c91dd92ee41b7c95280edbd975ef1ba9195086686623a1c6e8935ce965", size = 277983, upload-time = "2026-07-19T00:17:02.571Z" }, + { url = "https://files.pythonhosted.org/packages/8d/bd/56ceaf170e875d5a6761bf2bfd0d040f1cacc896850d5e40cb29b11bbd06/regex-2026.7.19-cp311-cp311-win_arm64.whl", hash = "sha256:36aacfb15faaff3ced55afbf35ec72f50d4aee22082c4f7fe0573a33e2fca92e", size = 276961, upload-time = "2026-07-19T00:17:04.135Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b9/d11d7e501ac8fd7d617684423ebb9561e0b998481c1e4cbc0cb212c5d74a/regex-2026.7.19-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2cc3460cedf7579948486eab03bc9ad7089df4d7281c0f47f4afe03e8d13f02d", size = 496778, upload-time = "2026-07-19T00:17:05.677Z" }, + { url = "https://files.pythonhosted.org/packages/3f/a9/a5ab6f312f24318019170dc485d5421fe4f89e43a98640da50d95a8a7041/regex-2026.7.19-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0e9554c8785eac5cffe6300f69a91f58ba72bc88a5f8d661235ad7c6aa5b8ccd", size = 297122, upload-time = "2026-07-19T00:17:07.59Z" }, + { url = "https://files.pythonhosted.org/packages/b3/63/4cab4d7f2d384a144d420b763d97674cb70619c878ea6fcd7640d0e62143/regex-2026.7.19-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d7da47a0f248977f08e2cb659ff3c17ddc13a4d39b3a7baa0a81bf5b415430f6", size = 292009, upload-time = "2026-07-19T00:17:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/22/85/102a81b218298957d4ea7d2f084fae537a71add9d6ff93c8e67284c5f45e/regex-2026.7.19-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93db40c8de0815baab96a06e08a984bac71f989d13bab789e382158c5d426797", size = 796708, upload-time = "2026-07-19T00:17:11.542Z" }, + { url = "https://files.pythonhosted.org/packages/78/b5/dc136af5629938a037cd2b304c12240e132ec92f38be8ff9cc89af2a1f2d/regex-2026.7.19-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:66bd62c59a5427746e8c44becae1d9b99d22fb13f30f492083dfb9ad7c45cc18", size = 865651, upload-time = "2026-07-19T00:17:13.312Z" }, + { url = "https://files.pythonhosted.org/packages/e0/75/67402ae3cd9c8c988a4c805d15ee3eef015e7ca4cb112cf3e640fc1f4153/regex-2026.7.19-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1649eb39fcc9ea80c4d2f110fde2b8ab2aef3877b98f02ab9b14e961f418c511", size = 911756, upload-time = "2026-07-19T00:17:15.015Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8e/096d00c7c480ef2ff4265349b14e2261d4ab787ba1f74e2e80d1c58079c3/regex-2026.7.19-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9dce8ec9695f531a1b8a6f314fd4b393adcccf2ea861db480cdf97a301d01a68", size = 801798, upload-time = "2026-07-19T00:17:17.208Z" }, + { url = "https://files.pythonhosted.org/packages/f0/41/e7ecac6edb5722417f85cc67eaf386322fbe8acf6918ec2fdc37c20dd9d0/regex-2026.7.19-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3080a7fd38ef049bd489e01c970c97dd84ff446a885b0f1f6b26d9b1ad13ce11", size = 776933, upload-time = "2026-07-19T00:17:19.347Z" }, + { url = "https://files.pythonhosted.org/packages/6f/69/03c9b3f058d66403e0ca2c938696e81d51cd4c6d47ec5265f02f96948d9a/regex-2026.7.19-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1d793a7988e04fcb1e2e135567443d82173225d657419ec09414a9b5a145b986", size = 784338, upload-time = "2026-07-19T00:17:21.057Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f7/b38ab3d43f284afbb618fcd15d0e77eb786ae461ce1f6bc7494619ddc0f2/regex-2026.7.19-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e8b0abe7d870f53ca5143895fef7d1041a0c831a140d3dc2c760dd7ba25d4a8b", size = 860452, upload-time = "2026-07-19T00:17:23.119Z" }, + { url = "https://files.pythonhosted.org/packages/15/5c/ff60ef0571121714f3cf9920bc183071e384a10b556d042e0fdb06cc07a5/regex-2026.7.19-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:4e5413bd5f13d3a4e3539ca98f70f75e7fca92518dd7f117f030ebedd10b60cb", size = 765958, upload-time = "2026-07-19T00:17:24.81Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0f/bd34021162c0ab47f9a315bd56cd5642e920c8e5668a75ef6c6a6fca590d/regex-2026.7.19-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:73b133a9e6fb512858e7f065e96f1180aa46646bc74a83aea62f1d314f3dd035", size = 851765, upload-time = "2026-07-19T00:17:26.993Z" }, + { url = "https://files.pythonhosted.org/packages/2a/20/a2ca43edade0595cccfdc98636739f536d9e26898e7dbddc2b9e98898953/regex-2026.7.19-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dbe6493fbd27321b1d1f2dd4f5c7e5bd4d8b1d7cab7f32fd67db3d0b2ed8248a", size = 789714, upload-time = "2026-07-19T00:17:28.699Z" }, + { url = "https://files.pythonhosted.org/packages/5d/47/e02db4015d424fc83c00ea0ac8c5e5ec14397943de9abf909d5ce3a25931/regex-2026.7.19-cp312-cp312-win32.whl", hash = "sha256:ddd67571c10869f65a5d7dde536d1e066e306cc90de57d7de4d5f34802428bb5", size = 267157, upload-time = "2026-07-19T00:17:31.051Z" }, + { url = "https://files.pythonhosted.org/packages/08/8e/c780c131f79b42ed22d1bd7da4096c2c35f813e835acd02ef0f018bd892c/regex-2026.7.19-cp312-cp312-win_amd64.whl", hash = "sha256:e30d40268a28d54ce0437031750497004c22602b8e3ab891f759b795a003b312", size = 277777, upload-time = "2026-07-19T00:17:32.848Z" }, + { url = "https://files.pythonhosted.org/packages/3e/4c/e4d7e086449bdf379d89774bf1f89dc4a41943f3c5a6125a03905b34b5fb/regex-2026.7.19-cp312-cp312-win_arm64.whl", hash = "sha256:de9208bb427130c82a5dbfd104f92c8876fc9559278c880b3002755bbbe9c83d", size = 277136, upload-time = "2026-07-19T00:17:34.803Z" }, + { url = "https://files.pythonhosted.org/packages/5d/3d/84165e4299ff76f3a40fe1f2abf939e976f693383a08d2beea6af62bd2c1/regex-2026.7.19-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f035d9dc1d25eff9d361456572231c7d27b5ccd473ca7dc0adfce732bd006d40", size = 496552, upload-time = "2026-07-19T00:17:36.808Z" }, + { url = "https://files.pythonhosted.org/packages/02/a2/a65293e6e4cf28eb7ee1be5335a5386c40d6742e9f47fafc8fec785e16c7/regex-2026.7.19-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c42572142ed0b9d5d261ba727157c426510da78e20828b66bbb855098b8a4e38", size = 296983, upload-time = "2026-07-19T00:17:38.816Z" }, + { url = "https://files.pythonhosted.org/packages/95/47/2d0564e93d87bc48618360ddca232a2ca612bbdf53ce8465d45ca5ce14ee/regex-2026.7.19-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:40b34dd88658e4fedd2fddbf0275ac970d00614b731357f425722a3ed1983d11", size = 291832, upload-time = "2026-07-19T00:17:40.726Z" }, + { url = "https://files.pythonhosted.org/packages/07/cd/42dfbabff3dfc9603c501c0e2e2c5adbb09d127b267bf5348de0af338c15/regex-2026.7.19-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c41c63992bf1874cebb6e7f56fd7d3c007924659a604ae3d90e427d40d4fd13", size = 796775, upload-time = "2026-07-19T00:17:42.382Z" }, + { url = "https://files.pythonhosted.org/packages/df/5d/f6a4839f2b934e3eed5973fd07f5929ee97d4c98939fb275ea23c274ee16/regex-2026.7.19-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d3372064506b94dd2c67c845f2db8062e9e9ba84d04e33cb96d7d33c11fe1ae", size = 865687, upload-time = "2026-07-19T00:17:44.185Z" }, + { url = "https://files.pythonhosted.org/packages/14/b0/b47d6c36049bc59806a50bd4c86ced70bbe058d787f80281b1d7a9b0e024/regex-2026.7.19-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fce7760bf283405b2c7999cab3da4e72f7deca6396013115e3f7a955db9760da", size = 911962, upload-time = "2026-07-19T00:17:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/2a/be/ff61f28f9273658cfe23acbbac5217221f6519960ed401e61dfdab12bc35/regex-2026.7.19-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0d702548d89d572b2929879bc883bb7a4c4709efafe4512cadee56c55c9bd15", size = 801817, upload-time = "2026-07-19T00:17:48.25Z" }, + { url = "https://files.pythonhosted.org/packages/c3/bb/8b4f7f26b333f9f79e1b453613c39bb4776f51d38ae66dd0ba31d6b354ca/regex-2026.7.19-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d446c6ac40bb6e05025ccee55b84d80fe9bf8e93010ffc4bb9484f13d498835f", size = 776908, upload-time = "2026-07-19T00:17:50.183Z" }, + { url = "https://files.pythonhosted.org/packages/09/13/610110fc5921d380516d03c26b652555f08aa0d23ea78a771231873c3638/regex-2026.7.19-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4c3501bfa814ab07b5580741f9bf78dfdfe146a04057f82df9e2402d2a975939", size = 784426, upload-time = "2026-07-19T00:17:52.454Z" }, + { url = "https://files.pythonhosted.org/packages/ca/f5/1ef9e2a83a5947c57ebff0b377cb5727c3d5ec1992317a320d035cd0dbb6/regex-2026.7.19-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c4585c3e64b4f9e583b4d2683f18f5d5d872b3d71dcf24594b74ecc23602fa96", size = 860600, upload-time = "2026-07-19T00:17:54.229Z" }, + { url = "https://files.pythonhosted.org/packages/a0/02/073af33a3ec149241d11c80acea91e722aa0adbf05addd50f251c4fe89c3/regex-2026.7.19-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:571fde9741eb0ccde23dd4e0c1d50fbae910e901fa7e629faf39b2dda740d220", size = 765950, upload-time = "2026-07-19T00:17:56.041Z" }, + { url = "https://files.pythonhosted.org/packages/81/a9/d1e9f819dc394a568ef370cd56cf25394e957a2235f8370f23b576e5a475/regex-2026.7.19-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:15b364b9b98d6d2fe1a85034c23a3180ff913f46caddc3895f6fd65186255ccc", size = 851794, upload-time = "2026-07-19T00:17:57.897Z" }, + { url = "https://files.pythonhosted.org/packages/03/3a/8ae83eda7579feacdf984e71fb9e70635fb6f832eeddca58427ec4fca926/regex-2026.7.19-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffd8893ccc1c2fce6e0d6ca402d716fe1b29db70c7132609a05955e31b2aa8f2", size = 789845, upload-time = "2026-07-19T00:17:59.97Z" }, + { url = "https://files.pythonhosted.org/packages/4b/23/c195cbfe5a75fdec64d8f6554fd15237b837919d2c61bdc141d7c807b08b/regex-2026.7.19-cp313-cp313-win32.whl", hash = "sha256:f0fa4fa9c3632d708742baf2282f2055c11d888a790362670a403cbf48a2c404", size = 267135, upload-time = "2026-07-19T00:18:01.958Z" }, + { url = "https://files.pythonhosted.org/packages/b2/80/a11de8404b7272b70acb45c1c05987cce60b45d5693da2e176f0e390d564/regex-2026.7.19-cp313-cp313-win_amd64.whl", hash = "sha256:d51ffd3427640fa2da6ade574ceba932f210ad095f65fcc450a2b0a0d454868e", size = 277747, upload-time = "2026-07-19T00:18:04.121Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/0f5c8eff1b4f1f3d83276d365fccecf666afcc7d947420943bf394d07adb/regex-2026.7.19-cp313-cp313-win_arm64.whl", hash = "sha256:c670fe7be5b6020b76bc6e8d2196074657e1327595bca93a389e1a76ab130ad8", size = 277129, upload-time = "2026-07-19T00:18:05.821Z" }, + { url = "https://files.pythonhosted.org/packages/dc/4c/44b74742052cedda40f9ae469532a037112f7311a36669a891fba8984bb0/regex-2026.7.19-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db47b561c9afd884baa1f96f797c9ca369872c4b65912bc691cfa99e68340af2", size = 501134, upload-time = "2026-07-19T00:18:07.567Z" }, + { url = "https://files.pythonhosted.org/packages/f0/45/bbd038b5e39ee5613a5a689290145b40058cc152c41de9cc23639d2b9734/regex-2026.7.19-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:65dcd28d3eba2ab7c2fd906485cc301392b47cc2234790d27d4e4814e02cdfda", size = 299418, upload-time = "2026-07-19T00:18:09.38Z" }, + { url = "https://files.pythonhosted.org/packages/65/38/c5bde94b4cedfd5850d64c3f08222d8e1600e84f6ee71d9b44b4b8163f74/regex-2026.7.19-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f2e7f8e2ab6c2922be02c7ec45185aa5bd771e2e57b95455ee343a44d8130dff", size = 294486, upload-time = "2026-07-19T00:18:11.188Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6a/2f5e107cb26c960b781967178899daf2787a7ab151844ed3c01d6fc95474/regex-2026.7.19-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe31f28c94402043161876a258a9c6f757cb485905c7614ce8d6cd40e6b7bdc1", size = 811643, upload-time = "2026-07-19T00:18:12.975Z" }, + { url = "https://files.pythonhosted.org/packages/37/d4/a2f963406d7d73a62eed84ba05a258afb6cad1b21aa4517443ce40506b78/regex-2026.7.19-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f8f6fa298bb4f7f58a33334406218ba74716e68feddf5e4e54cd5d8082705abf", size = 871081, upload-time = "2026-07-19T00:18:14.733Z" }, + { url = "https://files.pythonhosted.org/packages/45/a3/44be546340bedb15f13063f5e7fe16793ea4d9ea2e805d09bd174ac27724/regex-2026.7.19-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:cc1b2440423a851fad781309dd87843868f4f66a6bcd1ddb9225cf4ec2c84732", size = 917372, upload-time = "2026-07-19T00:18:16.724Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f6/e0870b0fd2a40dba0074e4b76e514b21313d37946c9248453e34ec43923e/regex-2026.7.19-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ac59a0900474a52b7c04af8196affc22bd9842acb0950df12f7b813e983609a", size = 816089, upload-time = "2026-07-19T00:18:18.617Z" }, + { url = "https://files.pythonhosted.org/packages/ae/27/957e8e22690ad6634572b39b71f130a6105f4d0718bb16849eac00fff147/regex-2026.7.19-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4896db1f4ce0576765b8272aa922df324e0f5b9bb2c3d03044ff32a7234a9aba", size = 785206, upload-time = "2026-07-19T00:18:20.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/a4/186e410941e731037c01166069ab86da9f65e8f8110c18009ccf4bd623ee/regex-2026.7.19-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4e6883a021db30511d9fb8cfb0f222ce1f2c369f7d4d8b0448f449a93ba0bdfc", size = 800431, upload-time = "2026-07-19T00:18:22.716Z" }, + { url = "https://files.pythonhosted.org/packages/73/9f/e4e10e023d291d64a33e246610b724493bf1ce98e0e59c9b7c837e5acfb7/regex-2026.7.19-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:09523a592938aa9f587fb74467c63ff0cf88fc3df14c82ab0f0517dcf76aaa62", size = 864906, upload-time = "2026-07-19T00:18:24.772Z" }, + { url = "https://files.pythonhosted.org/packages/24/57/ccb20b6be5f1f52a053d1ba2a8f7a077edb9d918248b8490d7506c6832b3/regex-2026.7.19-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:1ebac3474b8589fce2f9b225b650afd61448f7c73a5d0255a10cc6366471aed1", size = 773559, upload-time = "2026-07-19T00:18:27.008Z" }, + { url = "https://files.pythonhosted.org/packages/a3/82/f3b263cf8fad927dc102891da8502e718b7ff9d19af7a2a07c03865d7188/regex-2026.7.19-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:4a0530bb1b8c1c985e7e2122e2b4d3aedd8a3c21c6bfddae6767c4405668b56e", size = 857739, upload-time = "2026-07-19T00:18:29.107Z" }, + { url = "https://files.pythonhosted.org/packages/47/2e/1687bd1b6c2aed5e672ccf845fc11557821fe7366d921b50889ea5ce57bf/regex-2026.7.19-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2ef7eeb108c47ce7bcc9513e51bcb1bf57e8f483d52fce68a8642e3527141ae0", size = 804522, upload-time = "2026-07-19T00:18:31.362Z" }, + { url = "https://files.pythonhosted.org/packages/76/7c/cc4e7655181b2d9235b704f2c5e19d8eff002bbc437bae59baee0e381aca/regex-2026.7.19-cp313-cp313t-win32.whl", hash = "sha256:64b6ca7391a1395c2638dd5c7456d67bea44fc6c5e8e92c5dc8aa6a8f23292b4", size = 269141, upload-time = "2026-07-19T00:18:33.479Z" }, + { url = "https://files.pythonhosted.org/packages/bb/14/961b4c7b05a2391c32dbc85e27773076671ef8f97f36cec70fe414734c02/regex-2026.7.19-cp313-cp313t-win_amd64.whl", hash = "sha256:f04b9f56b0e0614c0126be12c2c2d9f8850c1e57af302bd0a63bed379d4af974", size = 280036, upload-time = "2026-07-19T00:18:35.419Z" }, + { url = "https://files.pythonhosted.org/packages/ce/67/795644550d788ddbb6dc458c95895f8009978ea6d6ea76b005eb3f45e8c9/regex-2026.7.19-cp313-cp313t-win_arm64.whl", hash = "sha256:fcee38cd8e5089d6d4f048ba1233b3ad76e5954f545382180889112ff5cb712d", size = 279394, upload-time = "2026-07-19T00:18:37.454Z" }, + { url = "https://files.pythonhosted.org/packages/d2/25/0c4c452f8ef3efe456745b2f33195f5904b573fb4c2ff3f0cb9ec188461e/regex-2026.7.19-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:a81758ed242b861b72e778ba34d41366441a2e10b16b472784c88da2dea7e2dd", size = 496750, upload-time = "2026-07-19T00:18:39.633Z" }, + { url = "https://files.pythonhosted.org/packages/24/9e/b70ca6c1704f6c7cd32a9e143c86cc5968d10981eca284bad670c245ea7d/regex-2026.7.19-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4aa5435cdb3eb6f55fe98a171b05e3fbcd95fadaa4aa32acf62afd9b0cfdbcac", size = 297093, upload-time = "2026-07-19T00:18:41.583Z" }, + { url = "https://files.pythonhosted.org/packages/87/74/0b692da2520d51fbff19c88b83d97e4c702909dd02386c585998b7e2dbed/regex-2026.7.19-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:60be8693a1dadc210bbcbc0db3e26da5f7d01d1d5a3da594e99b4fa42df404f5", size = 292043, upload-time = "2026-07-19T00:18:43.347Z" }, + { url = "https://files.pythonhosted.org/packages/e3/a7/1d478e614016045a33feae57446215f9fd65b665a5ceb2f891fb3183bc52/regex-2026.7.19-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19662dbedbe783d323196312d38f5ba53cf56296378252171985da6899887d3", size = 797214, upload-time = "2026-07-19T00:18:45.362Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ae/11b9c9411d92c30e3d2db32df5a31133e4a99a8fc397a604fd08f6c4bffb/regex-2026.7.19-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d15df07081d91b76ff20d43f94592ee110330152d617b730fdbe5ef9fb680053", size = 866433, upload-time = "2026-07-19T00:18:47.315Z" }, + { url = "https://files.pythonhosted.org/packages/b1/62/2b2efc4992f91d6d204b24c647c9f9412e85379d92b7c0ab9fdae622327e/regex-2026.7.19-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:56ad4d9f77df871a99e25c37091052a02528ec0eb059de928ee33956b854b45b", size = 911360, upload-time = "2026-07-19T00:18:49.588Z" }, + { url = "https://files.pythonhosted.org/packages/14/71/986ceea9aa3da548bf1357cad89b63915ec6d21ec957c8113b29ece567df/regex-2026.7.19-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7322ec6cc9fba9d49ab888bb82d67ac5625627aa168f0165139b17018df3fb8a", size = 801275, upload-time = "2026-07-19T00:18:51.767Z" }, + { url = "https://files.pythonhosted.org/packages/15/be/ce9d9534b2cda96eab32c548261224b9b4e220a4126f098f60f42ae7b4cd/regex-2026.7.19-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9c7472192ebfad53a6be7c4a8bfb2d64b81c0e93a1fc8c57e1dd0b638297b5d1", size = 777131, upload-time = "2026-07-19T00:18:54.053Z" }, + { url = "https://files.pythonhosted.org/packages/61/2b/58b5c710f2c3929515a25f3a1ca0dad0dcd4518d4fff3cf23bc7adb8dcd2/regex-2026.7.19-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c10b82c2634df08dfb13b1f04e38fe310d086ee092f4f69c0c8da234251e556e", size = 785020, upload-time = "2026-07-19T00:18:56.579Z" }, + { url = "https://files.pythonhosted.org/packages/84/03/5fe091935b74f15fe0f97998c215cae418d1c0413f6258c7d4d2e83aa37f/regex-2026.7.19-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:17ed5692f6acc4183e98331101a5f9e4f64d72fe58b753da4d444a2c77d05b12", size = 861263, upload-time = "2026-07-19T00:18:58.64Z" }, + { url = "https://files.pythonhosted.org/packages/d8/fa/d60bf82e10841eef62a9e32aac401468f05fddfbcb2942e342b1ba3d2433/regex-2026.7.19-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:22a992de9a0d91bda927bf02b94351d737a0302905432c88a53de7c4b9ce62e2", size = 766199, upload-time = "2026-07-19T00:19:00.705Z" }, + { url = "https://files.pythonhosted.org/packages/bf/5d/11e64d151b0662b81d6bf644c74dc118d461df85bdf2577fadbbf751788a/regex-2026.7.19-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:618a0aed532be87294c4477b0481f3aa0f1520f4014a4374dd4cf789b4cd2c97", size = 851317, upload-time = "2026-07-19T00:19:03.015Z" }, + { url = "https://files.pythonhosted.org/packages/7c/34/532efb87488d90807bae6a443d357ee5e2728a478c597619c8aaa17cc0bd/regex-2026.7.19-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2ce9e679f776649746729b6c86382da519ef649c8e34cc41df0d2e5e0f6c36d4", size = 789557, upload-time = "2026-07-19T00:19:05.338Z" }, + { url = "https://files.pythonhosted.org/packages/d6/90/3a8d5ca977171ec3ae21a71207d2228b2663bde14d7f7ef0e6363ecf9290/regex-2026.7.19-cp314-cp314-win32.whl", hash = "sha256:73f272fba87b8ccfe70a137d02a54af386f6d27aa509fbffdd978f5947aae1aa", size = 272531, upload-time = "2026-07-19T00:19:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/96/e1/8862885e70409de70e8c005f57fb2e7be8d9ef0317250d60f4c9660a300d/regex-2026.7.19-cp314-cp314-win_amd64.whl", hash = "sha256:d721e53758b2cca74990185eb0671dd466d7a388a1a45d0c6f4c13cef41a68ac", size = 280831, upload-time = "2026-07-19T00:19:09.46Z" }, + { url = "https://files.pythonhosted.org/packages/08/82/2693e53e29f9104d9de95d37ce4dd826bd32d5f9c0085d3aa6ac042675c4/regex-2026.7.19-cp314-cp314-win_arm64.whl", hash = "sha256:65fa6cb38ed5e9c3637e68e544f598b39c3b86b808ed0627a67b68320384b459", size = 281099, upload-time = "2026-07-19T00:19:11.398Z" }, + { url = "https://files.pythonhosted.org/packages/92/b7/9a01aa16461a18cde9d7b9c3ab21e501db2ce33725f53014342b91df2b0a/regex-2026.7.19-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:5a2721c8720e2cb3c209925dfb9200199b4b07361c9e01d321719404b21458b3", size = 501121, upload-time = "2026-07-19T00:19:13.425Z" }, + { url = "https://files.pythonhosted.org/packages/f3/5e/bbaeca815dc9191c424c94a4fdc5c87c75748a64a6271821212ebdd4e1a3/regex-2026.7.19-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:199535629f25caf89698039af3d1ad5fcae7f933e2112c73f1cdf49165c99518", size = 299415, upload-time = "2026-07-19T00:19:15.43Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d6/0dd1a321afaab95eb7ff44aa0f637301786f1dc71c6b797b9ed236ed8890/regex-2026.7.19-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9b60d7814174f059e5de4ab98271cc5ba9259cfea55273a81544dceea32dc8d9", size = 294483, upload-time = "2026-07-19T00:19:17.879Z" }, + { url = "https://files.pythonhosted.org/packages/92/5f/40bacf91d0904f812e13bbbab3864604c463eced8afdc54aeaa50492ea95/regex-2026.7.19-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbece16025afda5e3031af0c4059207e61dcf73ef13af844964f57f387d1c435", size = 811833, upload-time = "2026-07-19T00:19:20.102Z" }, + { url = "https://files.pythonhosted.org/packages/94/7c/4902744261f775aeede8b5627314b38482da29cf49a57b66a6fb753246c5/regex-2026.7.19-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d24ecb4f5e009ea0bd275ee37ad9953b32005e2e5e60f8bbae16da0dbbf0d3a0", size = 871270, upload-time = "2026-07-19T00:19:22.365Z" }, + { url = "https://files.pythonhosted.org/packages/16/70/6980c9be6bf21c0a60ed3e0aea39cf419ecf3b08d1d9947bc56e196ef186/regex-2026.7.19-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8cae6fd77a5b72dae505084b1a2ee0360139faf72fedbab667cd7cc65aae7a6a", size = 917534, upload-time = "2026-07-19T00:19:24.529Z" }, + { url = "https://files.pythonhosted.org/packages/52/92/8b2bd872782ce8c42691e39acb38eb8efe014e5ddb78ad7d943d6f197ce9/regex-2026.7.19-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9724e6cb5e478cd7d8cabf027826178739cb18cf0e117d0e32814d479fa02276", size = 816135, upload-time = "2026-07-19T00:19:26.919Z" }, + { url = "https://files.pythonhosted.org/packages/de/2d/33a602f657bdc4041f17d79f92ab18261d255d91a06117a6e29df023e5e2/regex-2026.7.19-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:572fc57b0009c735ee56c175ea021b637a15551a312f56734277f923d6fd0f6c", size = 785492, upload-time = "2026-07-19T00:19:29.192Z" }, + { url = "https://files.pythonhosted.org/packages/9e/36/0987cf4cb271680064a70d24a475873775a151d0b7058698a006cb0cae4a/regex-2026.7.19-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:20568e182eb82d39a6bf7cff3fd58566f14c75c6f74b2c8c96537eecf9010e3a", size = 800658, upload-time = "2026-07-19T00:19:31.392Z" }, + { url = "https://files.pythonhosted.org/packages/a8/24/c14f31c135e1ba55fa4f9a58ca98d0842512bf6188230763c31c8f449e3b/regex-2026.7.19-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:1d58561843f0ff7dc78b4c28b5e2dc388f3eff94ebc8a232a3adba961fc00009", size = 865073, upload-time = "2026-07-19T00:19:33.485Z" }, + { url = "https://files.pythonhosted.org/packages/14/85/181a12211f22469f24d2de1ebddfe397d2396e2c29013b9a58134a91069a/regex-2026.7.19-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:61bb1bd45520aacd56dd80943bd34991fb5350afdd1f36f2282230fd5154a218", size = 773684, upload-time = "2026-07-19T00:19:35.599Z" }, + { url = "https://files.pythonhosted.org/packages/23/58/bd1a0c1a62251366f8d21f41b1ea3c76994962071b8b6ea42f72d505c0f0/regex-2026.7.19-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:cd3584591ea4429026cdb931b054342c2bcf189b44ff367f8d5c15bc092a2966", size = 857769, upload-time = "2026-07-19T00:19:37.738Z" }, + { url = "https://files.pythonhosted.org/packages/e4/4f/f7e2dad6756b2fe1fe75dd90a628c3b45f249d39f948dd90cd2476325417/regex-2026.7.19-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5cc26a66e212fa5d6c6170c3a40d99d888db3020c6fdab1523250d4341382e44", size = 804546, upload-time = "2026-07-19T00:19:40.229Z" }, + { url = "https://files.pythonhosted.org/packages/2b/d7/01d31d5bdb09bc026fab77f59a371fdf8f9b292e4810546c56182ca70498/regex-2026.7.19-cp314-cp314t-win32.whl", hash = "sha256:2c4e61e2e1be56f63ec3cc618aa9e0de81ef6f43d177205451840022e24f5b78", size = 274526, upload-time = "2026-07-19T00:19:42.398Z" }, + { url = "https://files.pythonhosted.org/packages/52/0e/cea4ce73bc0a8247a0748228ae6669984c7e1f8134b6fa66e59c0572e0ea/regex-2026.7.19-cp314-cp314t-win_amd64.whl", hash = "sha256:c639ea314df70a7b2811e8020448c75af8c9445f5a60f8a4ced81c306a9380c2", size = 283763, upload-time = "2026-07-19T00:19:44.644Z" }, + { url = "https://files.pythonhosted.org/packages/6f/b6/26e41975febae63b7a6e3e02f32cff6cff2e4f10d19c929082f56aebf7c6/regex-2026.7.19-cp314-cp314t-win_arm64.whl", hash = "sha256:9a15e785f244f3e07847b984ce8773fc3da10a9f3c131cc49a4c5b4d672b4547", size = 283451, upload-time = "2026-07-19T00:19:46.639Z" }, +] + [[package]] name = "requests" version = "2.32.5" @@ -2442,6 +3171,35 @@ version = "0.30.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" }, + { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" }, + { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" }, + { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" }, + { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" }, + { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" }, + { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" }, + { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" }, + { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" }, + { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" }, + { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" }, + { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" }, + { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" }, + { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" }, + { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" }, + { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" }, + { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" }, + { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" }, + { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" }, { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" }, { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" }, { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" }, @@ -2515,6 +3273,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, + { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" }, + { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" }, + { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" }, + { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" }, + { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" }, + { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" }, + { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" }, + { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" }, + { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" }, + { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" }, ] [[package]] @@ -2576,6 +3346,18 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/a9/d3/df796f1b8fa96e3570c57aeefc8b5567cfc6ffbd54855f59e8a9a04c22fd/scylla_driver-3.29.7.tar.gz", hash = "sha256:ba658d386efbe543668667a912d39b7c708ac8977655c9114c9f98f3e0970d1b", size = 303478, upload-time = "2025-12-09T13:37:35.573Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/21/4c/897e57f034302ef3a97fae4814b65fed4a34ebf5e0834c2d2ac2c5bbf5ba/scylla_driver-3.29.7-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:4b6e528bf77859e7c43e7a122af780b28f430924381032cfb7465b73cfdb6546", size = 3133962, upload-time = "2025-12-09T13:36:41.004Z" }, + { url = "https://files.pythonhosted.org/packages/41/ec/240f0d6192918a650797c3f7cf4cef25415a963a1337c7e6c86ed9d0247d/scylla_driver-3.29.7-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:fe8a81bd858356977735888018c6434399cd4a9a238360578404bf577234717c", size = 3495058, upload-time = "2025-12-09T13:36:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/da/b6/0255800e4af84ba77bdcf452ca465809134bd4685af755a5200f76c94f73/scylla_driver-3.29.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d73abd485754a20012f589217c66691bd2aa53d51bbff6cdb8a2f433a1e135aa", size = 3998225, upload-time = "2025-12-09T13:36:43.987Z" }, + { url = "https://files.pythonhosted.org/packages/18/f3/aedd0adf3a174705d6ee19f6fcf11b7b9877a6bfef5b34203685dded48df/scylla_driver-3.29.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50e347979fae76022ffa0f4231755ec0b8d3e0ccbec5d8a7da45e5219813f994", size = 4284057, upload-time = "2025-12-09T13:36:45.417Z" }, + { url = "https://files.pythonhosted.org/packages/85/83/92e8d9af21a31675e09a524e133b149aa5f55fd8f104f73dbf15f923d2b0/scylla_driver-3.29.7-cp310-cp310-win32.whl", hash = "sha256:72ea680b5ae1116887ca05c8adbd9cc162f993a5460fb62701fd435bd32bbae5", size = 2392601, upload-time = "2025-12-09T13:36:46.912Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6c/8468b050fe7c9ce4e1dc9e6684d8f6bf0e90e44e78917a8b22e622e288bb/scylla_driver-3.29.7-cp310-cp310-win_amd64.whl", hash = "sha256:05f6bbc673c7fb0b9dd1786e7a11b880f7340e74b3110b82ed48d944d1654f23", size = 2905386, upload-time = "2025-12-09T13:36:49.017Z" }, + { url = "https://files.pythonhosted.org/packages/fe/b0/4fa7568f951294b9dc9ef19092f384cdc7346362c9ade18a6e0d5f57142c/scylla_driver-3.29.7-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:62a850ab548ce5416c6e9d3a7056c2e179a6bbb07e71f19d59ad427b925c041d", size = 3094594, upload-time = "2025-12-09T13:36:50.618Z" }, + { url = "https://files.pythonhosted.org/packages/20/43/344cf2b54fa33036c94d95def0c22b53af189c3cbf59251a8fcb0583312a/scylla_driver-3.29.7-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:53ff049d8675ba43aa65d07da768ccf9e8cc75829f44dda7950faa0b05781dee", size = 3473784, upload-time = "2025-12-09T13:36:51.947Z" }, + { url = "https://files.pythonhosted.org/packages/47/76/a886e9cb7e4c5e962166d0a3fd9e32b45401198468345a661c88de71aacc/scylla_driver-3.29.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de0a22acb386d2e1f1dd80d0b05f7b5b8ce70253202bb4fd0f591a95f418ba59", size = 3882105, upload-time = "2025-12-09T13:36:53.626Z" }, + { url = "https://files.pythonhosted.org/packages/2a/83/347086e21f1731b08c51e933f3b70ec304fba81394579bf737a64786faa3/scylla_driver-3.29.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6ccfc03f03f619f6bd67e94180ef77dd95fce5803c74db7dc7fe4cc45984fd7c", size = 4141080, upload-time = "2025-12-09T13:36:55.614Z" }, + { url = "https://files.pythonhosted.org/packages/04/5c/f5e3a9d2e5ff49375f6d6f8e39b692dfa981fd387b8271105bafd9f323f7/scylla_driver-3.29.7-cp311-cp311-win32.whl", hash = "sha256:ea0fd2a03724664a1abf5d1d1c471102c469b9d39a0219a996e19db9f4f057e3", size = 2384253, upload-time = "2025-12-09T13:36:57.66Z" }, + { url = "https://files.pythonhosted.org/packages/67/84/b2aeacc8074f82a5b264af8f35dfff31225a6693fd3d8013accbdcba93d1/scylla_driver-3.29.7-cp311-cp311-win_amd64.whl", hash = "sha256:9fe4e0a07b6fc725084f8214e7c814b111847677e6dd1e3e9af3e2bd60b81432", size = 2914541, upload-time = "2025-12-09T13:36:59.358Z" }, { url = "https://files.pythonhosted.org/packages/78/2c/757ea26ba20d41b00f56be4ad2056e78840e5c35530d7bbd14f4df76fbbb/scylla_driver-3.29.7-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:6b68cbb3906e9c5c6a2d00e377337286417933f3964a85fc6d3b6092f62127ac", size = 3140113, upload-time = "2025-12-09T13:37:00.746Z" }, { url = "https://files.pythonhosted.org/packages/77/68/0287cd37ccc7fdebc57e2c3e51addcae02353921e6ab6c676629f1446867/scylla_driver-3.29.7-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:88fbbad56e7b915e666258cf6d8ec41d981e59b04df742920edd9b85eb53f95d", size = 3534985, upload-time = "2025-12-09T13:37:02.135Z" }, { url = "https://files.pythonhosted.org/packages/cc/45/7634772e8fba013b9f9edc7a633260abfb112b4756efe1234bbf8e427a3d/scylla_driver-3.29.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87dcf13b36254e0ceaf1ca70a0c1b55deaa899bdd016b17d7b53bfb4ec24bb91", size = 3664551, upload-time = "2025-12-09T13:37:03.562Z" }, @@ -2594,6 +3376,10 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/48/58cd8a40a18a7fa061bd8c48f7aec5768eb3ef7d1130d7ac4c4c583fb3e3/scylla_driver-3.29.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:68cde7306d5ec5d4061b43c7882539ff2b4b193c14c5e22c6ebbb08618f446b7", size = 3929342, upload-time = "2025-12-09T13:37:24.995Z" }, { url = "https://files.pythonhosted.org/packages/80/e3/cbda4ea6830ef4e8e361bdb74cd82d91cf20c36ed64994099e732fc8435b/scylla_driver-3.29.7-cp314-cp314-win32.whl", hash = "sha256:85cababcdca5e28226e1275988a6123ceddf5c5a9cab70c2ef64bf18f89e2210", size = 2301268, upload-time = "2025-12-09T13:37:26.819Z" }, { url = "https://files.pythonhosted.org/packages/50/64/9749cfbd5375780042ad63a19f9da972efcbcb2f4f783f7a6022e47d2ad1/scylla_driver-3.29.7-cp314-cp314-win_amd64.whl", hash = "sha256:5147346ca1e04855c16a1cb936f16f543c0ba3bffb13bbcccec07adf0857c37e", size = 2803279, upload-time = "2025-12-09T13:37:28.209Z" }, + { url = "https://files.pythonhosted.org/packages/24/ae/8e3e796d118b4bd36ddbd15ee35e8996446405b6c83129204064c86e4507/scylla_driver-3.29.7-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ec078ba75731192399dd059e9ad93d1f3a368553403cf18e7cca497f9879ae86", size = 350478, upload-time = "2025-12-09T13:37:29.607Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e7/0deb868f8217f9194e6242535b71f8eee0b45d8143645a1d175700e15fe1/scylla_driver-3.29.7-pp311-pypy311_pp73-macosx_15_0_x86_64.whl", hash = "sha256:1671ae58f5725610a47d932751a62e2c3e8679d1a09e5c158b57f1a092ef9d95", size = 349985, upload-time = "2025-12-09T13:37:31.702Z" }, + { url = "https://files.pythonhosted.org/packages/68/43/e354fd55969f39191add6b251b9fb8d19c1d4a8f037bb214b17a5c9a404f/scylla_driver-3.29.7-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cfcf8a06b3022bf3d235260e7bc161e56dbefa8bff56e75b10e843145da9bbee", size = 351238, upload-time = "2025-12-09T13:37:33.021Z" }, + { url = "https://files.pythonhosted.org/packages/98/80/d1a1ca79445ca2716cbf0b99dd368b5811e6d251ee9609d7028e94b2a8fb/scylla_driver-3.29.7-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:831e4da1b84235c09bf0c48e9913512143f5705239fe9b2865bdb86265f9c94b", size = 354284, upload-time = "2025-12-09T13:37:34.183Z" }, ] [[package]] @@ -2623,6 +3409,15 @@ 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 = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + [[package]] name = "stack-data" version = "0.6.3" @@ -2679,6 +3474,67 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8", size = 78154, upload-time = "2019-08-30T21:37:03.543Z" }, ] +[[package]] +name = "tiktoken" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "regex" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/e5/5f3cb2159769d0f4324c0e9e87f9de3c4b1cd45848a96b2eb3566ad5ca77/tiktoken-0.13.0.tar.gz", hash = "sha256:c9435714c3a84c2319499de9a300c0e604449dd0799ff246458b3bb6a7f433c1", size = 38986, upload-time = "2026-05-15T04:51:27.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/e3/03c90dadcf5b3f82b83cee9adee60ef666b329c654f58c066af44eae0287/tiktoken-0.13.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:47b1df8d73390a24f94980c75158cdd5c56d256f16d55f30cb49c230caba9ba4", size = 1036627, upload-time = "2026-05-15T04:50:11.229Z" }, + { url = "https://files.pythonhosted.org/packages/5e/30/760463e5b2e8ad2bc229ae0a17ecb06727b6cbc094f08d8f65844315632e/tiktoken-0.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7d40c6c5aab171dcd6eb8455bc567bde404bb9def60cdb8c1299cc782b242bb9", size = 984699, upload-time = "2026-05-15T04:50:12.874Z" }, + { url = "https://files.pythonhosted.org/packages/de/8a/8895f342a6b6aabd1a358e672f6f077b3ae51d0c63ca605d142db3bcd8ab/tiktoken-0.13.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:9b842981fa91accdffd48ff6408a977b7a91c3fbda55d353c3c68114d5c9d69e", size = 1118690, upload-time = "2026-05-15T04:50:14.234Z" }, + { url = "https://files.pythonhosted.org/packages/51/e0/92557768fb0801f0d9dd9243cb9b6d342900b05e4b1006d4771f49ce233e/tiktoken-0.13.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ed5a30027cb4d8c7ca8b273d4766f3db3cf58fad9e9f3b1a68a351ffb54873d5", size = 1138423, upload-time = "2026-05-15T04:50:15.668Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b9/a3d99feeedb032ffd09cd6652077f86bdee9a70dd0b990b2b272b445d4c3/tiktoken-0.13.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7ab10f4a21c2999846940113f6dbd72e0fa06a24119feddd74cc47e85818e06d", size = 1185077, upload-time = "2026-05-15T04:50:17.19Z" }, + { url = "https://files.pythonhosted.org/packages/cc/93/bab868277d475dc6d2aaacd34cdd239c282f4908dcc8702e0a3311a8e032/tiktoken-0.13.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a2937ad042d49d50eac6e1ba07c5661d4bd3942a5b1e0c0d08475c4df83676e1", size = 1241702, upload-time = "2026-05-15T04:50:18.772Z" }, + { url = "https://files.pythonhosted.org/packages/c3/16/27e9f7e0ed76e501cfefc9fb2112df4c7bf70ca96945b15ecb7615aac860/tiktoken-0.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:44733b99bfd72b590cd0936b1c01b3b4dd73122db2d544bc1ceeb18a7678c910", size = 876565, upload-time = "2026-05-15T04:50:20.268Z" }, + { url = "https://files.pythonhosted.org/packages/1a/4c/1bc81f4cd53e827c4ee67ca951b5935724716049452d8dfa09b8b82372bb/tiktoken-0.13.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7bfe1849caa65d1e1d9871817170ec497bbb7984e182012e1bdce72f66608cdb", size = 1036353, upload-time = "2026-05-15T04:50:21.757Z" }, + { url = "https://files.pythonhosted.org/packages/75/91/10b9c7076bc02c246c853201fdbbe300a4b8c5ed7b84c25f7403f4e32655/tiktoken-0.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:91c180fe255bd5a86d8316210d2833a1d4d33d026cd86a67812f4773743c8d26", size = 984644, upload-time = "2026-05-15T04:50:23.256Z" }, + { url = "https://files.pythonhosted.org/packages/4e/e4/fceae98015fab47fcd49b8bd7f46145bcd187a47e0add1e5378ed67ef980/tiktoken-0.13.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:059c8ecf554eb5b41e6e054ba467b871b03277d267dee7244380aca4359747d4", size = 1119261, upload-time = "2026-05-15T04:50:24.348Z" }, + { url = "https://files.pythonhosted.org/packages/f9/39/fe42ad00de01a8c4a49ad8649a2c8a316835a9cad5961b11d21eac0020a5/tiktoken-0.13.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:36217497eaffc158607a3b26f065300db2aefd43b115263f3b9688ce38146173", size = 1138253, upload-time = "2026-05-15T04:50:25.505Z" }, + { url = "https://files.pythonhosted.org/packages/03/c4/ccee1ecccca107e9a16efcecdeeb964c325305038554d466ece65b42338f/tiktoken-0.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:303f7d91b4fce3baddbcde05c139091d4caa5026ac7214c1dc7ff7a71ee429ff", size = 1185747, upload-time = "2026-05-15T04:50:27.02Z" }, + { url = "https://files.pythonhosted.org/packages/9d/03/cd0cba295522b91eb55c6b2704f1df895f8226cfe60ab10d4d51d0cc9e69/tiktoken-0.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5d48843bee149630eb735a99e1f4a85b47308d21868ea63163f6e87768d3cfed", size = 1241265, upload-time = "2026-05-15T04:50:28.815Z" }, + { url = "https://files.pythonhosted.org/packages/7e/25/a10efd564402d82c2ff50d12057353ace447aa8007deceaa48641f63d35c/tiktoken-0.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:fc1c44cd37b43fc46bae593129164f4f281e82ea116b57a85aa81bda57eafc94", size = 876509, upload-time = "2026-05-15T04:50:30.026Z" }, + { url = "https://files.pythonhosted.org/packages/85/8e/144bde4e01df66b34bb865557c7cd754ed08b036217ebd79c9db5e9048a9/tiktoken-0.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:32ac870a806cfb260a02d0cb70426aef02e038297f8ad50df5040bb5af360791", size = 1034888, upload-time = "2026-05-15T04:50:31.579Z" }, + { url = "https://files.pythonhosted.org/packages/36/18/d4ac9d20956cdebca04841316660ed584c2fecdc2b81722a28bc7ad3b1e4/tiktoken-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4d9980f11429ed2d737c463bb1fb78cf330caa026adf002f714aced7849a687b", size = 982970, upload-time = "2026-05-15T04:50:32.961Z" }, + { url = "https://files.pythonhosted.org/packages/74/ed/6bb8d05b9f731f749fee5c6f5ca63e981143c826a5985877330507bd13b7/tiktoken-0.13.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3f277ebea5edd7b8bf03c6f9431e1d67d517530115572b2dc1d465326e8f88c7", size = 1115741, upload-time = "2026-05-15T04:50:34.475Z" }, + { url = "https://files.pythonhosted.org/packages/34/de/2ca96b07a82d972b74fe4b46de055b79c904e45c7eab699354a0bfa697dc/tiktoken-0.13.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:a116178fa7e1b4065bff05214360373a65cac22f965be7b3f73d00a0dbfe7649", size = 1136523, upload-time = "2026-05-15T04:50:35.782Z" }, + { url = "https://files.pythonhosted.org/packages/ee/dc/9dafec002c2d4424378563cf4cf5c7fb93631d2a55013c8b87554ee4012c/tiktoken-0.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c397ddda233208345b01bd30f2fca79ff730e55731d0108a603f9bc57f6af3b", size = 1181954, upload-time = "2026-05-15T04:50:36.99Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d0/1f8578c45b2f24759b46f0b50d31878c63c73e6bf0f2227e10ec5c5408dc/tiktoken-0.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:95097e4f89b06403976e498abf61a0ee73a7497e73fb599cb211d8197a054d91", size = 1240069, upload-time = "2026-05-15T04:50:38.221Z" }, + { url = "https://files.pythonhosted.org/packages/aa/90/28d7f154888610aa9237e541986beb62b479df29d193a5a0617dbb1514d0/tiktoken-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:8f2d16e7a7c783ad81f36e457d046d1f1c8af70b22aec8a13238efe531977c41", size = 874748, upload-time = "2026-05-15T04:50:39.587Z" }, + { url = "https://files.pythonhosted.org/packages/9c/83/b096c859c2a47c11731bf2f5885f4028b809dfe2396582883eed9cae372f/tiktoken-0.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5df5d1507bd245f1ccad4a074698240021239e455eb0bb4ced4e3d7181872154", size = 1034228, upload-time = "2026-05-15T04:50:40.988Z" }, + { url = "https://files.pythonhosted.org/packages/53/61/c68e123b6d753e3fc2751e9b18e732c9d8bf1e1926762e736eee935d931c/tiktoken-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8fe806a50664e83a6ffd56cbd1e4f5dcc6cd32a3e7538f70dc38b1a271384545", size = 982978, upload-time = "2026-05-15T04:50:42.195Z" }, + { url = "https://files.pythonhosted.org/packages/ef/8b/96cc178cc584e65d363134500f297790b06cd48cdeb1e8fcf7bbe60f4715/tiktoken-0.13.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:125bc05005e747f993a83dc67934249932d6e4209854452cd4c0b1d53fba3ba2", size = 1116355, upload-time = "2026-05-15T04:50:43.564Z" }, + { url = "https://files.pythonhosted.org/packages/86/f5/bab735d2c72ea55404b295d02d092644eb5f7cc6205e34d35eb9abfb9ab2/tiktoken-0.13.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5e6358911cab4adee6712da27d65573496a4f68cf8a2b5fca6a4ad10fc5748cf", size = 1135772, upload-time = "2026-05-15T04:50:44.782Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b9/6de04ebdf904edfaad87788011b3735087a0c9ea671b9027e1e4e965e8c8/tiktoken-0.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:975cbd78d085d75d26b59660e262736dcaed1e35f8f142cd6291025c01d25486", size = 1182415, upload-time = "2026-05-15T04:50:46.422Z" }, + { url = "https://files.pythonhosted.org/packages/0d/9c/470a05f3b1caf038f44880e334d47ab674e0c80d514c66b375d14d5afa10/tiktoken-0.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:75ab9bc99fa020a4c283424590ecd7f3afd70c1c281cb3fa3192a6c3af9f9615", size = 1239879, upload-time = "2026-05-15T04:50:48.052Z" }, + { url = "https://files.pythonhosted.org/packages/42/a6/c1936d16055436cb32e6c6128d68629622e00f4768562f55653752d34768/tiktoken-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:6b1615f0ff71953d19729ceb18865429c185b0a23c5353f1bbca34a394bf60f7", size = 874829, upload-time = "2026-05-15T04:50:49.202Z" }, + { url = "https://files.pythonhosted.org/packages/d6/07/acb5992c3772b5a36284f742cfb7a5895aa4471d1848ac31464ad50d7fdf/tiktoken-0.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6eb4a5bfbc6426938026b1a334e898ac53541360d62d8c689870160cc80abd67", size = 1033600, upload-time = "2026-05-15T04:50:50.4Z" }, + { url = "https://files.pythonhosted.org/packages/14/e9/742e9aec30f59b9f161f7ff7cd072e02ea836c9e1c0854a8076dfcd40d5c/tiktoken-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:43cee3e5400573b2046fbf092cc7a5bc30164f9e4c95ce20714da929df48737a", size = 982516, upload-time = "2026-05-15T04:50:52.03Z" }, + { url = "https://files.pythonhosted.org/packages/72/74/ca1541b053e7648254d2e4b42a253e1bb4359f2c91a0a8d49228c794e1a0/tiktoken-0.13.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:7de52e3f566d19b3b11bd37eea552c6c305ad74081f736882bd44d148ed4c48d", size = 1115518, upload-time = "2026-05-15T04:50:53.543Z" }, + { url = "https://files.pythonhosted.org/packages/46/e3/93825eaf5a4a504795b787e5d5dea07fbeb3dabf97aa7b450be8bde59c89/tiktoken-0.13.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:51384448aa508e4df84c0f7c1dc3211c7f7b8096325660ee5fc82f3e11b381ce", size = 1136867, upload-time = "2026-05-15T04:50:55.191Z" }, + { url = "https://files.pythonhosted.org/packages/8c/46/002b68de6827091d5ae90b048f326e8aad8d953520950e5ce1508879414f/tiktoken-0.13.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e28157350f7ebf35008dd8e9e0fdb621f976e4230c881099c85e8cf07eaa50e2", size = 1181826, upload-time = "2026-05-15T04:50:56.296Z" }, + { url = "https://files.pythonhosted.org/packages/db/c6/d393e3185a276505182f7abd93fe714f3c444a2be9180798fa052347504e/tiktoken-0.13.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:165cf1820ea4a354985c2490a5205d4cc74661c934aca79dd0368232fff94e0f", size = 1239489, upload-time = "2026-05-15T04:50:57.918Z" }, + { url = "https://files.pythonhosted.org/packages/b7/4d/bc07d1f1635d4897a202acc0ae11c2886eaa7325c359ba4741b47bf8e225/tiktoken-0.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6c43a675ca14f6f2749ba7f12075d37456015a24b859f2517b9beb4ef30807ec", size = 873820, upload-time = "2026-05-15T04:50:59.528Z" }, + { url = "https://files.pythonhosted.org/packages/8c/93/0dd6adca026a616c3a92974566b43381eea4b475ce1f36c062b8271a9ac5/tiktoken-0.13.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaaaef47c2406277181d2086484c317bf7fc433e2d5d03ff94f56b0dcec87471", size = 1034977, upload-time = "2026-05-15T04:51:00.957Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5ec6e6bc5b30bed6d93f7f2162d8f6b32437b3ba27cb527cfe004f6109c9/tiktoken-0.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ca8b310bd93b3772cb1b7922d915446864860f562bdfe4825c63a0aed3fb28cd", size = 983635, upload-time = "2026-05-15T04:51:02.629Z" }, + { url = "https://files.pythonhosted.org/packages/94/b0/c8ae9aff00d625c50659b4513e707a0462c4bf5d4d6cc1b802103225c02e/tiktoken-0.13.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:32e0c12305105002c047b3bb1070b0dd9a73b0cb3b2856a8972b810e7a4f5881", size = 1116036, upload-time = "2026-05-15T04:51:04.082Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ac/6a5dddd1d0a6018ecb389bd0353e6b4a515eb4d2286611bd0ace1937b9e1/tiktoken-0.13.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:5ba5fd62507a932d1241346179e3b39bc7bf7408f03c272652d93b3bedf5db24", size = 1135544, upload-time = "2026-05-15T04:51:05.229Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b8/585032b4384b2f7dcdaddcb52865c83a701a420d09e3c2b4a2be1c450c57/tiktoken-0.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d108bc2d470fc53c8ecd24f2c0fd2b5f98c33e87cdb6aa2e9b8c5dced703d273", size = 1182217, upload-time = "2026-05-15T04:51:06.517Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b6/993ff1ded3958215fd341a847b8e5ffeb5de473f435296870d314fc91ac4/tiktoken-0.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cb99cb5127449f58d0a2d5f5ccfb390d8dbdfd919c221246caaee29d8725ed51", size = 1239404, upload-time = "2026-05-15T04:51:07.843Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3d/fef7e06e3b33e7538db0ced734cf9fe23b6832d2ac4990c119c377aec55e/tiktoken-0.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:115c4f26ffa11caac8b54eea35c2ad38c612c20a48d35dd15d70a02ac6f51f58", size = 918686, upload-time = "2026-05-15T04:51:08.925Z" }, + { url = "https://files.pythonhosted.org/packages/c1/82/a7fc44582bc32ab00de988a2299bf77c077f59068b233109e34b7d6ca7e6/tiktoken-0.13.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:472527e9132952f2fbf77cd290658bacf003d4d5a3fabc18e5fbd407cbae4d9b", size = 1034454, upload-time = "2026-05-15T04:51:10.035Z" }, + { url = "https://files.pythonhosted.org/packages/37/d0/24d8a890c14f432a05cea669c17bebeaa99f96a7c79523b590f564246411/tiktoken-0.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4e2f67d27c9626cdd25fe33d9313c5cdb3d8d82da646b68d6eb8e7e9c20e6448", size = 982976, upload-time = "2026-05-15T04:51:11.23Z" }, + { url = "https://files.pythonhosted.org/packages/49/b7/2ab43f62788a9266187a9bfc1d3af99ad83e5eaa25fbef168a69cd5ad14f/tiktoken-0.13.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:2b920b35805cd64585a37c3dc7ce65fba4d2d36016be01e1d7942482ca29093a", size = 1115526, upload-time = "2026-05-15T04:51:12.608Z" }, + { url = "https://files.pythonhosted.org/packages/64/39/1494321ed323ce7a14d88e3cd6cb9058625977df1c6961ddc492bd10a9f3/tiktoken-0.13.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:493af3aa28a4aaf2e3d2600a2ee717252c9bf5ab38fff94eb5a02db5ab77e5ad", size = 1136466, upload-time = "2026-05-15T04:51:13.926Z" }, + { url = "https://files.pythonhosted.org/packages/96/d9/dfd086aa2d918c563a140720e0ce296cada1634efd2783d5cf51e05f984e/tiktoken-0.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6644c9c2b5cf3916f5a3641d7d12fdb3f006a7b3d9ff6acdaec44e29ab1ff91e", size = 1181863, upload-time = "2026-05-15T04:51:15.025Z" }, + { url = "https://files.pythonhosted.org/packages/2f/68/a18b4f307086954fdae32714cb4f85562e34f9d34ab206e61f1816aa6018/tiktoken-0.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5cb65b60b9408563676d874a3a4ee573370066f0dc4e29d84e82e989c6517424", size = 1239218, upload-time = "2026-05-15T04:51:16.103Z" }, + { url = "https://files.pythonhosted.org/packages/16/5b/f2aa703a4fc5d2dff73460a7d46cc2f3f44aa0f3dd8eeb20d2a0ecf68862/tiktoken-0.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:85b78cc3a2c3d48723ca751fa981f1fedccd54194ca0471b957364353a898b07", size = 918110, upload-time = "2026-05-15T04:51:17.237Z" }, +] + [[package]] name = "tokenizers" version = "0.22.2" @@ -2703,6 +3559,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" }, { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" }, { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" }, + { url = "https://files.pythonhosted.org/packages/84/04/655b79dbcc9b3ac5f1479f18e931a344af67e5b7d3b251d2dcdcd7558592/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4", size = 3282301, upload-time = "2026-01-05T10:40:34.858Z" }, + { url = "https://files.pythonhosted.org/packages/46/cd/e4851401f3d8f6f45d8480262ab6a5c8cb9c4302a790a35aa14eeed6d2fd/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c", size = 3161308, upload-time = "2026-01-05T10:40:40.737Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6e/55553992a89982cd12d4a66dddb5e02126c58677ea3931efcbe601d419db/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195", size = 3718964, upload-time = "2026-01-05T10:40:46.56Z" }, + { url = "https://files.pythonhosted.org/packages/59/8c/b1c87148aa15e099243ec9f0cf9d0e970cc2234c3257d558c25a2c5304e6/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5", size = 3373542, upload-time = "2026-01-05T10:40:52.803Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { 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]] @@ -2809,6 +3723,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "h11" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" } wheels = [ @@ -2832,6 +3747,18 @@ version = "0.22.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/14/ecceb239b65adaaf7fde510aa8bd534075695d1e5f8dadfa32b5723d9cfb/uvloop-0.22.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ef6f0d4cc8a9fa1f6a910230cd53545d9a14479311e87e3cb225495952eb672c", size = 1343335, upload-time = "2025-10-16T22:16:11.43Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ae/6f6f9af7f590b319c94532b9567409ba11f4fa71af1148cab1bf48a07048/uvloop-0.22.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7cd375a12b71d33d46af85a3343b35d98e8116134ba404bd657b3b1d15988792", size = 742903, upload-time = "2025-10-16T22:16:12.979Z" }, + { url = "https://files.pythonhosted.org/packages/09/bd/3667151ad0702282a1f4d5d29288fce8a13c8b6858bf0978c219cd52b231/uvloop-0.22.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac33ed96229b7790eb729702751c0e93ac5bc3bcf52ae9eccbff30da09194b86", size = 3648499, upload-time = "2025-10-16T22:16:14.451Z" }, + { url = "https://files.pythonhosted.org/packages/b3/f6/21657bb3beb5f8c57ce8be3b83f653dd7933c2fd00545ed1b092d464799a/uvloop-0.22.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:481c990a7abe2c6f4fc3d98781cc9426ebd7f03a9aaa7eb03d3bfc68ac2a46bd", size = 3700133, upload-time = "2025-10-16T22:16:16.272Z" }, + { url = "https://files.pythonhosted.org/packages/09/e0/604f61d004ded805f24974c87ddd8374ef675644f476f01f1df90e4cdf72/uvloop-0.22.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a592b043a47ad17911add5fbd087c76716d7c9ccc1d64ec9249ceafd735f03c2", size = 3512681, upload-time = "2025-10-16T22:16:18.07Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ce/8491fd370b0230deb5eac69c7aae35b3be527e25a911c0acdffb922dc1cd/uvloop-0.22.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1489cf791aa7b6e8c8be1c5a080bae3a672791fcb4e9e12249b05862a2ca9cec", size = 3615261, upload-time = "2025-10-16T22:16:19.596Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" }, + { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" }, + { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" }, + { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" }, + { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" }, + { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" }, { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" }, { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" }, { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" }, @@ -2872,6 +3799,7 @@ dependencies = [ { name = "distlib" }, { name = "filelock" }, { name = "platformdirs" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/aa/a3/4d310fa5f00863544e1d0f4de93bddec248499ccf97d4791bc3122c9d4f3/virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba", size = 6032239, upload-time = "2026-01-09T18:21:01.296Z" } wheels = [ @@ -2887,6 +3815,31 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/1a/206e8cf2dd86fddf939165a57b4df61607a1e0add2785f170a3f616b7d9f/watchfiles-1.1.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:eef58232d32daf2ac67f42dea51a2c80f0d03379075d44a587051e63cc2e368c", size = 407318, upload-time = "2025-10-14T15:04:18.753Z" }, + { url = "https://files.pythonhosted.org/packages/b3/0f/abaf5262b9c496b5dad4ed3c0e799cbecb1f8ea512ecb6ddd46646a9fca3/watchfiles-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:03fa0f5237118a0c5e496185cafa92878568b652a2e9a9382a5151b1a0380a43", size = 394478, upload-time = "2025-10-14T15:04:20.297Z" }, + { url = "https://files.pythonhosted.org/packages/b1/04/9cc0ba88697b34b755371f5ace8d3a4d9a15719c07bdc7bd13d7d8c6a341/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ca65483439f9c791897f7db49202301deb6e15fe9f8fe2fed555bf986d10c31", size = 449894, upload-time = "2025-10-14T15:04:21.527Z" }, + { url = "https://files.pythonhosted.org/packages/d2/9c/eda4615863cd8621e89aed4df680d8c3ec3da6a4cf1da113c17decd87c7f/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f0ab1c1af0cb38e3f598244c17919fb1a84d1629cc08355b0074b6d7f53138ac", size = 459065, upload-time = "2025-10-14T15:04:22.795Z" }, + { url = "https://files.pythonhosted.org/packages/84/13/f28b3f340157d03cbc8197629bc109d1098764abe1e60874622a0be5c112/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3bc570d6c01c206c46deb6e935a260be44f186a2f05179f52f7fcd2be086a94d", size = 488377, upload-time = "2025-10-14T15:04:24.138Z" }, + { url = "https://files.pythonhosted.org/packages/86/93/cfa597fa9389e122488f7ffdbd6db505b3b915ca7435ecd7542e855898c2/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e84087b432b6ac94778de547e08611266f1f8ffad28c0ee4c82e028b0fc5966d", size = 595837, upload-time = "2025-10-14T15:04:25.057Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/68c1ed5652b48d89fc24d6af905d88ee4f82fa8bc491e2666004e307ded1/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:620bae625f4cb18427b1bb1a2d9426dc0dd5a5ba74c7c2cdb9de405f7b129863", size = 473456, upload-time = "2025-10-14T15:04:26.497Z" }, + { url = "https://files.pythonhosted.org/packages/d5/dc/1a680b7458ffa3b14bb64878112aefc8f2e4f73c5af763cbf0bd43100658/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:544364b2b51a9b0c7000a4b4b02f90e9423d97fbbf7e06689236443ebcad81ab", size = 455614, upload-time = "2025-10-14T15:04:27.539Z" }, + { url = "https://files.pythonhosted.org/packages/61/a5/3d782a666512e01eaa6541a72ebac1d3aae191ff4a31274a66b8dd85760c/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bbe1ef33d45bc71cf21364df962af171f96ecaeca06bd9e3d0b583efb12aec82", size = 630690, upload-time = "2025-10-14T15:04:28.495Z" }, + { url = "https://files.pythonhosted.org/packages/9b/73/bb5f38590e34687b2a9c47a244aa4dd50c56a825969c92c9c5fc7387cea1/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1a0bb430adb19ef49389e1ad368450193a90038b5b752f4ac089ec6942c4dff4", size = 622459, upload-time = "2025-10-14T15:04:29.491Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ac/c9bb0ec696e07a20bd58af5399aeadaef195fb2c73d26baf55180fe4a942/watchfiles-1.1.1-cp310-cp310-win32.whl", hash = "sha256:3f6d37644155fb5beca5378feb8c1708d5783145f2a0f1c4d5a061a210254844", size = 272663, upload-time = "2025-10-14T15:04:30.435Z" }, + { url = "https://files.pythonhosted.org/packages/11/a0/a60c5a7c2ec59fa062d9a9c61d02e3b6abd94d32aac2d8344c4bdd033326/watchfiles-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a36d8efe0f290835fd0f33da35042a1bb5dc0e83cbc092dcf69bce442579e88e", size = 287453, upload-time = "2025-10-14T15:04:31.53Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" }, + { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" }, + { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" }, + { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" }, + { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" }, + { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" }, + { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" }, + { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" }, + { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" }, { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" }, { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" }, { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" }, @@ -2946,6 +3899,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" }, { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" }, { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4c/a888c91e2e326872fa4705095d64acd8aa2fb9c1f7b9bd0588f33850516c/watchfiles-1.1.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:17ef139237dfced9da49fb7f2232c86ca9421f666d78c264c7ffca6601d154c3", size = 409611, upload-time = "2025-10-14T15:06:05.809Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/5420d1943c8e3ce1a21c0a9330bcf7edafb6aa65d26b21dbb3267c9e8112/watchfiles-1.1.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:672b8adf25b1a0d35c96b5888b7b18699d27d4194bac8beeae75be4b7a3fc9b2", size = 396889, upload-time = "2025-10-14T15:06:07.035Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e5/0072cef3804ce8d3aaddbfe7788aadff6b3d3f98a286fdbee9fd74ca59a7/watchfiles-1.1.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a13aea58bc2b90173bc69f2a90de8e282648939a00a602e1dc4ee23e26b66d", size = 451616, upload-time = "2025-10-14T15:06:08.072Z" }, + { url = "https://files.pythonhosted.org/packages/83/4e/b87b71cbdfad81ad7e83358b3e447fedd281b880a03d64a760fe0a11fc2e/watchfiles-1.1.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b495de0bb386df6a12b18335a0285dda90260f51bdb505503c02bcd1ce27a8b", size = 458413, upload-time = "2025-10-14T15:06:09.209Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" }, + { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" }, + { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" }, ] [[package]] @@ -2972,6 +3933,24 @@ version = "16.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/20/74/221f58decd852f4b59cc3354cccaf87e8ef695fede361d03dc9a7396573b/websockets-16.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:04cdd5d2d1dacbad0a7bf36ccbcd3ccd5a30ee188f2560b7a62a30d14107b31a", size = 177343, upload-time = "2026-01-10T09:22:21.28Z" }, + { url = "https://files.pythonhosted.org/packages/19/0f/22ef6107ee52ab7f0b710d55d36f5a5d3ef19e8a205541a6d7ffa7994e5a/websockets-16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8ff32bb86522a9e5e31439a58addbb0166f0204d64066fb955265c4e214160f0", size = 175021, upload-time = "2026-01-10T09:22:22.696Z" }, + { url = "https://files.pythonhosted.org/packages/10/40/904a4cb30d9b61c0e278899bf36342e9b0208eb3c470324a9ecbaac2a30f/websockets-16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:583b7c42688636f930688d712885cf1531326ee05effd982028212ccc13e5957", size = 175320, upload-time = "2026-01-10T09:22:23.94Z" }, + { url = "https://files.pythonhosted.org/packages/9d/2f/4b3ca7e106bc608744b1cdae041e005e446124bebb037b18799c2d356864/websockets-16.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7d837379b647c0c4c2355c2499723f82f1635fd2c26510e1f587d89bc2199e72", size = 183815, upload-time = "2026-01-10T09:22:25.469Z" }, + { url = "https://files.pythonhosted.org/packages/86/26/d40eaa2a46d4302becec8d15b0fc5e45bdde05191e7628405a19cf491ccd/websockets-16.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df57afc692e517a85e65b72e165356ed1df12386ecb879ad5693be08fac65dde", size = 185054, upload-time = "2026-01-10T09:22:27.101Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ba/6500a0efc94f7373ee8fefa8c271acdfd4dca8bd49a90d4be7ccabfc397e/websockets-16.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2b9f1e0d69bc60a4a87349d50c09a037a2607918746f07de04df9e43252c77a3", size = 184565, upload-time = "2026-01-10T09:22:28.293Z" }, + { url = "https://files.pythonhosted.org/packages/04/b4/96bf2cee7c8d8102389374a2616200574f5f01128d1082f44102140344cc/websockets-16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:335c23addf3d5e6a8633f9f8eda77efad001671e80b95c491dd0924587ece0b3", size = 183848, upload-time = "2026-01-10T09:22:30.394Z" }, + { url = "https://files.pythonhosted.org/packages/02/8e/81f40fb00fd125357814e8c3025738fc4ffc3da4b6b4a4472a82ba304b41/websockets-16.0-cp310-cp310-win32.whl", hash = "sha256:37b31c1623c6605e4c00d466c9d633f9b812ea430c11c8a278774a1fde1acfa9", size = 178249, upload-time = "2026-01-10T09:22:32.083Z" }, + { url = "https://files.pythonhosted.org/packages/b4/5f/7e40efe8df57db9b91c88a43690ac66f7b7aa73a11aa6a66b927e44f26fa/websockets-16.0-cp310-cp310-win_amd64.whl", hash = "sha256:8e1dab317b6e77424356e11e99a432b7cb2f3ec8c5ab4dabbcee6add48f72b35", size = 178685, upload-time = "2026-01-10T09:22:33.345Z" }, + { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340, upload-time = "2026-01-10T09:22:34.539Z" }, + { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022, upload-time = "2026-01-10T09:22:36.332Z" }, + { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319, upload-time = "2026-01-10T09:22:37.602Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631, upload-time = "2026-01-10T09:22:38.789Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870, upload-time = "2026-01-10T09:22:39.893Z" }, + { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361, upload-time = "2026-01-10T09:22:41.016Z" }, + { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615, upload-time = "2026-01-10T09:22:42.442Z" }, + { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246, upload-time = "2026-01-10T09:22:43.654Z" }, + { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684, upload-time = "2026-01-10T09:22:44.941Z" }, { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" }, { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" }, { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" }, @@ -3008,6 +3987,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" }, { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" }, { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" }, + { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947, upload-time = "2026-01-10T09:23:36.166Z" }, + { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260, upload-time = "2026-01-10T09:23:37.409Z" }, + { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071, upload-time = "2026-01-10T09:23:39.158Z" }, + { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968, upload-time = "2026-01-10T09:23:41.031Z" }, + { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735, upload-time = "2026-01-10T09:23:42.259Z" }, { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" }, ] @@ -3050,6 +4034,39 @@ version = "0.25.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" }, + { url = "https://files.pythonhosted.org/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload-time = "2025-09-14T22:15:58.177Z" }, + { url = "https://files.pythonhosted.org/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload-time = "2025-09-14T22:16:00.165Z" }, + { url = "https://files.pythonhosted.org/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload-time = "2025-09-14T22:16:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload-time = "2025-09-14T22:16:04.109Z" }, + { url = "https://files.pythonhosted.org/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload-time = "2025-09-14T22:16:06.312Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload-time = "2025-09-14T22:16:08.457Z" }, + { url = "https://files.pythonhosted.org/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload-time = "2025-09-14T22:16:10.444Z" }, + { url = "https://files.pythonhosted.org/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload-time = "2025-09-14T22:16:12.128Z" }, + { url = "https://files.pythonhosted.org/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload-time = "2025-09-14T22:16:14.225Z" }, + { url = "https://files.pythonhosted.org/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload-time = "2025-09-14T22:16:16.343Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload-time = "2025-09-14T22:16:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload-time = "2025-09-14T22:16:20.559Z" }, + { url = "https://files.pythonhosted.org/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload-time = "2025-09-14T22:16:22.206Z" }, + { url = "https://files.pythonhosted.org/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload-time = "2025-09-14T22:16:25.002Z" }, + { url = "https://files.pythonhosted.org/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload-time = "2025-09-14T22:16:23.569Z" }, + { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" }, + { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" }, + { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" }, + { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" }, + { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" }, + { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" }, + { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" }, + { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" }, + { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" }, + { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" }, + { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" }, { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" }, { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" }, { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" }, From f8616ddf94f69ca2f8ca2e32ed26e0d4d26e9453 Mon Sep 17 00:00:00 2001 From: Dusan Malusev Date: Wed, 22 Jul 2026 19:46:44 +0200 Subject: [PATCH 3/4] feature(client): summary-first output for run events, --raw for original Add a Summary field to the SCT event model and render it in `argus run events` where present, falling back to the original message so output is never blank. A --raw flag forces the original; JSON output is additive and carries both message and summary. Marks the CLI plan phase done. --- cli/cmd/run_nemeses_events.go | 4 ++- cli/internal/models/runs.go | 10 ++++++ cli/internal/models/runs_test.go | 54 +++++++++++++++++++++++++++++++ docs/plans/event-summarization.md | 2 +- docs/plans/progress.json | 2 +- 5 files changed, 69 insertions(+), 3 deletions(-) create mode 100644 cli/internal/models/runs_test.go diff --git a/cli/cmd/run_nemeses_events.go b/cli/cmd/run_nemeses_events.go index 8cc6520ef..370290bab 100644 --- a/cli/cmd/run_nemeses_events.go +++ b/cli/cmd/run_nemeses_events.go @@ -198,6 +198,7 @@ Only SCT runs have per-event records; for other plugin types use beforeRaw, _ := cmd.Flags().GetString("before") afterRaw, _ := cmd.Flags().GetString("after") limit, _ := cmd.Flags().GetInt("limit") + raw, _ := cmd.Flags().GetBool("raw") log.Debug(). Str("run_id", runID). @@ -247,7 +248,7 @@ Only SCT runs have per-event records; for other plugin types use allEvents = deduplicateEvents(allEvents) log.Info().Str("run_id", runID).Int("total_events", len(allEvents)).Msg("SCT events fetched successfully") - return out.Write(models.SCTEventsResponse{RunID: runID, Events: allEvents}) + return out.Write(models.SCTEventsResponse{RunID: runID, Events: allEvents, Raw: raw}) }, } @@ -471,6 +472,7 @@ func init() { runEventsCmd.Flags().String("before", "", "Only events before this time (Unix timestamp, RFC3339, or YYYY-MM-DD)") runEventsCmd.Flags().String("after", "", "Only events after this time (Unix timestamp, RFC3339, or YYYY-MM-DD)") runEventsCmd.Flags().Int("limit", 100, "Maximum events per severity level to return") + runEventsCmd.Flags().Bool("raw", false, "Show the original event message instead of the AI summary") _ = runEventsCmd.MarkFlagRequired("run-id") // run nemeses diff --git a/cli/internal/models/runs.go b/cli/internal/models/runs.go index 5253a3b15..c841e576c 100644 --- a/cli/internal/models/runs.go +++ b/cli/internal/models/runs.go @@ -202,6 +202,7 @@ type SCTEvent struct { EventID string `json:"event_id"` EventType string `json:"event_type"` Message string `json:"message"` + Summary string `json:"summary"` DuplicateID string `json:"duplicate_id"` Node string `json:"node"` ReceivedTimestamp string `json:"received_timestamp"` @@ -794,6 +795,9 @@ func (f FetchResultsResponse) Tables() []output.NamedTable { type SCTEventsResponse struct { RunID string `json:"run_id"` Events []SCTEvent `json:"response"` + // Raw forces the table renderer to show the original message even when a + // summary is present. It is a rendering flag only and is never serialised. + Raw bool `json:"-"` } // Headers implements output.Tabular for SCTEventsResponse. @@ -805,7 +809,13 @@ func (SCTEventsResponse) Headers() []string { func (r SCTEventsResponse) Rows() [][]string { rows := make([][]string, 0, len(r.Events)) for _, e := range r.Events { + // Summary-first by default (§5.6): the CLI optimises for scripted/token + // consumers. --raw (r.Raw) forces the original; a missing summary falls + // back to the message so output is never blank. msg := e.Message + if !r.Raw && e.Summary != "" { + msg = e.Summary + } if len(msg) > 200 { msg = msg[:200] + "..." } diff --git a/cli/internal/models/runs_test.go b/cli/internal/models/runs_test.go new file mode 100644 index 000000000..63eb37cfb --- /dev/null +++ b/cli/internal/models/runs_test.go @@ -0,0 +1,54 @@ +package models_test + +import ( + "encoding/json" + "testing" + + "github.com/scylladb/argus/cli/internal/models" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func sctEvents() []models.SCTEvent { + return []models.SCTEvent{ + {Severity: "ERROR", Message: "long raw error message body", Summary: "short summary"}, + {Severity: "CRITICAL", Message: "event with no summary yet", Summary: ""}, + } +} + +// The message column is the last one (see SCTEventsResponse.Headers). +func messageCol(t *testing.T, resp models.SCTEventsResponse) []string { + t.Helper() + last := len(resp.Headers()) - 1 + rows := resp.Rows() + got := make([]string, 0, len(rows)) + for _, r := range rows { + got = append(got, r[last]) + } + return got +} + +func TestSCTEventsResponse_Rows_SummaryFirstByDefault(t *testing.T) { + resp := models.SCTEventsResponse{Events: sctEvents()} + // Summary shown when present; falls back to the message when the summary is empty. + assert.Equal(t, []string{"short summary", "event with no summary yet"}, messageCol(t, resp)) +} + +func TestSCTEventsResponse_Rows_RawForcesOriginalMessage(t *testing.T) { + resp := models.SCTEventsResponse{Events: sctEvents(), Raw: true} + // --raw shows the original message even when a summary exists. + assert.Equal(t, []string{"long raw error message body", "event with no summary yet"}, messageCol(t, resp)) +} + +func TestSCTEventsResponse_JSONCarriesBothMessageAndSummary(t *testing.T) { + resp := models.SCTEventsResponse{Events: sctEvents()} + data, err := json.Marshal(resp) + require.NoError(t, err) + + var out []map[string]any + require.NoError(t, json.Unmarshal(data, &out)) + require.Len(t, out, 2) + // JSON is additive: both fields travel regardless of the Raw rendering flag. + assert.Equal(t, "long raw error message body", out[0]["message"]) + assert.Equal(t, "short summary", out[0]["summary"]) +} diff --git a/docs/plans/event-summarization.md b/docs/plans/event-summarization.md index 9c5186f6b..6a2a50f13 100644 --- a/docs/plans/event-summarization.md +++ b/docs/plans/event-summarization.md @@ -380,5 +380,5 @@ Tracked as 5 phases (`progress.json`); Zeus (§5.7) is an external service track | 1 | Backend worker | §5.1 `summary` column · §5.2 dispatch · §5.3 Summarizer + config · §6 per-call & aggregate metrics | **done** | | 2 | Evaluation harness | §7 prompt/model sweep, LLM judge, token-based cost/compression, HTML report | **done** | | 3 | Serving & tests | §5.4 (`SELECT *`, no code) · §8 backend serving test (`summary` in payload, `message` intact) done; integration test pending | in progress | -| 4 | CLI | §5.6 Go `Summary` field, summary-first output, `--raw` | todo | +| 4 | CLI | §5.6 Go `Summary` field, summary-first output, `--raw` | **done** | | 5 | Web UI | §5.5 Svelte toggle + per-user localStorage preference | todo | diff --git a/docs/plans/progress.json b/docs/plans/progress.json index 642a3aa85..96043485e 100644 --- a/docs/plans/progress.json +++ b/docs/plans/progress.json @@ -37,6 +37,6 @@ "status": "in_progress", "created": "2026-06-08", "phases_total": 5, - "phases_done": 2 + "phases_done": 3 } ] From 37647089da31e919294955326d0ea4e77ceacef8 Mon Sep 17 00:00:00 2001 From: Dusan Malusev Date: Wed, 22 Jul 2026 20:15:40 +0200 Subject: [PATCH 4/4] feature(frontend): AI summary toggle for SCT events (original-first) Add an optional AI-summary view to SctEvent: when an event carries a summary, a labelled toggle switches the body between the original message and the summary, defaulting to original-first. The chosen default is a per-user preference in localStorage. Events without a summary render exactly as before, and copy-to-clipboard always copies the original. --- docs/plans/event-summarization.md | 2 +- docs/plans/progress.json | 2 +- frontend/TestRun/SCT/SctEvent.svelte | 39 +++++++++++++++++++++++++-- frontend/TestRun/SCT/SctEvents.svelte | 1 + 4 files changed, 40 insertions(+), 4 deletions(-) diff --git a/docs/plans/event-summarization.md b/docs/plans/event-summarization.md index 6a2a50f13..8dbb30004 100644 --- a/docs/plans/event-summarization.md +++ b/docs/plans/event-summarization.md @@ -381,4 +381,4 @@ Tracked as 5 phases (`progress.json`); Zeus (§5.7) is an external service track | 2 | Evaluation harness | §7 prompt/model sweep, LLM judge, token-based cost/compression, HTML report | **done** | | 3 | Serving & tests | §5.4 (`SELECT *`, no code) · §8 backend serving test (`summary` in payload, `message` intact) done; integration test pending | in progress | | 4 | CLI | §5.6 Go `Summary` field, summary-first output, `--raw` | **done** | -| 5 | Web UI | §5.5 Svelte toggle + per-user localStorage preference | todo | +| 5 | Web UI | §5.5 Svelte toggle + per-user localStorage preference | **done** | diff --git a/docs/plans/progress.json b/docs/plans/progress.json index 96043485e..68b0d9cf1 100644 --- a/docs/plans/progress.json +++ b/docs/plans/progress.json @@ -37,6 +37,6 @@ "status": "in_progress", "created": "2026-06-08", "phases_total": 5, - "phases_done": 3 + "phases_done": 4 } ] diff --git a/frontend/TestRun/SCT/SctEvent.svelte b/frontend/TestRun/SCT/SctEvent.svelte index 4cbb62cec..9d87e18a3 100644 --- a/frontend/TestRun/SCT/SctEvent.svelte +++ b/frontend/TestRun/SCT/SctEvent.svelte @@ -3,7 +3,7 @@ import { timestampToISODate } from "../../Common/DateUtils"; import type { EventSeverityFilter, Options, SCTEvent } from "./SctEvents.svelte"; import Fa from "svelte-fa"; - import { faClipboard, faClock, faCopy, faPlus, faSearch, faServer, faSpider, faTable } from "@fortawesome/free-solid-svg-icons"; + import { faClipboard, faClock, faCopy, faPlus, faRobot, faSearch, faServer, faSpider, faTable } from "@fortawesome/free-solid-svg-icons"; import SctSimilarEvents from "./SctSimilarEvents.svelte"; import { sendMessage } from "../../Stores/AlertStore"; import type { GithubSubtype, JiraSubtype } from "../../Github/Issues.svelte"; @@ -159,6 +159,28 @@ let fullMessage = $state(false); let parsedMessage = $derived(parseEventMessage(event.message)); + // AI summary view (§5.5). The original message is always the source of truth; the summary + // is opt-in. Which view renders first is a per-user preference stored in localStorage + // (default: original-first). When there is no summary, the event renders exactly as before. + const SUMMARY_PREF_KEY = "argus.sctEvent.summaryFirst"; + const summaryFirstPref = function (): boolean { + try { + return window.localStorage.getItem(SUMMARY_PREF_KEY) === "true"; + } catch { + return false; + } + }; + let hasSummary = $derived(!!event.summary && event.summary.trim().length > 0); + let showSummary = $state(summaryFirstPref()); + const toggleSummaryView = function () { + showSummary = !showSummary; + try { + window.localStorage.setItem(SUMMARY_PREF_KEY, String(showSummary)); + } catch { + // localStorage unavailable (e.g. private mode) — the choice is session-only. + } + }; + const shouldFilter = function (filterString: string) { if (!filterString) return false; try { @@ -363,7 +385,20 @@
- 
{sliceMessage(event.message)} {#if event.message.length > MESSAGE_CUTOFF}{/if}
+ {#if hasSummary && showSummary} +
+ AI summary + +
+ 
{event.summary}
+ {:else} + {#if hasSummary} +
+ +
+ {/if} + 
{sliceMessage(event.message)} {#if event.message.length > MESSAGE_CUTOFF}{/if}
+ {/if}
diff --git a/frontend/TestRun/SCT/SctEvents.svelte b/frontend/TestRun/SCT/SctEvents.svelte index cc18b30f6..c5a6fe30e 100644 --- a/frontend/TestRun/SCT/SctEvents.svelte +++ b/frontend/TestRun/SCT/SctEvents.svelte @@ -7,6 +7,7 @@ duplicate_id: string; event_type: string; message: string; + summary?: string | null; node?: string; received_timestamp?: string; nemesis_name?: string;