File size: 6,518 Bytes
a06d854 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | """Shared, dependency-light helpers for the DeepResearch-9K pipeline."""
from __future__ import annotations
import ast
import hashlib
import json
import re
import unicodedata
from collections.abc import Iterable, Iterator
from pathlib import Path
from typing import Any
from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
TOOL_CALL_RE = re.compile(r"<tool_call>\s*(.*?)\s*</tool_call>", re.DOTALL | re.IGNORECASE)
TRACKING_QUERY_KEYS = {
"fbclid",
"gclid",
"mc_cid",
"mc_eid",
}
def normalize_question(text: str) -> str:
"""Normalize a question for duplicate detection without rewriting content."""
return re.sub(r"\s+", " ", unicodedata.normalize("NFKC", text or "")).strip()
def question_key(text: str) -> str:
return normalize_question(text).casefold()
def stable_qid(question: str) -> str:
digest = hashlib.sha256(question_key(question).encode("utf-8")).hexdigest()[:16]
return f"dr9k-{digest}"
def to_plain(value: Any) -> Any:
"""Recursively convert numpy/Arrow containers to JSON-compatible values."""
if hasattr(value, "tolist"):
return to_plain(value.tolist())
if isinstance(value, dict):
return {str(key): to_plain(item) for key, item in value.items()}
if isinstance(value, (list, tuple)):
return [to_plain(item) for item in value]
if hasattr(value, "item"):
try:
return value.item()
except (TypeError, ValueError):
pass
return value
def trajectory_fingerprint(row: dict[str, Any]) -> str:
"""Fingerprint the complete public row so DeepResearch-Hard matches exactly."""
payload = {
"question": normalize_question(str(row["question"])),
"difficulty": int(row["difficulty"]),
"search trajectory": to_plain(row["search trajectory"]),
"final answer": str(row["final answer"]).strip(),
}
encoded = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(encoded.encode("utf-8")).hexdigest()
def parse_tool_call_block(block: str) -> dict[str, Any]:
"""Parse one JSON-ish tool-call block.
The public data contains a small number of Python-literal or fenced blocks,
so JSON is attempted first and ``literal_eval`` is a conservative fallback.
"""
value = block.strip()
if value.startswith("```") and value.endswith("```"):
value = re.sub(r"^```(?:json)?\s*|\s*```$", "", value, flags=re.DOTALL | re.IGNORECASE).strip()
errors: list[str] = []
for parser in (json.loads, ast.literal_eval):
try:
result = parser(value)
if not isinstance(result, dict):
raise ValueError(f"tool call is {type(result).__name__}, not an object")
name = result.get("name")
arguments = result.get("arguments", {})
if not isinstance(name, str) or not name.strip():
raise ValueError("tool call has no string name")
if not isinstance(arguments, dict):
raise ValueError("tool-call arguments are not an object")
return {"name": name.strip(), "arguments": arguments}
except (SyntaxError, ValueError, TypeError, json.JSONDecodeError) as exc:
errors.append(str(exc))
raise ValueError("; ".join(errors))
def iter_tool_calls(trajectory: Iterable[dict[str, Any]]) -> Iterator[tuple[int, int, dict[str, Any], str]]:
"""Yield ``(message_index, block_index, call, raw_block)`` from a trajectory."""
for message_index, message in enumerate(trajectory):
if message.get("role") != "assistant":
continue
content = str(message.get("content") or "")
for block_index, match in enumerate(TOOL_CALL_RE.finditer(content)):
raw = match.group(1)
yield message_index, block_index, parse_tool_call_block(raw), raw
def as_string_list(value: Any) -> list[str]:
if isinstance(value, str):
return [value.strip()] if value.strip() else []
if isinstance(value, (list, tuple)):
return [str(item).strip() for item in value if str(item).strip()]
return []
def unwrap_jina_url(url: str) -> tuple[str, bool]:
"""Return the underlying URL for an observed r.jina.ai reader URL."""
value = url.strip()
match = re.match(r"^https?://r\.jina\.ai/(https?://.+)$", value, flags=re.IGNORECASE)
return (match.group(1), True) if match else (value, False)
def canonicalize_url(url: str) -> str:
"""Canonicalize an HTTP(S) URL for corpus deduplication."""
value, _ = unwrap_jina_url(url)
parsed = urlsplit(value.strip())
scheme = parsed.scheme.lower()
if scheme not in {"http", "https"} or not parsed.hostname:
raise ValueError("only absolute HTTP(S) URLs are supported")
hostname = parsed.hostname.encode("idna").decode("ascii").lower()
port = parsed.port
netloc = hostname
if port and not ((scheme == "http" and port == 80) or (scheme == "https" and port == 443)):
netloc = f"{hostname}:{port}"
if parsed.username or parsed.password:
raise ValueError("credential-bearing URLs are not supported")
path = re.sub(r"/{2,}", "/", parsed.path or "/")
if path != "/":
path = path.rstrip("/")
query_items = []
for key, item in parse_qsl(parsed.query, keep_blank_values=True):
lowered = key.casefold()
if lowered.startswith("utm_") or lowered in TRACKING_QUERY_KEYS:
continue
query_items.append((key, item))
query = urlencode(sorted(query_items))
return urlunsplit((scheme, netloc, path, query, ""))
def url_id(canonical_url: str) -> str:
return "url-" + hashlib.sha256(canonical_url.encode("utf-8")).hexdigest()[:24]
def write_jsonl(path: Path, records: Iterable[dict[str, Any]]) -> int:
path.parent.mkdir(parents=True, exist_ok=True)
count = 0
with path.open("w", encoding="utf-8") as handle:
for record in records:
handle.write(json.dumps(record, ensure_ascii=False, sort_keys=True) + "\n")
count += 1
return count
def read_jsonl(path: Path) -> Iterator[dict[str, Any]]:
with path.open(encoding="utf-8") as handle:
for line_number, line in enumerate(handle, start=1):
if not line.strip():
continue
try:
yield json.loads(line)
except json.JSONDecodeError as exc:
raise ValueError(f"invalid JSON in {path}:{line_number}: {exc}") from exc
|