449 lines
18 KiB
Python
449 lines
18 KiB
Python
from __future__ import annotations
|
||
|
||
import uuid
|
||
from http import HTTPStatus
|
||
from typing import Any
|
||
|
||
from repositories.history_repository import (
|
||
append_generated_history,
|
||
load_history_for_config,
|
||
upsert_generated_history,
|
||
)
|
||
|
||
|
||
def _normalize_key_fields(value: Any) -> list[str]:
|
||
key_fields = value if isinstance(value, list) else []
|
||
if not key_fields:
|
||
key_fields = ["branch", "amount", "type"]
|
||
return [str(x) for x in key_fields]
|
||
|
||
|
||
def run_parse_api(payload: dict[str, Any], ctx: dict[str, Any]) -> tuple[HTTPStatus, dict[str, Any]]:
|
||
normalize_insurance_year = ctx["normalize_insurance_year"]
|
||
normalize_insurance_year_choices = ctx["normalize_insurance_year_choices"]
|
||
load_config = ctx["load_config"]
|
||
parse_records = ctx["parse_records"]
|
||
log_parse_skipped = ctx["log_parse_skipped"]
|
||
append_review_log = ctx["append_review_log"]
|
||
|
||
raw_text = str(payload.get("raw_text", ""))
|
||
try:
|
||
insurance_year_choice = normalize_insurance_year(payload.get("insurance_year"))
|
||
insurance_year_choices = normalize_insurance_year_choices(payload.get("insurance_year_choices"))
|
||
config = load_config()
|
||
_, history = load_history_for_config(config, ctx)
|
||
result = parse_records(raw_text, config, history, insurance_year_choice, insurance_year_choices)
|
||
log_parse_skipped(result.get("skipped", []), source="api_parse")
|
||
return HTTPStatus.OK, {"ok": True, "result": result}
|
||
except ValueError as exc:
|
||
return HTTPStatus.BAD_REQUEST, {"ok": False, "error": str(exc)}
|
||
except Exception as exc:
|
||
append_review_log(
|
||
"parse_api_error",
|
||
{
|
||
"error": str(exc),
|
||
"raw_text": raw_text,
|
||
},
|
||
)
|
||
return HTTPStatus.INTERNAL_SERVER_ERROR, {"ok": False, "error": str(exc)}
|
||
|
||
|
||
def run_generate_api(payload: dict[str, Any], ctx: dict[str, Any]) -> tuple[HTTPStatus, dict[str, Any]]:
|
||
normalize_insurance_year = ctx["normalize_insurance_year"]
|
||
normalize_insurance_year_choices = ctx["normalize_insurance_year_choices"]
|
||
load_config = ctx["load_config"]
|
||
resolve_template_path = ctx["resolve_template_path"]
|
||
resolve_output_dir = ctx["resolve_output_dir"]
|
||
parse_records = ctx["parse_records"]
|
||
generate_records = ctx["generate_records"]
|
||
set_generation_progress = ctx["set_generation_progress"]
|
||
append_review_log = ctx["append_review_log"]
|
||
log_parse_skipped = ctx["log_parse_skipped"]
|
||
resolve_single_generation_mode = ctx.get("resolve_single_generation_mode")
|
||
acquire_generation_slot = ctx.get("acquire_generation_slot")
|
||
release_generation_slot = ctx.get("release_generation_slot")
|
||
|
||
raw_text = str(payload.get("raw_text", ""))
|
||
progress_token = str(payload.get("progress_token", "")).strip() or uuid.uuid4().hex
|
||
slot_acquired = False
|
||
try:
|
||
template_override = str(payload.get("template_file", "")).strip() or None
|
||
output_override = str(payload.get("output_dir", "")).strip() or None
|
||
insurance_year_choice = normalize_insurance_year(payload.get("insurance_year"))
|
||
insurance_year_choices = normalize_insurance_year_choices(payload.get("insurance_year_choices"))
|
||
save_history_flag = bool(payload.get("save_history", True))
|
||
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="running",
|
||
stage="接收请求",
|
||
percent=1,
|
||
detail="已收到生成请求",
|
||
)
|
||
|
||
config = load_config()
|
||
single_mode = bool(resolve_single_generation_mode(config)) if callable(resolve_single_generation_mode) else True
|
||
if single_mode and callable(acquire_generation_slot):
|
||
slot_acquired = bool(acquire_generation_slot(progress_token))
|
||
if not slot_acquired:
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="busy",
|
||
stage="系统繁忙",
|
||
percent=0,
|
||
detail="已有任务在生成，请稍后重试",
|
||
)
|
||
return (
|
||
HTTPStatus.TOO_MANY_REQUESTS,
|
||
{
|
||
"ok": False,
|
||
"error": "generate_busy",
|
||
"error_code": "generate_busy",
|
||
"message": "已有任务在生成，请稍后再试。",
|
||
"progress_token": progress_token,
|
||
},
|
||
)
|
||
history_path, history = load_history_for_config(config, ctx)
|
||
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="running",
|
||
stage="解析文本",
|
||
percent=8,
|
||
detail="正在解析接龙内容",
|
||
)
|
||
parse_result = parse_records(
|
||
raw_text,
|
||
config,
|
||
history,
|
||
insurance_year_choice,
|
||
insurance_year_choices,
|
||
)
|
||
log_parse_skipped(parse_result.get("skipped", []), source="api_generate")
|
||
|
||
if parse_result.get("needs_insurance_choice") and insurance_year_choice is None:
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="need_input",
|
||
stage="等待选择",
|
||
percent=15,
|
||
detail="检测到保险记录，等待选择3年交/5年交",
|
||
)
|
||
return (
|
||
HTTPStatus.BAD_REQUEST,
|
||
{
|
||
"ok": False,
|
||
"error": "insurance_year_required",
|
||
"error_code": "insurance_year_required",
|
||
"result": parse_result,
|
||
"options": ["3", "5"],
|
||
"message": "检测到保险记录但未指定年限，请逐条选择3年交或5年交。",
|
||
"progress_token": progress_token,
|
||
},
|
||
)
|
||
|
||
new_records = parse_result.get("new_records", [])
|
||
if not isinstance(new_records, list):
|
||
new_records = []
|
||
|
||
if not new_records:
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="done",
|
||
stage="完成",
|
||
percent=100,
|
||
detail="没有可生成的新记录",
|
||
)
|
||
return (
|
||
HTTPStatus.OK,
|
||
{
|
||
"ok": True,
|
||
"message": "没有可生成的新记录",
|
||
"result": parse_result,
|
||
"generated_count": 0,
|
||
"progress_token": progress_token,
|
||
},
|
||
)
|
||
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="running",
|
||
stage="准备模板",
|
||
percent=12,
|
||
detail=f"待生成 {len(new_records)} 条",
|
||
)
|
||
template_path = resolve_template_path(config, template_override)
|
||
output_dir = resolve_output_dir(config, output_override)
|
||
|
||
def on_progress(percent: int, stage: str, detail: str) -> None:
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="running",
|
||
stage=stage,
|
||
percent=percent,
|
||
detail=detail,
|
||
)
|
||
|
||
gen_result = generate_records(
|
||
new_records,
|
||
config,
|
||
template_path,
|
||
output_dir,
|
||
progress_cb=on_progress,
|
||
)
|
||
|
||
history_stat = None
|
||
if save_history_flag:
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="running",
|
||
stage="更新历史",
|
||
percent=96,
|
||
detail="写入历史记录",
|
||
)
|
||
key_fields = _normalize_key_fields(parse_result.get("dedup_key_fields", ["branch", "amount", "type"]))
|
||
history_stat = append_generated_history(
|
||
history_path=history_path,
|
||
generated_items=gen_result.get("generated", []),
|
||
key_fields=key_fields,
|
||
ctx=ctx,
|
||
)
|
||
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="done",
|
||
stage="完成",
|
||
percent=100,
|
||
detail=f"已生成 {gen_result.get('generated_count', 0)} 张",
|
||
)
|
||
|
||
return (
|
||
HTTPStatus.OK,
|
||
{
|
||
"ok": True,
|
||
"message": "生成完成",
|
||
"result": parse_result,
|
||
"generated_count": gen_result.get("generated_count", 0),
|
||
"generated": gen_result.get("generated", []),
|
||
"download_images": gen_result.get("download_images", []),
|
||
"generation_strategy": gen_result.get("generation_strategy", "legacy"),
|
||
"history": history_stat,
|
||
"progress_token": progress_token,
|
||
},
|
||
)
|
||
except ValueError as exc:
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="error",
|
||
stage="失败",
|
||
percent=100,
|
||
detail="请求参数错误",
|
||
error=str(exc),
|
||
)
|
||
return HTTPStatus.BAD_REQUEST, {"ok": False, "error": str(exc)}
|
||
except Exception as exc:
|
||
append_review_log(
|
||
"generate_api_error",
|
||
{
|
||
"error": str(exc),
|
||
"raw_text": raw_text,
|
||
},
|
||
)
|
||
set_generation_progress(
|
||
progress_token,
|
||
status="error",
|
||
stage="失败",
|
||
percent=100,
|
||
detail="生成过程异常",
|
||
error=str(exc),
|
||
)
|
||
return HTTPStatus.INTERNAL_SERVER_ERROR, {"ok": False, "error": str(exc)}
|
||
finally:
|
||
if slot_acquired and callable(release_generation_slot):
|
||
release_generation_slot(progress_token)
|
||
|
||
|
||
def run_correction_apply_api(payload: dict[str, Any], ctx: dict[str, Any]) -> tuple[HTTPStatus, dict[str, Any]]:
|
||
load_config = ctx["load_config"]
|
||
resolve_template_path = ctx["resolve_template_path"]
|
||
resolve_output_dir = ctx["resolve_output_dir"]
|
||
resolve_history_path = ctx["resolve_history_path"]
|
||
normalize_line = ctx["normalize_line"]
|
||
normalize_branch_value = ctx["normalize_branch_value"]
|
||
normalize_amount_text = ctx["normalize_amount_text"]
|
||
normalize_status_value = ctx["normalize_status_value"]
|
||
infer_page_from_type = ctx["infer_page_from_type"]
|
||
apply_record_overrides = ctx["apply_record_overrides"]
|
||
render_output_filename = ctx["render_output_filename"]
|
||
validate_record_for_generation = ctx["validate_record_for_generation"]
|
||
generate_records = ctx["generate_records"]
|
||
infer_correction_rule_keyword = ctx["infer_correction_rule_keyword"]
|
||
save_or_update_manual_rule = ctx["save_or_update_manual_rule"]
|
||
append_review_log = ctx["append_review_log"]
|
||
resolve_issue_marks_by_source_line = ctx["resolve_issue_marks_by_source_line"]
|
||
resolve_single_generation_mode = ctx.get("resolve_single_generation_mode")
|
||
acquire_generation_slot = ctx.get("acquire_generation_slot")
|
||
release_generation_slot = ctx.get("release_generation_slot")
|
||
|
||
issue_resolve_stat: dict[str, Any] = {"count": 0, "ids": []}
|
||
slot_acquired = False
|
||
try:
|
||
record = payload.get("record")
|
||
if not isinstance(record, dict):
|
||
raise ValueError("record is required")
|
||
overrides = payload.get("overrides", {})
|
||
if overrides is None:
|
||
overrides = {}
|
||
if not isinstance(overrides, dict):
|
||
raise ValueError("overrides must be an object")
|
||
|
||
config = load_config()
|
||
single_mode = bool(resolve_single_generation_mode(config)) if callable(resolve_single_generation_mode) else True
|
||
if single_mode and callable(acquire_generation_slot):
|
||
slot_acquired = bool(acquire_generation_slot("correction_apply"))
|
||
if not slot_acquired:
|
||
return (
|
||
HTTPStatus.TOO_MANY_REQUESTS,
|
||
{
|
||
"ok": False,
|
||
"error": "generate_busy",
|
||
"error_code": "generate_busy",
|
||
"message": "已有任务在生成，请稍后再试。",
|
||
},
|
||
)
|
||
template_override = str(payload.get("template_file", "")).strip() or None
|
||
output_override = str(payload.get("output_dir", "")).strip() or None
|
||
template_path = resolve_template_path(config, template_override)
|
||
output_dir = resolve_output_dir(config, output_override)
|
||
history_path = resolve_history_path(config)
|
||
|
||
relay_cfg = config.get("relay_handling", {})
|
||
parse_rules = relay_cfg.get("parse_rules", {}) if isinstance(relay_cfg, dict) else {}
|
||
line_pattern = str(parse_rules.get("line_pattern", r"^\d+、\s*"))
|
||
|
||
source_line = str(record.get("source_line", "")).strip()
|
||
raw_text = str(record.get("raw_text", "")).strip()
|
||
normalized_line = normalize_line(source_line or raw_text, line_pattern)
|
||
|
||
base_record = {
|
||
"source_line": source_line or raw_text,
|
||
"raw_text": normalized_line or raw_text,
|
||
"branch": normalize_branch_value(record.get("branch", ""), config),
|
||
"amount": normalize_amount_text(record.get("amount", "")),
|
||
"type": str(record.get("type", "")).strip(),
|
||
"page": str(record.get("page", "")).strip(),
|
||
"status": normalize_status_value(str(record.get("status", "")).strip(), config),
|
||
"output_file": str(record.get("output_file", "")).strip(),
|
||
}
|
||
if not base_record["page"] and base_record["type"]:
|
||
base_record["page"] = infer_page_from_type(base_record["type"], config)
|
||
|
||
corrected = apply_record_overrides(base_record, overrides, config)
|
||
corrected["source_line"] = str(corrected.get("source_line") or source_line or raw_text)
|
||
corrected["raw_text"] = normalize_line(str(corrected.get("raw_text") or normalized_line), line_pattern)
|
||
if not corrected.get("output_file"):
|
||
corrected["output_file"] = render_output_filename(config, corrected, 1)
|
||
validate_record_for_generation(corrected, config)
|
||
|
||
gen_result = generate_records(
|
||
[corrected],
|
||
config,
|
||
template_path,
|
||
output_dir,
|
||
progress_cb=None,
|
||
)
|
||
|
||
relay_cfg = config.get("relay_handling", {})
|
||
dedup_cfg = relay_cfg.get("dedup", {}) if isinstance(relay_cfg, dict) else {}
|
||
key_fields = _normalize_key_fields(dedup_cfg.get("key_fields", ["branch", "amount", "type"]))
|
||
history_stat = upsert_generated_history(
|
||
history_path=history_path,
|
||
generated_items=gen_result.get("generated", []),
|
||
key_fields=key_fields,
|
||
ctx=ctx,
|
||
)
|
||
|
||
remember_rule = bool(payload.get("remember_rule", False))
|
||
remember_amount = bool(payload.get("remember_amount", False))
|
||
rule_keyword = str(payload.get("rule_keyword", "")).strip()
|
||
note = str(payload.get("note", "")).strip()
|
||
applied_rule = None
|
||
if remember_rule:
|
||
rule_updates: dict[str, Any] = {}
|
||
for field in ("branch", "type", "page", "status", "amount"):
|
||
if field not in overrides:
|
||
continue
|
||
val = str(corrected.get(field, "")).strip()
|
||
if val:
|
||
rule_updates[field] = val
|
||
if not remember_amount:
|
||
rule_updates.pop("amount", None)
|
||
if rule_updates:
|
||
keyword = rule_keyword or infer_correction_rule_keyword(
|
||
source_line=str(corrected.get("source_line", "")),
|
||
normalized_line=str(corrected.get("raw_text", "")),
|
||
corrected_record=corrected,
|
||
)
|
||
applied_rule = save_or_update_manual_rule(
|
||
keyword=keyword,
|
||
updates=rule_updates,
|
||
note=note,
|
||
match_mode=str(payload.get("rule_mode", "normalized")),
|
||
)
|
||
|
||
append_review_log(
|
||
"manual_correction_apply",
|
||
{
|
||
"source_line": str(corrected.get("source_line", "")),
|
||
"record_before": base_record,
|
||
"record_after": corrected,
|
||
"overrides": overrides,
|
||
"remember_rule": remember_rule,
|
||
"rule": applied_rule,
|
||
"note": note,
|
||
},
|
||
)
|
||
issue_resolve_stat = resolve_issue_marks_by_source_line(
|
||
str(corrected.get("source_line", "")),
|
||
reason="manual_correction_apply",
|
||
)
|
||
if int(issue_resolve_stat.get("count", 0)) > 0:
|
||
append_review_log(
|
||
"issue_auto_resolve",
|
||
{
|
||
"source_line": str(corrected.get("source_line", "")),
|
||
"resolved_issue_count": int(issue_resolve_stat.get("count", 0)),
|
||
"resolved_issue_ids": issue_resolve_stat.get("ids", []),
|
||
},
|
||
)
|
||
|
||
return (
|
||
HTTPStatus.OK,
|
||
{
|
||
"ok": True,
|
||
"message": "修正已生成",
|
||
"generated_count": gen_result.get("generated_count", 0),
|
||
"generated": gen_result.get("generated", []),
|
||
"download_images": gen_result.get("download_images", []),
|
||
"generation_strategy": gen_result.get("generation_strategy", "legacy"),
|
||
"history": history_stat,
|
||
"rule": applied_rule,
|
||
"resolved_issue_count": int(issue_resolve_stat.get("count", 0)),
|
||
"resolved_issue_ids": issue_resolve_stat.get("ids", []),
|
||
},
|
||
)
|
||
except ValueError as exc:
|
||
return HTTPStatus.BAD_REQUEST, {"ok": False, "error": str(exc)}
|
||
except Exception as exc:
|
||
append_review_log(
|
||
"manual_correction_error",
|
||
{
|
||
"error": str(exc),
|
||
"record": payload.get("record") if isinstance(payload, dict) else {},
|
||
},
|
||
)
|
||
return HTTPStatus.INTERNAL_SERVER_ERROR, {"ok": False, "error": str(exc)}
|
||
finally:
|
||
if slot_acquired and callable(release_generation_slot):
|
||
release_generation_slot("correction_apply")
|