459 lines
23 KiB
Python
459 lines
23 KiB
Python
import json
|
||
import base64
|
||
import io
|
||
import logging
|
||
import re
|
||
import time
|
||
import urllib.error
|
||
import urllib.request
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||
|
||
from PIL import Image, ImageOps
|
||
|
||
from fastapi import HTTPException, status
|
||
|
||
from .config import settings
|
||
from .schemas import QABulkAnswerRequest, QAGenerateRequest
|
||
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
def _prompt(payload: QAGenerateRequest) -> str:
|
||
style = "带真实体验的轻度种草语气" if payload.seed_style else "客观自然，不刻意种草"
|
||
return f"""你是电商问大家内容策划。请根据商品条件生成真实、具体、互不重复的消费者提问和参考回答。
|
||
商品名称：{payload.product_name or '未提供'}
|
||
商品品类：{payload.category or '未提供'}
|
||
商品功效：{payload.benefits or '未提供'}
|
||
商品卖点：{payload.selling_points or '未提供'}
|
||
语言风格：{payload.language_style or '客观自然'}
|
||
目标人群：{payload.target_group or '普通消费者'}
|
||
使用场景：{payload.usage_scene or '日常使用'}
|
||
购买渠道：{payload.purchase_channel or '电商平台'}
|
||
回答要求：{payload.answer_requirement or '直接回应问题，避免夸大功效'}
|
||
回答语气：{style}
|
||
真实问答参考：{payload.reference_qa or '未提供'}
|
||
|
||
请生成 {payload.question_count} 个问题，每个问题生成 {payload.answers_per_question} 个不同角度的参考回答。
|
||
约束：问题尽量不超过20字，回答尽量不超过50字；不虚构成分、检测、认证和医疗功效；表达像真实买家；不要重复商品名称作为开头。
|
||
如果提供了真实问答参考，请优先学习其中的提问角度、真实语气和回答结构，但不要照抄原文，不要把参考中的其他商品信息误套到当前商品。
|
||
只返回严格 JSON，不要 Markdown 代码块或额外解释，格式必须是：
|
||
{{"items":[{{"question":"问题文本","answers":["回答1","回答2"]}}]}}"""
|
||
|
||
|
||
def _parse_content(content: str, expected_answers: int) -> list[dict]:
|
||
cleaned = content.strip()
|
||
if cleaned.startswith("```"):
|
||
cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", cleaned, flags=re.I | re.S).strip()
|
||
try:
|
||
parsed = json.loads(cleaned)
|
||
except json.JSONDecodeError as exc:
|
||
start, end = cleaned.find("{"), cleaned.rfind("}")
|
||
if start < 0 or end <= start:
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="大模型返回格式无法解析") from exc
|
||
parsed = json.loads(cleaned[start:end + 1])
|
||
raw_items = parsed.get("items") if isinstance(parsed, dict) else parsed
|
||
if not isinstance(raw_items, list):
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="大模型未返回有效问答列表")
|
||
items = []
|
||
for index, raw in enumerate(raw_items):
|
||
if not isinstance(raw, dict) or not str(raw.get("question", "")).strip():
|
||
continue
|
||
answers = raw.get("answers", [])
|
||
if isinstance(answers, str):
|
||
answers = [answers]
|
||
answers = [str(answer).strip() for answer in answers if str(answer).strip()][:expected_answers]
|
||
if answers:
|
||
items.append({"id": f"Q{index + 1:03d}", "question": str(raw["question"]).strip(), "answers": answers, "source": "AI生成", "status": "待采纳", "accepted": False})
|
||
if not items:
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="大模型未返回有效问答内容")
|
||
return items
|
||
|
||
|
||
def _generate_qa_batch(payload: QAGenerateRequest) -> list[dict]:
|
||
if not settings.llm_api_key:
|
||
raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="尚未配置大模型 API Key，请先设置 LLM_API_KEY")
|
||
url = settings.llm_base_url.rstrip("/") + "/chat/completions"
|
||
request_body = {"model": settings.llm_model, "temperature": 0.8, "messages": [{"role": "system", "content": "你只输出合法 JSON。"}, {"role": "user", "content": _prompt(payload)}]}
|
||
request = urllib.request.Request(url, data=json.dumps(request_body).encode("utf-8"), headers={"Content-Type": "application/json", "Authorization": f"Bearer {settings.llm_api_key}"}, method="POST")
|
||
try:
|
||
with urllib.request.urlopen(request, timeout=settings.llm_timeout_seconds) as response:
|
||
result = json.loads(response.read().decode("utf-8"))
|
||
except urllib.error.HTTPError as exc:
|
||
logger.error("LLM HTTP error: status=%s url=%s", exc.code, url)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=f"大模型服务返回错误（HTTP {exc.code}）") from exc
|
||
except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as exc:
|
||
logger.exception("LLM request failed: url=%s reason=%s", url, exc)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="大模型服务暂时不可用，请稍后重试") from exc
|
||
try:
|
||
content = result["choices"][0]["message"]["content"]
|
||
except (KeyError, IndexError, TypeError) as exc:
|
||
logger.error("LLM response missing choices/message/content: keys=%s", list(result) if isinstance(result, dict) else type(result).__name__)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="大模型响应缺少内容") from exc
|
||
return _parse_content(content, payload.answers_per_question)
|
||
|
||
|
||
def generate_qa(payload: QAGenerateRequest) -> list[dict]:
|
||
"""Generate the requested amount in small batches so large requests are not truncated."""
|
||
target = payload.question_count
|
||
items: list[dict] = []
|
||
seen: set[str] = set()
|
||
attempts = 0
|
||
max_attempts = max((target + 19) // 20 + 2, 3)
|
||
while len(items) < target and attempts < max_attempts:
|
||
batch_size = min(20, target - len(items))
|
||
batch_payload = payload.model_copy(update={"question_count": batch_size})
|
||
for item in _generate_qa_batch(batch_payload):
|
||
key = item["question"].strip()
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
items.append(item)
|
||
if len(items) >= target:
|
||
break
|
||
attempts += 1
|
||
if len(items) < target:
|
||
logger.warning("LLM returned %s/%s unique QA items", len(items), target)
|
||
for index, item in enumerate(items[:target], start=1):
|
||
item["id"] = f"Q{index:03d}"
|
||
return items[:target]
|
||
|
||
|
||
def _bulk_answers_prompt(payload: QABulkAnswerRequest, questions: list[str]) -> str:
|
||
style = "带真实体验的轻度种草语气" if payload.seed_style else "客观自然，不刻意种草"
|
||
question_lines = "\n".join(f"{index}. {question}" for index, question in enumerate(questions, start=1))
|
||
return f"""你是电商问大家回答助手。请严格按照给定问题逐条生成参考回答，不要新增、删除、合并或改写问题。
|
||
商品名称：{payload.product_name or '未提供'}
|
||
商品品类：{payload.category or '未提供'}
|
||
商品功效：{payload.benefits or '未提供'}
|
||
商品卖点：{payload.selling_points or '未提供'}
|
||
语言风格：{payload.language_style or '客观自然'}
|
||
目标人群：{payload.target_group or '普通消费者'}
|
||
使用场景：{payload.usage_scene or '日常使用'}
|
||
购买渠道：{payload.purchase_channel or '电商平台'}
|
||
回答要求：{payload.answer_requirement or '直接回应问题，避免夸大功效'}
|
||
回答语气：{style}
|
||
|
||
问题列表：
|
||
{question_lines}
|
||
|
||
每个问题生成 {payload.answers_per_question} 条不同角度的回答。回答尽量不超过50字，不虚构成分、检测、认证和医疗功效。
|
||
只返回严格 JSON，不要 Markdown 或解释。必须按问题序号原顺序返回，格式：
|
||
{{"items":[{{"index":1,"answers":["回答1","回答2"]}}]}}"""
|
||
|
||
|
||
def _generate_bulk_answers_batch(payload: QABulkAnswerRequest, questions: list[str]) -> list[list[str]]:
|
||
if not settings.llm_api_key:
|
||
raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="尚未配置大模型 API Key，请先设置 LLM_API_KEY")
|
||
url = settings.llm_base_url.rstrip("/") + "/chat/completions"
|
||
request_body = {
|
||
"model": settings.llm_model,
|
||
"temperature": 0.75,
|
||
"messages": [
|
||
{"role": "system", "content": "你只输出合法 JSON，并严格保持输入问题的数量和顺序。"},
|
||
{"role": "user", "content": _bulk_answers_prompt(payload, questions)},
|
||
],
|
||
}
|
||
request = urllib.request.Request(
|
||
url,
|
||
data=json.dumps(request_body).encode("utf-8"),
|
||
headers={"Content-Type": "application/json", "Authorization": f"Bearer {settings.llm_api_key}"},
|
||
method="POST",
|
||
)
|
||
try:
|
||
with urllib.request.urlopen(request, timeout=settings.llm_timeout_seconds) as response:
|
||
result = json.loads(response.read().decode("utf-8"))
|
||
content = str(result["choices"][0]["message"]["content"]).strip()
|
||
cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", content, flags=re.I | re.S).strip()
|
||
parsed = json.loads(cleaned)
|
||
raw_items = parsed.get("items") if isinstance(parsed, dict) else parsed
|
||
if not isinstance(raw_items, list):
|
||
raise ValueError("items is not a list")
|
||
by_index: dict[int, list[str]] = {}
|
||
for raw in raw_items:
|
||
if not isinstance(raw, dict):
|
||
continue
|
||
try:
|
||
index = int(raw.get("index"))
|
||
except (TypeError, ValueError):
|
||
continue
|
||
answers = raw.get("answers") or []
|
||
if isinstance(answers, str):
|
||
answers = [answers]
|
||
clean_answers = [str(answer).strip() for answer in answers if str(answer).strip()]
|
||
if len(clean_answers) >= payload.answers_per_question:
|
||
by_index[index] = clean_answers[:payload.answers_per_question]
|
||
if any(index not in by_index for index in range(1, len(questions) + 1)):
|
||
raise ValueError("answers are incomplete")
|
||
return [by_index[index] for index in range(1, len(questions) + 1)]
|
||
except urllib.error.HTTPError as exc:
|
||
logger.error("LLM bulk-answer HTTP error: status=%s url=%s", exc.code, url)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=f"大模型服务返回错误（HTTP {exc.code}）") from exc
|
||
except (urllib.error.URLError, TimeoutError, json.JSONDecodeError, KeyError, IndexError, TypeError, ValueError) as exc:
|
||
logger.exception("LLM bulk-answer generation failed")
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="批量回答生成不完整，请重试") from exc
|
||
|
||
|
||
def generate_answers_batch(payload: QABulkAnswerRequest, questions: list[str]) -> list[list[str]]:
|
||
"""Generate one bounded batch for the persistent background job worker."""
|
||
return _generate_bulk_answers_batch(payload, questions)
|
||
|
||
|
||
def generate_answers_for_questions(payload: QABulkAnswerRequest, questions: list[str]) -> list[dict]:
|
||
"""Generate answers for exact imported questions without rewriting them."""
|
||
items: list[dict] = []
|
||
# Keep each response small enough that the provider can return every
|
||
# requested answer without truncating the JSON payload.
|
||
batch_size = max(1, min(10, 30 // payload.answers_per_question))
|
||
for offset in range(0, len(questions), batch_size):
|
||
batch = questions[offset:offset + batch_size]
|
||
answer_groups = _generate_bulk_answers_batch(payload, batch)
|
||
for question, answers in zip(batch, answer_groups):
|
||
items.append({
|
||
"id": f"Q{len(items) + 1:03d}",
|
||
"question": question,
|
||
"answers": answers,
|
||
"source": "批量导入（AI回答）",
|
||
"status": "待采纳",
|
||
"accepted": False,
|
||
})
|
||
return items
|
||
|
||
|
||
def _generate_questions_batch(payload: dict, count: int, reference_qa: str = "") -> list[str]:
|
||
"""Generate only consumer questions for the ask-task workflow."""
|
||
if not settings.llm_api_key:
|
||
raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="尚未配置大模型 API Key，无法生成真实提问")
|
||
prompt = f"""你是电商问大家提问策划。请根据商品信息生成 {count} 个真实、具体、互不重复的消费者提问。
|
||
商品名称：{payload.get('product_name') or '未提供'}
|
||
商品品类：{payload.get('category') or '未提供'}
|
||
商品功效：{payload.get('benefits') or '未提供'}
|
||
商品卖点：{payload.get('selling_points') or '未提供'}
|
||
语言风格：{payload.get('language_style') or '客观自然'}
|
||
目标人群：{payload.get('target_group') or '普通消费者'}
|
||
使用场景：{payload.get('usage_scene') or '日常使用'}
|
||
购买渠道：{payload.get('purchase_channel') or '电商平台'}
|
||
真实问答参考：{reference_qa or '未提供'}
|
||
只返回严格 JSON，不要 Markdown 或解释，格式：{{"questions":["问题1","问题2"]}}。问题应像真实买家提问，尽量不超过30字，不要虚构具体参数或功效。"""
|
||
url = settings.llm_base_url.rstrip("/") + "/chat/completions"
|
||
body = {"model": settings.llm_model, "temperature": 0.85, "messages": [{"role": "system", "content": "你只输出合法 JSON。"}, {"role": "user", "content": prompt}]}
|
||
request = urllib.request.Request(url, data=json.dumps(body).encode("utf-8"), headers={"Content-Type": "application/json", "Authorization": f"Bearer {settings.llm_api_key}"}, method="POST")
|
||
try:
|
||
with urllib.request.urlopen(request, timeout=settings.llm_timeout_seconds) as response:
|
||
result = json.loads(response.read().decode("utf-8"))
|
||
content = result["choices"][0]["message"]["content"]
|
||
cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", str(content).strip(), flags=re.I | re.S).strip()
|
||
parsed = json.loads(cleaned)
|
||
questions = parsed.get("questions") if isinstance(parsed, dict) else parsed
|
||
if not isinstance(questions, list):
|
||
raise ValueError("questions is not a list")
|
||
output = []
|
||
for value in questions:
|
||
text = str(value).strip()
|
||
if text and text not in output:
|
||
output.append(text[:200])
|
||
if not output:
|
||
raise ValueError("empty questions")
|
||
return output[:count]
|
||
except urllib.error.HTTPError as exc:
|
||
logger.error("LLM question generation HTTP error: status=%s url=%s", exc.code, url)
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=f"大模型服务返回错误（HTTP {exc.code}）") from exc
|
||
except (urllib.error.URLError, TimeoutError, json.JSONDecodeError, KeyError, IndexError, TypeError, ValueError) as exc:
|
||
logger.exception("LLM question generation failed")
|
||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="大模型提问生成失败，请稍后重试") from exc
|
||
|
||
|
||
def generate_questions(payload: dict, count: int, reference_qa: str = "") -> list[str]:
|
||
"""Generate questions in batches and merge them until the requested count is reached."""
|
||
target = int(count)
|
||
output: list[str] = []
|
||
seen: set[str] = set()
|
||
attempts = 0
|
||
max_attempts = max((target + 19) // 20 + 2, 3)
|
||
while len(output) < target and attempts < max_attempts:
|
||
batch = _generate_questions_batch(payload, min(20, target - len(output)), reference_qa)
|
||
for question in batch:
|
||
if question not in seen:
|
||
seen.add(question)
|
||
output.append(question)
|
||
if len(output) >= target:
|
||
break
|
||
attempts += 1
|
||
if len(output) < target:
|
||
logger.warning("LLM returned %s/%s unique questions", len(output), target)
|
||
return output[:target]
|
||
|
||
|
||
def generate_answer_for_question(product_title: str, question: str) -> str:
|
||
"""Generate one concise answer for an OCR-extracted question."""
|
||
if not settings.llm_api_key:
|
||
return f"结合{product_title}的使用体验来看，建议按自身肤质先少量试用，确认合适后再正常使用。"
|
||
url = settings.llm_base_url.rstrip("/") + "/chat/completions"
|
||
prompt = f"商品：{product_title}\n问题：{question}\n请生成一条50字以内、自然真实、不夸大功效的淘宝问大家回答。只输出回答正文。"
|
||
request_body = {"model": settings.llm_model, "temperature": 0.7, "messages": [{"role": "system", "content": "你是电商问大家回答助手。"}, {"role": "user", "content": prompt}]}
|
||
request = urllib.request.Request(url, data=json.dumps(request_body).encode("utf-8"), headers={"Content-Type": "application/json", "Authorization": f"Bearer {settings.llm_api_key}"}, method="POST")
|
||
try:
|
||
with urllib.request.urlopen(request, timeout=settings.llm_timeout_seconds) as response:
|
||
result = json.loads(response.read().decode("utf-8"))
|
||
answer = str(result["choices"][0]["message"]["content"]).strip()
|
||
return answer[:300]
|
||
except Exception:
|
||
logger.exception("Answer generation failed for OCR question")
|
||
return f"结合{product_title}的使用体验来看，建议按自身肤质先少量试用，确认合适后再正常使用。"
|
||
|
||
|
||
def _parse_ocr_content(content: str) -> list[dict]:
|
||
if isinstance(content, list):
|
||
content = "".join(str(item.get("text", "")) for item in content if isinstance(item, dict))
|
||
cleaned = str(content or "").strip()
|
||
if cleaned.startswith("```"):
|
||
cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", cleaned, flags=re.I | re.S).strip()
|
||
try:
|
||
parsed = json.loads(cleaned)
|
||
except json.JSONDecodeError:
|
||
start, end = cleaned.find("{"), cleaned.rfind("}")
|
||
if start < 0 or end <= start:
|
||
return []
|
||
try:
|
||
parsed = json.loads(cleaned[start:end + 1])
|
||
except json.JSONDecodeError:
|
||
return []
|
||
raw_items = parsed.get("items") if isinstance(parsed, dict) else parsed
|
||
if not isinstance(raw_items, list):
|
||
return []
|
||
items = []
|
||
seen = set()
|
||
for raw in raw_items:
|
||
if not isinstance(raw, dict):
|
||
continue
|
||
question = re.sub(r"^[\s\d.#、.)（()]+", "", str(raw.get("question", ""))).strip()
|
||
if len(question) < 4 or question in seen:
|
||
continue
|
||
if any(token in question for token in ("回答", "规则", "待回答", "已回答", "已提问")):
|
||
continue
|
||
seen.add(question)
|
||
items.append({
|
||
"product_title": str(raw.get("product_title", "待识别商品")).strip() or "待识别商品",
|
||
"question": question[:300],
|
||
})
|
||
return items[:100]
|
||
|
||
|
||
def _compress_ocr_image(image_data: bytes, content_type: str) -> tuple[bytes, str]:
|
||
"""Normalize screenshots and keep each vision request reasonably small."""
|
||
try:
|
||
with Image.open(io.BytesIO(image_data)) as source:
|
||
image = ImageOps.exif_transpose(source)
|
||
image.thumbnail((2200, 2200), Image.Resampling.LANCZOS)
|
||
if image.mode in {"RGBA", "LA"} or "transparency" in image.info:
|
||
rgba = image.convert("RGBA")
|
||
background = Image.new("RGB", rgba.size, "white")
|
||
background.paste(rgba, mask=rgba.getchannel("A"))
|
||
image = background
|
||
else:
|
||
image = image.convert("RGB")
|
||
|
||
for quality in (86, 76, 66):
|
||
output = io.BytesIO()
|
||
image.save(output, format="JPEG", quality=quality, optimize=True)
|
||
compressed = output.getvalue()
|
||
if len(compressed) <= 1_500_000:
|
||
return compressed, "image/jpeg"
|
||
|
||
# Very long/high-detail screenshots get one final size reduction.
|
||
image.thumbnail((1700, 1700), Image.Resampling.LANCZOS)
|
||
output = io.BytesIO()
|
||
image.save(output, format="JPEG", quality=72, optimize=True)
|
||
return output.getvalue(), "image/jpeg"
|
||
except Exception:
|
||
logger.warning("Could not compress OCR image; using original payload", exc_info=True)
|
||
return image_data, content_type
|
||
|
||
|
||
def _extract_questions_from_image(image_data: bytes, content_type: str) -> list[dict]:
|
||
encoded = base64.b64encode(image_data).decode("ascii")
|
||
content = [
|
||
{
|
||
"type": "text",
|
||
"text": (
|
||
"请识别这张淘宝‘问答/待回答’页面截图中的所有消费者提问。只提取真正的问题句子，"
|
||
"不要提取导航、按钮、商品名、用户昵称、规则文字或页面标题。去除序号并保持原文。"
|
||
"只返回严格 JSON："
|
||
'{"items":[{"product_title":"商品名或待识别商品","question":"问题原文"}]}'
|
||
),
|
||
},
|
||
{
|
||
"type": "image_url",
|
||
"image_url": {"url": f"data:{content_type};base64,{encoded}"},
|
||
},
|
||
]
|
||
request_body = {
|
||
"model": settings.llm_vision_model,
|
||
"temperature": 0,
|
||
"messages": [
|
||
{"role": "system", "content": "你是严谨的中文电商截图 OCR 提取器，只输出合法 JSON。"},
|
||
{"role": "user", "content": content},
|
||
],
|
||
}
|
||
url = settings.llm_base_url.rstrip("/") + "/chat/completions"
|
||
request = urllib.request.Request(
|
||
url,
|
||
data=json.dumps(request_body).encode("utf-8"),
|
||
headers={"Content-Type": "application/json", "Authorization": f"Bearer {settings.llm_api_key}"},
|
||
method="POST",
|
||
)
|
||
with urllib.request.urlopen(request, timeout=settings.llm_timeout_seconds) as response:
|
||
result = json.loads(response.read().decode("utf-8"))
|
||
return _parse_ocr_content(result["choices"][0]["message"]["content"])
|
||
|
||
|
||
def _recognize_one_image(index: int, image: tuple[bytes, str]) -> tuple[int, list[dict]]:
|
||
image_data, content_type = _compress_ocr_image(*image)
|
||
for attempt in range(2):
|
||
try:
|
||
items = _extract_questions_from_image(image_data, content_type)
|
||
if items:
|
||
return index, items
|
||
raise ValueError("vision model returned no valid questions")
|
||
except Exception:
|
||
logger.warning(
|
||
"Question OCR failed for image %s on attempt %s/2",
|
||
index + 1,
|
||
attempt + 1,
|
||
exc_info=True,
|
||
)
|
||
if attempt == 0:
|
||
time.sleep(0.5)
|
||
return index, []
|
||
|
||
|
||
def extract_questions_from_images(images: list[tuple[bytes, str]]) -> list[dict]:
|
||
"""Extract consumer questions from one or more Taobao Q&A screenshots.
|
||
|
||
The configured OpenAI-compatible model must support image input. Each
|
||
screenshot is compressed and recognized independently. Failed image
|
||
requests are retried once, then successful results are merged and deduped.
|
||
"""
|
||
if not settings.llm_api_key or not images:
|
||
return []
|
||
recognized: dict[int, list[dict]] = {}
|
||
with ThreadPoolExecutor(max_workers=min(3, len(images))) as executor:
|
||
futures = {
|
||
executor.submit(_recognize_one_image, index, image): index
|
||
for index, image in enumerate(images)
|
||
}
|
||
for future in as_completed(futures):
|
||
index, items = future.result()
|
||
recognized[index] = items
|
||
|
||
merged = []
|
||
seen = set()
|
||
for index in range(len(images)):
|
||
for item in recognized.get(index, []):
|
||
key = re.sub(r"[\s，。！？、,.!?]+", "", item["question"]).lower()
|
||
if not key or key in seen:
|
||
continue
|
||
seen.add(key)
|
||
merged.append({**item, "source_index": index})
|
||
return merged[:100]
|