193 lines
7.8 KiB
Python
193 lines
7.8 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
from typing import Any, Callable
|
|
from urllib.error import HTTPError
|
|
|
|
from .classify import SECTION_ORDER
|
|
from .llm import parse_json_object
|
|
from .models import NewsItem
|
|
|
|
|
|
RewriteLlmCall = Callable[[str], str]
|
|
|
|
|
|
def _chunks(items: list[NewsItem], size: int) -> list[list[NewsItem]]:
|
|
return [items[index : index + size] for index in range(0, len(items), size)]
|
|
|
|
|
|
def _build_prompt(batch: list[NewsItem]) -> str:
|
|
payload = {
|
|
"task": (
|
|
"For each AI news item, translate when needed, rewrite the title and summary into concise Chinese, "
|
|
"and classify it into exactly one allowed section. Preserve brand/model/API names such as GPT-5, "
|
|
"Codex, Gemini, Claude, API, MCP. Do not add facts."
|
|
),
|
|
"allowed_sections": SECTION_ORDER,
|
|
"section_guidance": {
|
|
"模型与能力": "model releases, capability upgrades, modalities, context windows, inference, benchmarks tied to model ability",
|
|
"产品与应用": "end-user products, apps, agents, workflows, product launches, practical business or consumer use cases",
|
|
"开发与基础设施": "developer tools, APIs, SDKs, MCP, frameworks, deployment, chips, cloud, infra, open source engineering",
|
|
"公司与资本": "company strategy, financing, IPO, acquisitions, partnerships, revenue, business competition",
|
|
"政策与安全": "policy, regulation, safety, privacy, copyright, misuse, security incidents, governance",
|
|
"论文与研究": "papers, academic research, arXiv, methods, experiments, datasets, evaluations",
|
|
"观点与教程": "opinions, analysis, explainers, tutorials, guides, practices",
|
|
"人物与动态": "people-focused interviews, speeches, career moves, public appearances",
|
|
},
|
|
"items": [
|
|
{
|
|
"id": item.id,
|
|
"title_raw": item.title_raw,
|
|
"summary_raw": item.summary_raw,
|
|
"source": item.source_label,
|
|
"language_hint": item.language_hint,
|
|
"source_section_hint": item.section_hint,
|
|
}
|
|
for item in batch
|
|
],
|
|
"output_schema": {
|
|
"rewrites": [
|
|
{
|
|
"id": "item id",
|
|
"title": "display title",
|
|
"summary": "display summary",
|
|
"section": "one allowed section",
|
|
"confidence": 0.0,
|
|
"flags": [],
|
|
}
|
|
]
|
|
},
|
|
}
|
|
return json.dumps(payload, ensure_ascii=False)
|
|
|
|
|
|
def _fallback(item: NewsItem) -> None:
|
|
item.title = item.title_raw
|
|
item.summary = item.summary_raw or "该条目暂无摘要。"
|
|
|
|
|
|
def _is_transient_llm_error(exc: Exception) -> bool:
|
|
if isinstance(exc, TimeoutError):
|
|
return True
|
|
if isinstance(exc, HTTPError):
|
|
return exc.code in {429, 500, 502, 503, 504}
|
|
return False
|
|
|
|
|
|
def _apply_rewrite_results(batch: list[NewsItem], rewrites: list[Any]) -> tuple[int, int]:
|
|
by_id = {item.id: item for item in batch}
|
|
seen_ids: set[str] = set()
|
|
section_count = 0
|
|
for entry in rewrites:
|
|
if not isinstance(entry, dict):
|
|
continue
|
|
item_id = entry.get("id")
|
|
title = str(entry.get("title") or "").strip()
|
|
summary = str(entry.get("summary") or "").strip()
|
|
if item_id in by_id and title and summary:
|
|
by_id[item_id].title = title
|
|
by_id[item_id].summary = summary
|
|
section = str(entry.get("section") or "").strip()
|
|
if section in SECTION_ORDER:
|
|
by_id[item_id].section = section
|
|
section_count += 1
|
|
seen_ids.add(item_id)
|
|
return len(seen_ids), section_count
|
|
|
|
|
|
def _apply_rewrite_batch(batch: list[NewsItem], llm_call: RewriteLlmCall) -> tuple[int, int]:
|
|
obj = parse_json_object(llm_call(_build_prompt(batch)))
|
|
rewrites = obj.get("rewrites", [])
|
|
if not isinstance(rewrites, list):
|
|
raise ValueError("rewrites is not a list")
|
|
return _apply_rewrite_results(batch, rewrites)
|
|
|
|
|
|
def rewrite_items(
|
|
items: list[NewsItem],
|
|
*,
|
|
llm_call: RewriteLlmCall,
|
|
batch_size: int = 30,
|
|
retry_batch_size: int = 10,
|
|
max_fallback_ratio: float = 0.2,
|
|
retry_single_items: bool = False,
|
|
) -> tuple[list[NewsItem], dict[str, Any]]:
|
|
rewritten_count = 0
|
|
llm_section_count = 0
|
|
fallback_count = 0
|
|
missing_rewrite_count = 0
|
|
batch_retry_count = 0
|
|
errors: list[str] = []
|
|
|
|
for batch in _chunks(items, max(1, batch_size)):
|
|
try:
|
|
batch_rewritten_count, batch_section_count = _apply_rewrite_batch(batch, llm_call)
|
|
rewritten_count += batch_rewritten_count
|
|
llm_section_count += batch_section_count
|
|
for item in batch:
|
|
if item.title is None or item.summary is None:
|
|
errors.append(f"missing_rewrite_for_item: {item.id}")
|
|
_fallback(item)
|
|
fallback_count += 1
|
|
missing_rewrite_count += 1
|
|
except Exception as exc:
|
|
errors.append(f"batch:{type(exc).__name__}: {exc}")
|
|
if _is_transient_llm_error(exc):
|
|
for item in batch:
|
|
_fallback(item)
|
|
fallback_count += 1
|
|
continue
|
|
if len(batch) > max(1, retry_batch_size):
|
|
for retry_batch in _chunks(batch, max(1, retry_batch_size)):
|
|
batch_retry_count += 1
|
|
try:
|
|
retry_rewritten_count, retry_section_count = _apply_rewrite_batch(retry_batch, llm_call)
|
|
rewritten_count += retry_rewritten_count
|
|
llm_section_count += retry_section_count
|
|
for item in retry_batch:
|
|
if item.title is None or item.summary is None:
|
|
errors.append(f"missing_rewrite_for_item: {item.id}")
|
|
_fallback(item)
|
|
fallback_count += 1
|
|
missing_rewrite_count += 1
|
|
except Exception as retry_exc:
|
|
errors.append(f"batch_retry:{type(retry_exc).__name__}: {retry_exc}")
|
|
for item in retry_batch:
|
|
_fallback(item)
|
|
fallback_count += 1
|
|
continue
|
|
if not retry_single_items:
|
|
for item in batch:
|
|
_fallback(item)
|
|
fallback_count += 1
|
|
continue
|
|
for item in batch:
|
|
try:
|
|
item_rewritten_count, item_section_count = _apply_rewrite_batch([item], llm_call)
|
|
rewritten_count += item_rewritten_count
|
|
llm_section_count += item_section_count
|
|
except Exception as item_exc:
|
|
errors.append(f"item:{item.id}:{type(item_exc).__name__}: {item_exc}")
|
|
_fallback(item)
|
|
fallback_count += 1
|
|
|
|
fallback_ratio = fallback_count / len(items) if items else 0
|
|
blocking_errors: list[str] = []
|
|
if fallback_ratio > max_fallback_ratio:
|
|
blocking_errors.append("rewrite_fallback_ratio_exceeded")
|
|
|
|
report = {
|
|
"input_count": len(items),
|
|
"rewritten_count": rewritten_count,
|
|
"llm_section_count": llm_section_count,
|
|
"fallback_count": fallback_count,
|
|
"missing_rewrite_count": missing_rewrite_count,
|
|
"fallback_ratio": round(fallback_ratio, 4),
|
|
"batch_count": len(_chunks(items, max(1, batch_size))),
|
|
"batch_retry_count": batch_retry_count,
|
|
"errors": errors,
|
|
"blocking_errors": blocking_errors,
|
|
"quality_gate_failed": bool(blocking_errors),
|
|
}
|
|
return items, report
|