1213 lines
49 KiB
Python
1213 lines
49 KiB
Python
"""
|
||
标书内容生成模块 - 极速并发优化版
|
||
全局LLM_SEMAPHORE(上限20) + 并行解析 + 更高池上限。
|
||
流程：生成大纲 → 解析章节树 → 并发生成内容
|
||
"""
|
||
import re
|
||
import random
|
||
import sqlite3
|
||
import logging
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||
from datetime import datetime
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
import config
|
||
from utils import ai_client, prompts as P
|
||
from utils import word_allocation as word_alloc
|
||
from utils import volume_chapters as vol_ch
|
||
from utils import diagram_intent as diagram_int
|
||
from utils import attachment_section as att_sec
|
||
from utils.outline_numbering import format_heading_display
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
BID_WRITING_SYSTEM = (
|
||
'你是一位资深的工程投标文件撰写专家，擅长以执行方视角撰写技术方案正文。'
|
||
'撰写时必须遵守以下铁律：'
|
||
|
||
'①【字数】用户规定的最低字数必须满足，但字数须由实质内容支撑，'
|
||
'不得用重复背景、堆砌承诺或复述要求来凑字数；'
|
||
|
||
'②【自称】投标方自称统一用"我方"，禁用"我们""我公司"；'
|
||
|
||
'③【禁止套话】禁用：综上所述、首先其次再次、我们深信、高度重视、全力以赴、'
|
||
'竭诚服务、不断优化、稳步推进、通过以上措施、我方将严格按照、我方承诺、'
|
||
'确保圆满完成、切实保障；'
|
||
|
||
'④【禁止前导句】严禁：本章节对应……、本小节主要说明……、'
|
||
'以下将从……方面说明、针对招标方要求……、根据招标文件……我方将……——'
|
||
'开头直接写实质内容；'
|
||
|
||
'⑤【禁止复述要求】招标文件给出的技术参数、工程量、服务数量、规范标准等均视为'
|
||
'已知条件，直接体现在方案中，禁止先复读要求再作答；'
|
||
'不用"满足招标方提出的XXX要求""针对招标文件第X条"等句式；'
|
||
|
||
'⑥【禁止重申背景——最常见的废稿场景】'
|
||
'禁止在章节正文中出现项目名称、建设单位、建设地点、工程规模、合同工期等基本信息；'
|
||
'尤其严禁将招标文件中的具体工程量数字（如"X条渠道""X公里""X座建筑物""X台设备"等）'
|
||
'反复引入到各个章节开头作为背景铺垫——'
|
||
'这类数字只能在专门的"项目概况/项目背景"章节出现一次，'
|
||
'质量、安全、进度、技术方案、人员配置等专业章节一律直接展开专业内容；'
|
||
|
||
'⑦【禁止虚构优越参数】严禁为了显示"超越"招标要求而捏造参数或数量：'
|
||
'招标文件要求多少就按多少写，不得无依据地写成"优于要求""高于标准"；'
|
||
'如需体现竞争力，只能在工艺方法、管理措施、响应速度等可具体描述的维度展开，'
|
||
'不得在规格数量上自行拔高；'
|
||
|
||
'⑧【实质可检验】每项措施须给出具体做法、操作步骤、管理节点或时间节点；'
|
||
'凡写数量、型号、吨位、强度、时限等量化内容，须能在招标文件或工程量清单摘要中找到依据，'
|
||
'无依据处不写具体数字与型号，改用"按设计要求""与工况及进度相匹配""符合相应规范等级"等完整中文概括表述，'
|
||
'不做空洞承诺；'
|
||
|
||
'⑨【行文格式】纯文本，段落间空行分隔，列举用(1)(2)(3)编号，'
|
||
'不用markdown符号，不用连接词串联，不用"等"作结尾。'
|
||
|
||
'⑩【禁止占位符】方案叙述中严禁半角或全角方括号形式的未完稿待填（如[型号][数量][数值][X][Y]等），'
|
||
'亦不得用「待填」「TBD」留白；语义须用通顺的陈述句一次写清。'
|
||
'若另有图示/表格专用输出规范要求使用约定标记，仅在该规范限定的标记内可使用方括号。'
|
||
)
|
||
|
||
# 篇幅档位：key → (基础小节字数, 核心章节字数, 标签, 期望max_tokens)
|
||
VOLUME_PRESETS = {
|
||
'concise': (1200, 2500, '精简版', 5000),
|
||
'standard': (2000, 4000, '标准版', 8000),
|
||
'detailed': (3000, 5500, '详细版', 12000),
|
||
'full': (4000, 7000, '充实版', 16000),
|
||
}
|
||
|
||
|
||
def _effective_volume() -> str:
|
||
"""
|
||
生成阶段使用的篇幅档位。
|
||
简化策略：若设置了目标页数，则按页数粗略映射到四档；否则沿用 CONTENT_VOLUME。
|
||
"""
|
||
pages = int(getattr(config, 'TARGET_PAGES', 0) or 0)
|
||
return vol_ch.volume_key_from_target_pages(
|
||
pages, getattr(config, 'CONTENT_VOLUME', 'standard'),
|
||
)
|
||
|
||
# 各模型提供商的 max_tokens 硬上限
|
||
_PROVIDER_TOKEN_LIMITS = {
|
||
'deepseek': 8192,
|
||
'qwen': 8192,
|
||
'openai': 16384,
|
||
}
|
||
|
||
|
||
def _get_word_count_spec(volume: str) -> str:
|
||
"""根据篇幅档位返回嵌入提示词的字数要求段落"""
|
||
base, core, _, _ = VOLUME_PRESETS.get(volume, VOLUME_PRESETS['standard'])
|
||
pages = int(getattr(config, 'TARGET_PAGES', 0) or 0)
|
||
page_note = f'\n- 目标页数：约 {pages} 页（按粗略换算生效）' if pages > 0 else ''
|
||
return (
|
||
f'- 字数硬性要求（必须达到，不达标将被退回重写）：\n'
|
||
f' · 一般小节：不少于 {base} 字\n'
|
||
f' · 核心技术/重点评分章节：不少于 {core} 字\n'
|
||
f'{page_note}'
|
||
f'- 内容必须充分展开，每个要点均需具体阐述，不得一笔带过\n'
|
||
f'- 宁多勿少，写满写透，篇幅不足是最严重的质量问题'
|
||
)
|
||
|
||
|
||
def _get_max_tokens(volume: str) -> int:
|
||
"""根据篇幅档位返回 AI 调用的 max_tokens，自动适配提供商上限"""
|
||
_, _, _, tokens = VOLUME_PRESETS.get(volume, VOLUME_PRESETS['standard'])
|
||
provider = getattr(config, 'MODEL_PROVIDER', 'openai')
|
||
limit = _PROVIDER_TOKEN_LIMITS.get(provider, 8192)
|
||
return min(tokens, limit)
|
||
|
||
|
||
def _get_min_chars(volume: str) -> int:
|
||
"""触发续写的最低字数阈值（基础小节字数的 65%，略低于目标以多轮补足）"""
|
||
base, _, _, _ = VOLUME_PRESETS.get(volume, VOLUME_PRESETS['standard'])
|
||
return int(base * 0.65)
|
||
|
||
|
||
# 中文数字映射
|
||
CN_NUM_MAP = {
|
||
'一': 1, '二': 2, '三': 3, '四': 4, '五': 5,
|
||
'六': 6, '七': 7, '八': 8, '九': 9, '十': 10,
|
||
'十一': 11, '十二': 12, '十三': 13, '十四': 14, '十五': 15,
|
||
}
|
||
|
||
|
||
# ─── 大纲生成 ─────────────────────────────────────────────────────────────
|
||
|
||
def generate_outline(db_path: str, project_id: int) -> None:
|
||
"""后台：生成标书大纲并存入 bid_sections"""
|
||
conn = sqlite3.connect(db_path)
|
||
try:
|
||
_set_project_status(conn, project_id, 'outline_generating')
|
||
|
||
td = _get_tender_data(conn, project_id)
|
||
if not td:
|
||
raise ValueError('尚未解析招标文件，请先解析')
|
||
|
||
summary = td['summary'] or ''
|
||
rating = td['rating_requirements'] or ''
|
||
|
||
if rating:
|
||
prompt = P.get_outlines_with_rating_prompt(summary, rating)
|
||
else:
|
||
prompt = P.get_outlines_prompt(summary or td['raw_text'] or '')
|
||
|
||
outline_text = ai_client.chat(
|
||
prompt,
|
||
temperature=0.5,
|
||
max_tokens=4096,
|
||
request_timeout=getattr(config, 'OUTLINE_REQUEST_TIMEOUT', 300),
|
||
)
|
||
|
||
# 解析章节并自动重排序号，保存规范化后的大纲文本
|
||
bid_title, sections, normalized_text = _parse_outline(outline_text)
|
||
_save_outline_text(conn, project_id, normalized_text)
|
||
_save_sections(conn, project_id, sections)
|
||
|
||
_set_project_status(conn, project_id, 'outline_done')
|
||
logger.info(f'项目 {project_id} 大纲生成完成，共 {len(sections)} 节')
|
||
|
||
except Exception as e:
|
||
logger.exception(f'大纲生成失败 project_id={project_id}')
|
||
_set_project_status(conn, project_id, 'outline_error', str(e))
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
# ─── 章节内容生成 ──────────────────────────────────────────────────────────
|
||
|
||
def generate_section(db_path: str, project_id: int, section_id: int,
|
||
anon_requirements: str = '',
|
||
enable_figure: bool = False,
|
||
enable_table: bool = False) -> None:
|
||
"""后台：为指定 section 生成正文内容（单个章节入口，自行读取上下文）"""
|
||
conn = sqlite3.connect(db_path)
|
||
try:
|
||
section = _get_section(conn, section_id)
|
||
if not section:
|
||
raise ValueError(f'Section {section_id} 不存在')
|
||
|
||
td = _get_tender_data(conn, project_id)
|
||
outline_text = _get_outline_text(conn, project_id)
|
||
if not outline_text.strip():
|
||
raise ValueError('当前项目尚无可用大纲，请先保存或生成大纲')
|
||
summary = (td or {}).get('summary', '')
|
||
boq_summary = (td or {}).get('boq_summary', '')
|
||
conn.close()
|
||
conn = None
|
||
|
||
tender_kind = (td or {}).get('tender_kind', 'engineering') or 'engineering'
|
||
outline_head = outline_text.strip().splitlines()[0][:50] if outline_text.strip() else ''
|
||
logger.info(
|
||
f'章节生成读取大纲 project_id={project_id}, section_id={section_id}, '
|
||
f'outline_len={len(outline_text)}, outline_head="{outline_head}"'
|
||
)
|
||
alloc_map = _project_allocation_map(db_path, project_id)
|
||
override = alloc_map.get(section_id) if alloc_map else None
|
||
_generate_one(db_path, section, summary, outline_text,
|
||
anon_requirements, enable_figure, enable_table,
|
||
boq_summary, tender_kind, override)
|
||
|
||
except Exception as e:
|
||
logger.exception(f'章节生成失败 section_id={section_id}')
|
||
_update_section_status_safe(db_path, section_id, 'error', str(e))
|
||
finally:
|
||
if conn:
|
||
conn.close()
|
||
|
||
|
||
MAX_CONTINUE_ROUNDS = 3 # 极速优化：从5减少到3，减少额外AI调用次数（结合改进prompt更易一次写满）
|
||
# 单次续写目标字数上限：与 DeepSeek/Qwen 8192 max_tokens 下的实际中文产出量匹配，略保守更易写满
|
||
_CONTINUE_CHUNK_CAP = 2800
|
||
_CONTINUE_TAIL_CHARS = 2200
|
||
|
||
|
||
def _auto_continue(content: str, min_chars: int, max_tok: int, title: str,
|
||
system: str = BID_WRITING_SYSTEM) -> str:
|
||
"""
|
||
自动续写：当首次生成的内容字数不足时，发起独立的续写调用。
|
||
不传入完整的原始 prompt（太长会挤占输出空间），而是只提供
|
||
已有内容的末尾部分作为上下文，让 AI 集中精力续写。
|
||
"""
|
||
for round_i in range(MAX_CONTINUE_ROUNDS):
|
||
if len(content) >= min_chars:
|
||
break
|
||
|
||
remaining = min_chars - len(content)
|
||
if remaining <= 200:
|
||
break
|
||
|
||
# 本轮只要求「差额」的一部分，多轮叠加更易达到总目标
|
||
chunk_goal = min(remaining, _CONTINUE_CHUNK_CAP)
|
||
|
||
tail = (
|
||
content[-_CONTINUE_TAIL_CHARS:]
|
||
if len(content) > _CONTINUE_TAIL_CHARS
|
||
else content
|
||
)
|
||
|
||
cont_prompt = (
|
||
f'以下是投标文件「{title}」小节已撰写的部分内容（末尾段落）：\n\n'
|
||
f'{tail}\n\n'
|
||
f'━━━━━━━━━━━━━━━━━━━━━━━━━\n'
|
||
f'当前累计 {len(content)} 字，本节最低要求 {min_chars} 字，'
|
||
f'全文总差额约 {remaining} 字。\n'
|
||
f'请紧接上文末尾继续撰写，要求：\n'
|
||
f'(1) 不重复、不复述上文已有段落，自然衔接续写\n'
|
||
f'(2) 深入展开实施细节、技术参数、岗位、设备、流程与验收要点\n'
|
||
f'(3) 保持"我方"口吻，禁止AI套话与前导说明句\n'
|
||
f'(4) 直接输出续写正文，不写"续写如下"等引导语\n'
|
||
f'(5) 本轮续写不少于 {chunk_goal} 字，尽量写满\n'
|
||
)
|
||
|
||
logger.info(
|
||
f'[续写] "{title}" 第{round_i+1}轮 '
|
||
f'({len(content)}/{min_chars}字, 差{remaining}字, 本轮目标≥{chunk_goal}字)'
|
||
)
|
||
|
||
try:
|
||
extra = ai_client.chat(
|
||
cont_prompt,
|
||
system=system,
|
||
temperature=0.7,
|
||
max_tokens=max_tok,
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f'[续写] "{title}" 第{round_i+1}轮失败: {e}')
|
||
break
|
||
|
||
if not extra or len(extra.strip()) < 80:
|
||
logger.info(f'[续写] "{title}" 第{round_i+1}轮返回内容过短，终止')
|
||
break
|
||
|
||
content = content.rstrip() + '\n\n' + extra.strip()
|
||
logger.info(
|
||
f'[续写] "{title}" 第{round_i+1}轮完成，'
|
||
f'+{len(extra.strip())}字，累计{len(content)}字'
|
||
)
|
||
|
||
logger.info(f'"{title}" 最终字数：{len(content)}')
|
||
return content
|
||
|
||
|
||
def _build_writing_system(anon_requirements: str = '') -> str:
|
||
"""根据暗标要求动态构建 system prompt"""
|
||
anon = anon_requirements.strip()
|
||
if not anon:
|
||
return BID_WRITING_SYSTEM
|
||
return (
|
||
BID_WRITING_SYSTEM
|
||
+ '\n\n【暗标合规要求（最高优先级，每个章节均须严格遵守）】\n'
|
||
+ anon
|
||
)
|
||
|
||
|
||
def _get_knowledge_context(title: str) -> str:
|
||
"""从企业知识库检索与章节标题相关的参考内容，供 AI 写作参考。
|
||
若知识库未安装或为空，静默返回空字符串。"""
|
||
try:
|
||
from modules.knowledge import search
|
||
chunks = search(title, top_k=config.TOP_K_KNOWLEDGE)
|
||
if not chunks:
|
||
return ''
|
||
parts = []
|
||
for i, chunk in enumerate(chunks, 1):
|
||
parts.append(f'[参考片段{i}]\n{chunk[:600]}')
|
||
return (
|
||
'\n\n【企业知识库参考内容（以下摘自历史投标文件，仅供参考，'
|
||
'须结合本项目实际情况重新撰写，禁止直接照抄）】\n'
|
||
+ '\n\n'.join(parts)
|
||
)
|
||
except Exception:
|
||
return ''
|
||
|
||
|
||
def _leaf_rows_for_allocation(conn, project_id: int) -> list:
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
'SELECT id, section_title FROM bid_sections WHERE project_id=? AND is_leaf=1 '
|
||
'ORDER BY order_index',
|
||
(project_id,),
|
||
)
|
||
return [{'id': r[0], 'section_title': (r[1] or '').strip()} for r in cur.fetchall()]
|
||
|
||
|
||
def _project_allocation_map(db_path: str, project_id: int) -> Optional[Dict[int, Dict[str, Any]]]:
|
||
"""按规则与叶节点全表计算各节目标字数。无有效评分时：若已设目标页且走 target_pages 分配，仍均分全稿总预算；否则 None。"""
|
||
try:
|
||
conn = sqlite3.connect(db_path)
|
||
try:
|
||
leaves = _leaf_rows_for_allocation(conn, project_id)
|
||
if not leaves:
|
||
return None
|
||
td = _get_tender_data(conn, project_id)
|
||
rating_raw = (td or {}).get('rating_json') or ''
|
||
vol = _effective_volume()
|
||
rules = word_alloc.load_rules()
|
||
return word_alloc.compute_leaf_allocations(vol, leaves, rating_raw, rules)
|
||
finally:
|
||
conn.close()
|
||
except Exception as e:
|
||
logger.warning('字数分配计算失败，回退统一篇幅: %s', e)
|
||
return None
|
||
|
||
|
||
def _build_diagram_addon_for_leaf(
|
||
section: dict,
|
||
outline_text: str,
|
||
enable_figure: bool,
|
||
enable_table: bool,
|
||
) -> str:
|
||
"""叶节点：按章节标题与大纲上下文的意图栈拼接图/表规范（受项目总开关约束）。"""
|
||
return diagram_int.get_diagram_agent().render_for_section(
|
||
section.get('section_title') or '',
|
||
outline_text or '',
|
||
enable_figure,
|
||
enable_table,
|
||
)
|
||
|
||
|
||
def _strip_line_serial_numbers(text: str) -> str:
|
||
"""
|
||
去除正文行首的纯序号（如 1. / 2、 / 370) / 12 ），保留正文语义。
|
||
"""
|
||
if not text:
|
||
return text
|
||
cleaned_lines = []
|
||
for line in text.splitlines():
|
||
cleaned = re.sub(r'^\s*\d{1,4}(?:[\.．、)\s]+)\s*', '', line)
|
||
cleaned_lines.append(cleaned)
|
||
return '\n'.join(cleaned_lines)
|
||
|
||
|
||
def _generate_one(db_path: str, section: dict, summary: str, outline_text: str,
|
||
anon_requirements: str = '',
|
||
enable_figure: bool = False,
|
||
enable_table: bool = False,
|
||
boq_summary: str = '',
|
||
tender_kind: str = 'engineering',
|
||
allocation_override: Optional[Dict[str, Any]] = None) -> None:
|
||
"""
|
||
核心生成函数：纯 AI 调用 + 结果写库。
|
||
不长期持有 DB 连接，适合在线程池中并发调用。
|
||
"""
|
||
section_id = section['id']
|
||
is_leaf = bool(section['is_leaf'])
|
||
title = section['section_title']
|
||
|
||
writing_system = _build_writing_system(anon_requirements)
|
||
_att_rules = att_sec.get_attachment_rules_cached()
|
||
_att_mode = att_sec.attachment_leaf_body_mode(_att_rules) if (
|
||
is_leaf and att_sec.is_attachment_only_section(title, _att_rules)
|
||
) else ''
|
||
_is_attachment_title = bool(is_leaf and bool(_att_mode))
|
||
_use_stack_charts = bool(
|
||
_is_attachment_title and att_sec.use_attachment_stack_charts_body(_att_rules),
|
||
)
|
||
diagram_addon = ''
|
||
if is_leaf and (enable_figure or enable_table) and not _use_stack_charts:
|
||
diagram_addon = _build_diagram_addon_for_leaf(
|
||
section, outline_text, enable_figure, enable_table,
|
||
)
|
||
|
||
_update_section_status_safe(db_path, section_id, 'generating')
|
||
|
||
try:
|
||
if is_leaf:
|
||
if _use_stack_charts:
|
||
stack = diagram_int.get_diagram_agent().plan(
|
||
title, outline_text, enable_figure, enable_table,
|
||
)
|
||
if _att_mode == 'single_chart_only' and len(stack) > 1:
|
||
stack = [stack[0]]
|
||
if not stack and (enable_figure or enable_table):
|
||
fk = att_sec.pick_single_figure_or_table(
|
||
title, enable_figure, enable_table, _att_rules,
|
||
)
|
||
if fk:
|
||
stack = diagram_int.make_fallback_stack(fk)
|
||
if not stack or (not enable_figure and not enable_table):
|
||
prompt = P.get_attachment_chart_disabled_prompt(title)
|
||
stack_sys = P.ATTACHMENT_STACK_CHARTS_SYSTEM
|
||
if (anon_requirements or '').strip():
|
||
stack_sys = stack_sys + '\n\n【合规】\n' + (anon_requirements or '')[:2000]
|
||
content = ai_client.chat(
|
||
prompt,
|
||
system=stack_sys,
|
||
temperature=0.45,
|
||
max_tokens=512,
|
||
)
|
||
else:
|
||
labels = diagram_int.stack_compact_labels(stack)
|
||
prompt = P.get_attachment_stack_charts_prompt(
|
||
summary, outline_text, title, labels,
|
||
)
|
||
stack_sys = P.ATTACHMENT_STACK_CHARTS_SYSTEM
|
||
if (anon_requirements or '').strip():
|
||
stack_sys = stack_sys + '\n\n【合规】\n' + (anon_requirements or '')[:2000]
|
||
content = ai_client.chat(
|
||
prompt,
|
||
system=stack_sys,
|
||
temperature=0.5,
|
||
max_tokens=3072,
|
||
)
|
||
content = _strip_line_serial_numbers(content)
|
||
_update_section_content_safe(db_path, section_id, content, '')
|
||
else:
|
||
volume = _effective_volume()
|
||
if allocation_override:
|
||
wc_spec = allocation_override['word_count_spec']
|
||
max_tok = int(allocation_override.get('max_tokens') or _get_max_tokens(volume))
|
||
tgt = int(allocation_override.get('target_chars') or 0)
|
||
min_chars = word_alloc.continuation_threshold(tgt) if tgt > 0 else _get_min_chars(volume)
|
||
else:
|
||
wc_spec = _get_word_count_spec(volume)
|
||
max_tok = _get_max_tokens(volume)
|
||
min_chars = _get_min_chars(volume)
|
||
|
||
prompt = P.get_section_detail_prompt(
|
||
summary, outline_text, title,
|
||
word_count_spec=wc_spec,
|
||
boq_summary=boq_summary,
|
||
tender_kind=tender_kind or 'engineering',
|
||
)
|
||
if _is_attachment_title:
|
||
prompt = prompt + P.get_attachment_chapter_emphasis_hint()
|
||
# 知识库检索：将历史标书相关片段作为写作参考注入提示词
|
||
knowledge_ctx = _get_knowledge_context(title)
|
||
if knowledge_ctx:
|
||
prompt = prompt + knowledge_ctx
|
||
|
||
if diagram_addon:
|
||
prompt = prompt + diagram_addon
|
||
|
||
content = ai_client.chat(
|
||
prompt,
|
||
system=writing_system,
|
||
temperature=0.7,
|
||
max_tokens=max_tok,
|
||
)
|
||
|
||
content = _auto_continue(content, min_chars, max_tok, title,
|
||
system=writing_system)
|
||
content = _strip_line_serial_numbers(content)
|
||
_update_section_content_safe(db_path, section_id, content, '')
|
||
else:
|
||
prompt = P.get_section_intro_prompt(summary, outline_text, title)
|
||
if prompt:
|
||
intro = ai_client.chat(
|
||
prompt,
|
||
system=writing_system,
|
||
temperature=0.4,
|
||
max_tokens=1024,
|
||
)
|
||
else:
|
||
intro = ''
|
||
intro = _strip_line_serial_numbers(intro)
|
||
_update_section_content_safe(db_path, section_id, '', intro)
|
||
|
||
_update_section_status_safe(db_path, section_id, 'done')
|
||
logger.info(f'Section {section_id} "{title}" 生成完成')
|
||
|
||
except Exception as e:
|
||
logger.exception(f'章节生成失败 section_id={section_id}')
|
||
_update_section_status_safe(db_path, section_id, 'error', str(e))
|
||
|
||
|
||
def generate_all_sections(db_path: str, project_id: int,
|
||
anon_requirements: str = '',
|
||
enable_figure: bool = False,
|
||
enable_table: bool = False) -> None:
|
||
"""
|
||
后台：并发生成所有章节（全局LLM_SEMAPHORE保护，总并发≤20）。
|
||
策略：先生成非叶节点(章节引言)，再并发生成所有叶节点(正文)。
|
||
并发数由 config.MAX_CONCURRENT_SECTIONS (默认12，可达20) 控制。
|
||
"""
|
||
try:
|
||
conn = sqlite3.connect(db_path)
|
||
cur = conn.cursor()
|
||
|
||
# 读取尚未生成的章节（跳过已完成的）
|
||
cur.execute('''
|
||
SELECT id, section_number, section_title, level, is_leaf, content, intro_content, status
|
||
FROM bid_sections WHERE project_id=? ORDER BY order_index
|
||
''', (project_id,))
|
||
rows = cur.fetchall()
|
||
|
||
td = _get_tender_data(conn, project_id)
|
||
outline_text = _get_outline_text(conn, project_id)
|
||
if not outline_text.strip():
|
||
conn.close()
|
||
raise ValueError('当前项目尚无可用大纲，请先保存或生成大纲')
|
||
summary = (td or {}).get('summary', '')
|
||
boq_summary = (td or {}).get('boq_summary', '')
|
||
tender_kind = (td or {}).get('tender_kind', 'engineering') or 'engineering'
|
||
outline_head = outline_text.strip().splitlines()[0][:50] if outline_text.strip() else ''
|
||
logger.info(
|
||
f'全量生成读取大纲 project_id={project_id}, outline_len={len(outline_text)}, outline_head="{outline_head}"'
|
||
)
|
||
alloc_map = _project_allocation_map(db_path, project_id)
|
||
conn.close()
|
||
|
||
all_sections = [
|
||
{'id': r[0], 'section_number': r[1], 'section_title': r[2],
|
||
'level': r[3], 'is_leaf': r[4], 'content': r[5], 'intro_content': r[6], 'status': r[7]}
|
||
for r in rows
|
||
]
|
||
|
||
# 只处理未完成的章节（pending / error 的重新生成）
|
||
sections = [s for s in all_sections if s.get('status') != 'done']
|
||
|
||
if not sections:
|
||
logger.info(f'项目 {project_id} 所有章节已生成完成，无需重新生成')
|
||
return
|
||
|
||
# 分组：非叶节点（章节引言，通常较短）+ 叶节点（正文内容，耗时较长）
|
||
non_leaf = [s for s in sections if not s['is_leaf']]
|
||
leaf = [s for s in sections if s['is_leaf']]
|
||
|
||
workers = max(1, config.MAX_CONCURRENT_SECTIONS)
|
||
# 极速优化：尊重全局LLM上限，避免continuation rounds导致超限
|
||
llm_limit = getattr(config, 'LLM_CONCURRENCY_LIMIT', 20)
|
||
workers = min(workers, max(1, llm_limit // 2)) # 保守分配，留空间给续写/知识检索
|
||
logger.info(
|
||
f'项目 {project_id} 开始并发生成: '
|
||
f'{len(non_leaf)} 个章节引言 + {len(leaf)} 个叶节点, '
|
||
f'并发数={workers} (LLM上限={llm_limit})'
|
||
)
|
||
|
||
# 第一阶段：并发生成非叶节点引言（通常很快）
|
||
if non_leaf:
|
||
_concurrent_generate(db_path, non_leaf, summary, outline_text, workers,
|
||
anon_requirements, enable_figure, enable_table,
|
||
boq_summary, tender_kind, None)
|
||
|
||
# 第二阶段：并发生成叶节点正文（主要耗时部分）
|
||
if leaf:
|
||
_concurrent_generate(db_path, leaf, summary, outline_text, workers,
|
||
anon_requirements, enable_figure, enable_table,
|
||
boq_summary, tender_kind, alloc_map)
|
||
|
||
# 统计结果
|
||
conn = sqlite3.connect(db_path)
|
||
cur = conn.cursor()
|
||
cur.execute('''
|
||
SELECT
|
||
COUNT(*) as total,
|
||
SUM(CASE WHEN status='done' THEN 1 ELSE 0 END) as done,
|
||
SUM(CASE WHEN status='error' THEN 1 ELSE 0 END) as errors
|
||
FROM bid_sections WHERE project_id=?
|
||
''', (project_id,))
|
||
total, done, errors = cur.fetchone()
|
||
conn.close()
|
||
logger.info(f'项目 {project_id} 全量生成完成: {done}/{total} 成功, {errors} 失败')
|
||
|
||
except Exception as e:
|
||
logger.exception(f'全量生成失败 project_id={project_id}')
|
||
|
||
|
||
def _concurrent_generate(db_path: str, sections: list, summary: str,
|
||
outline_text: str, workers: int,
|
||
anon_requirements: str = '',
|
||
enable_figure: bool = False,
|
||
enable_table: bool = False,
|
||
boq_summary: str = '',
|
||
tender_kind: str = 'engineering',
|
||
alloc_map: Optional[Dict[int, Dict[str, Any]]] = None) -> None:
|
||
"""用线程池并发生成一批章节"""
|
||
with ThreadPoolExecutor(max_workers=workers, thread_name_prefix='gen') as pool:
|
||
futures = {}
|
||
for s in sections:
|
||
override = alloc_map.get(s['id']) if alloc_map else None
|
||
f = pool.submit(_generate_one, db_path, s, summary, outline_text,
|
||
anon_requirements, enable_figure, enable_table,
|
||
boq_summary, tender_kind, override)
|
||
futures[f] = s
|
||
|
||
for f in as_completed(futures):
|
||
s = futures[f]
|
||
try:
|
||
f.result()
|
||
except Exception as e:
|
||
logger.error(f'章节 {s["id"]} "{s["section_title"]}" 异常: {e}')
|
||
|
||
|
||
# ─── 大纲解析 ─────────────────────────────────────────────────────────────
|
||
|
||
_CN_NUMS_LIST = [
|
||
'', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十',
|
||
'十一', '十二', '十三', '十四', '十五', '十六', '十七', '十八', '十九', '二十',
|
||
]
|
||
|
||
|
||
def _renumber_sections(sections: list) -> list:
|
||
"""
|
||
对章节列表按层级顺序重新编号，确保删除/增减章节后序号连续。
|
||
level 1 → 整数字符串 "1","2",...
|
||
level 2 → "1.1","1.2",...
|
||
level 3 → "1.1.1","1.1.2",...
|
||
level 4 → "1.1.1.1",...
|
||
直接修改传入列表中各节点的 number 字段，并返回该列表。
|
||
"""
|
||
counters = [0] * 5 # 索引 0-3 对应 level 1-4
|
||
for s in sections:
|
||
level = s['level']
|
||
idx = level - 1
|
||
counters[idx] += 1
|
||
for j in range(idx + 1, len(counters)):
|
||
counters[j] = 0
|
||
if level == 1:
|
||
s['number'] = str(counters[0])
|
||
else:
|
||
s['number'] = '.'.join(str(counters[i]) for i in range(level))
|
||
return sections
|
||
|
||
|
||
def _sections_to_outline_text(bid_title: str, sections: list) -> str:
|
||
"""将章节列表还原为大纲文本：一级「一、」子级「1.1 」，与 AI 目录示例一致。"""
|
||
lines = []
|
||
if bid_title:
|
||
lines.append(bid_title)
|
||
for s in sections:
|
||
level = int(s.get('level', 1))
|
||
title = s.get('title', '')
|
||
number = s.get('number', '')
|
||
line = format_heading_display(level, number, title)
|
||
indent = '\u3000' * (level - 1)
|
||
lines.append(f'{indent}{line}')
|
||
return '\n'.join(lines)
|
||
|
||
|
||
def _parse_outline(text: str):
|
||
"""
|
||
将大纲文本解析为章节列表，并自动重排序号（修复删除章节后序号不连续的问题）。
|
||
返回 (bid_title, sections_list, normalized_text)
|
||
每个 section: {number, title, level, is_leaf, order_index}
|
||
"""
|
||
lines = text.strip().split('\n')
|
||
bid_title = ''
|
||
sections = []
|
||
order = 0
|
||
|
||
# 第一行非章节行作为标题
|
||
for i, line in enumerate(lines):
|
||
stripped = line.strip()
|
||
if not stripped:
|
||
continue
|
||
is_chapter_line = (
|
||
bool(re.match(r'^[一二三四五六七八九十百第]', stripped))
|
||
or bool(re.match(r'^\d+(?:[.．、]\s*|\s+)?\S+', stripped))
|
||
)
|
||
if not is_chapter_line:
|
||
bid_title = stripped
|
||
lines = lines[i + 1:]
|
||
break
|
||
break
|
||
|
||
chapter_counter = 0
|
||
|
||
for line in lines:
|
||
raw_line = line.rstrip('\n')
|
||
stripped = raw_line.strip()
|
||
if not stripped:
|
||
continue
|
||
# 去掉行首全角/半角缩进后再匹配编号，避免「 1.1 标题」无法识别
|
||
parse_line = stripped.lstrip('\u3000\u2003\u2002\u00a0 \t')
|
||
|
||
# 一级：中文数字 + 顿号/句号
|
||
m1 = re.match(r'^([一二三四五六七八九十百]+)[、。.]\s*(.*)', parse_line)
|
||
if m1:
|
||
cn = m1.group(1)
|
||
title = m1.group(2).strip()
|
||
chapter_counter = CN_NUM_MAP.get(cn, chapter_counter + 1)
|
||
sections.append({
|
||
'number': str(chapter_counter),
|
||
'title': title,
|
||
'level': 1,
|
||
'is_leaf': True,
|
||
'order_index': order,
|
||
})
|
||
order += 1
|
||
continue
|
||
|
||
# 二/三/四级须先于「一级 纯数字+顿号/空格」匹配，避免 "1.1 标题" 被误成一级 1 且 title=".1 标题" 导致节数虚增
|
||
m_num = re.match(r'^(\d+(?:\.\d+)+)\s+(.*)', parse_line)
|
||
if m_num:
|
||
num_str = m_num.group(1)
|
||
title = m_num.group(2).strip()
|
||
level = num_str.count('.') + 1
|
||
sections.append({
|
||
'number': num_str,
|
||
'title': title,
|
||
'level': min(level, 4),
|
||
'is_leaf': True,
|
||
'order_index': order,
|
||
})
|
||
order += 1
|
||
continue
|
||
|
||
# 一级：阿拉伯数字 + 可选分隔（支持 "1 标题"、"1.标题"、"1标题"）—— 不含 1.1 形式（已上处理）
|
||
m1_en = re.match(r'^(\d+)(?:[、。．.]\s*|\s+)?(.*)', parse_line)
|
||
if m1_en:
|
||
chapter_no = int(m1_en.group(1))
|
||
title = (m1_en.group(2) or '').strip()
|
||
title = re.sub(r'^[、。．.\s]+', '', title)
|
||
if title:
|
||
chapter_counter = chapter_no
|
||
sections.append({
|
||
'number': str(chapter_counter),
|
||
'title': title,
|
||
'level': 1,
|
||
'is_leaf': True,
|
||
'order_index': order,
|
||
})
|
||
order += 1
|
||
continue
|
||
|
||
# 兜底：无编号行按缩进推断层级（支持“纯标题大纲”）
|
||
indent_full = len(re.match(r'^[\u3000 ]*', raw_line).group(0))
|
||
# 约定：每 1 个全角空格/2 个半角空格视作 1 级缩进
|
||
level = min(max(1, (indent_full // 2) + 1), 4)
|
||
if level == 1:
|
||
chapter_counter += 1
|
||
number = str(chapter_counter)
|
||
else:
|
||
number = '1.' * (level - 1) + '1'
|
||
sections.append({
|
||
'number': number.strip('.'),
|
||
'title': parse_line,
|
||
'level': level,
|
||
'is_leaf': True,
|
||
'order_index': order,
|
||
})
|
||
order += 1
|
||
|
||
# 重排序号（核心修复：删除章节后确保编号连续）
|
||
_renumber_sections(sections)
|
||
|
||
# 标记非叶节点（在重排后执行，确保前缀匹配正确）
|
||
nums = [s['number'] for s in sections]
|
||
for s in sections:
|
||
prefix = s['number'] + '.'
|
||
if any(n.startswith(prefix) for n in nums):
|
||
s['is_leaf'] = False
|
||
|
||
# 重建规范大纲文本（供回写数据库）
|
||
normalized_text = _sections_to_outline_text(bid_title, sections)
|
||
|
||
return bid_title, sections, normalized_text
|
||
|
||
|
||
# ─── 数据库工具 ───────────────────────────────────────────────────────────
|
||
|
||
def _get_tender_data(conn, project_id):
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
"SELECT summary, rating_requirements, rating_json, raw_text, boq_summary, tender_kind "
|
||
"FROM tender_data WHERE project_id=?",
|
||
(project_id,)
|
||
)
|
||
row = cur.fetchone()
|
||
if row:
|
||
return {
|
||
'summary': row[0],
|
||
'rating_requirements': row[1],
|
||
'rating_json': row[2],
|
||
'raw_text': row[3],
|
||
'boq_summary': row[4] or '',
|
||
'tender_kind': row[5] or 'engineering',
|
||
}
|
||
return None
|
||
|
||
|
||
def _get_outline_text(conn, project_id):
|
||
cur = conn.cursor()
|
||
cur.execute("SELECT outline FROM tender_data WHERE project_id=?", (project_id,))
|
||
row = cur.fetchone()
|
||
return row[0] if row and row[0] else ''
|
||
|
||
|
||
def _save_outline_text(conn, project_id, outline_text):
|
||
cur = conn.cursor()
|
||
# 兜底：若 tender_data 尚未初始化，先补齐空记录，避免 UPDATE 0 行导致“假保存成功”
|
||
cur.execute(
|
||
"INSERT OR IGNORE INTO tender_data (project_id, status) VALUES (?, 'pending')",
|
||
(project_id,),
|
||
)
|
||
cur.execute(
|
||
"UPDATE tender_data SET outline=?, updated_at=? WHERE project_id=?",
|
||
(outline_text, datetime.now(), project_id),
|
||
)
|
||
conn.commit()
|
||
|
||
|
||
def _save_sections(conn, project_id, sections):
|
||
cur = conn.cursor()
|
||
# 清除旧章节
|
||
cur.execute("DELETE FROM bid_sections WHERE project_id=?", (project_id,))
|
||
for s in sections:
|
||
cur.execute('''
|
||
INSERT INTO bid_sections
|
||
(project_id, section_number, section_title, level, is_leaf, order_index, status)
|
||
VALUES (?, ?, ?, ?, ?, ?, 'pending')
|
||
''', (project_id, s['number'], s['title'], s['level'], 1 if s['is_leaf'] else 0, s['order_index']))
|
||
conn.commit()
|
||
|
||
|
||
def _get_section(conn, section_id):
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
"SELECT id, section_number, section_title, level, is_leaf, content, intro_content FROM bid_sections WHERE id=?",
|
||
(section_id,)
|
||
)
|
||
row = cur.fetchone()
|
||
if row:
|
||
return {
|
||
'id': row[0], 'section_number': row[1], 'section_title': row[2],
|
||
'level': row[3], 'is_leaf': row[4], 'content': row[5], 'intro_content': row[6]
|
||
}
|
||
return None
|
||
|
||
|
||
def _update_section_status(conn, section_id, status, error=''):
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
"UPDATE bid_sections SET status=?, error_message=?, updated_at=? WHERE id=?",
|
||
(status, error, datetime.now(), section_id)
|
||
)
|
||
conn.commit()
|
||
|
||
|
||
def _update_section_content(conn, section_id, content, intro_content):
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
"UPDATE bid_sections SET content=?, intro_content=?, updated_at=? WHERE id=?",
|
||
(content, intro_content, datetime.now(), section_id)
|
||
)
|
||
conn.commit()
|
||
|
||
|
||
# ─── 线程安全的数据库操作（每次独立开关连接，启用 WAL）──────────────────
|
||
|
||
def _db_connect(db_path: str) -> sqlite3.Connection:
|
||
"""创建启用 WAL 模式的连接，适合多线程并发写入"""
|
||
conn = sqlite3.connect(db_path, timeout=30, check_same_thread=False)
|
||
conn.execute('PRAGMA journal_mode=WAL')
|
||
return conn
|
||
|
||
|
||
def _update_section_status_safe(db_path, section_id, status, error=''):
|
||
conn = _db_connect(db_path)
|
||
try:
|
||
_update_section_status(conn, section_id, status, error)
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
def _update_section_content_safe(db_path, section_id, content, intro_content):
|
||
conn = _db_connect(db_path)
|
||
try:
|
||
_update_section_content(conn, section_id, content, intro_content)
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
def _set_project_status(conn, project_id, status, error=''):
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
"UPDATE projects SET outline_status=?, outline_error=?, updated_at=? WHERE id=?",
|
||
(status, error, datetime.now(), project_id)
|
||
)
|
||
conn.commit()
|
||
|
||
|
||
# ─── AI自动填充小章节 ───────────────────────────────────────────────────────
|
||
|
||
def expand_outline(
|
||
outline_text: str,
|
||
summary: str = '',
|
||
rating_requirements: str = '',
|
||
project_id: int = 0,
|
||
target_pages: int = 0,
|
||
) -> str:
|
||
"""
|
||
根据用户输入的主章节标题，自动填充子章节。
|
||
|
||
target_pages: 小章节行总数上界用（与 volume_chapters 线性映射 + ±10%）；须由调用方传入本次请求
|
||
的页数（如前端目标页数），避免仅依赖 process 内全局 config 在多进程或与配置不同步时未生效（出现数百节）。
|
||
为 0 时不做条数限制（与未启用目标页数一致）。
|
||
"""
|
||
lines = outline_text.strip().split('\n')
|
||
bid_title = ''
|
||
main_chapters = []
|
||
|
||
# 提取标书标题（第一行非章节行且较长时视为标题）
|
||
for i, line in enumerate(lines):
|
||
stripped = line.strip()
|
||
if not stripped:
|
||
continue
|
||
is_chapter_format = re.match(r'^[一二三四五六七八九十百第]', stripped) or re.match(r'^\d+[.．、\s]', stripped)
|
||
if not is_chapter_format and len(stripped) > 50:
|
||
bid_title = stripped
|
||
lines = lines[i + 1:]
|
||
break
|
||
break
|
||
|
||
# 提取一级章节
|
||
for line in lines:
|
||
stripped = line.strip()
|
||
if not stripped:
|
||
continue
|
||
|
||
# 先排除二级及以上章节
|
||
if re.match(r'^\d+(?:\.\d+)+', stripped):
|
||
continue
|
||
|
||
m1_cn = re.match(r'^([一二三四五六七八九十百]+)[、。．.\s]+\s*(.*)', stripped)
|
||
if not m1_cn:
|
||
m1_cn = re.match(r'^第([一二三四五六七八九十百]+)[章节]\s*(.*)', stripped)
|
||
if not m1_cn:
|
||
m1_cn = re.match(r'^([一二三四五六七八九十百]+)(?![一二三四五六七八九十百])\s+(.*)', stripped)
|
||
|
||
m1_en = re.match(r'^(\d+)[、。．.\s]+\s*(.*)', stripped)
|
||
if not m1_en:
|
||
m1_en = re.match(r'^第(\d+)[章节]\s*(.*)', stripped)
|
||
if not m1_en:
|
||
m1_en = re.match(r'^(\d+)(?!\d)\s+(.*)', stripped)
|
||
if not m1_en:
|
||
m1_en = re.match(r'^(\d+)([^\d].*)', stripped)
|
||
|
||
if m1_cn or m1_en:
|
||
title = (m1_cn.group(2) if m1_cn else m1_en.group(2)).strip()
|
||
title = re.sub(r'^[、。．.\s]+', '', title)
|
||
if title:
|
||
main_chapters.append({'title': title})
|
||
else:
|
||
# 没有编号的短文本行，也允许作为主章节
|
||
if 0 < len(stripped) < 50:
|
||
main_chapters.append({'title': stripped})
|
||
|
||
if not main_chapters:
|
||
logger.warning(f'expand_outline未找到主章节，输入大纲：{outline_text[:200]}')
|
||
return outline_text
|
||
|
||
expanded_lines = []
|
||
if bid_title:
|
||
expanded_lines.append(bid_title)
|
||
|
||
# 并发生成主章节的小章节（附件类主章跳过 AI 填充）
|
||
results: List[Optional[str]] = [None] * len(main_chapters)
|
||
chapters_to_expand: List[Tuple[int, Dict[str, Any]]] = []
|
||
for idx, chapter in enumerate(main_chapters):
|
||
ct = chapter['title']
|
||
if att_sec.should_skip_expand_subchapters(ct):
|
||
results[idx] = ''
|
||
label = att_sec.parse_attachment_label(ct)
|
||
if label:
|
||
logger.info(
|
||
'expand_outline 跳过附件主章节小章节填充: title=%r attachment_label=%r',
|
||
ct, label,
|
||
)
|
||
else:
|
||
logger.info(
|
||
'expand_outline 跳过附件主章节小章节填充: title=%r',
|
||
ct,
|
||
)
|
||
else:
|
||
chapters_to_expand.append((idx, chapter))
|
||
|
||
if chapters_to_expand:
|
||
tp = max(0, int(target_pages or 0))
|
||
per_main: Optional[List[int]] = None
|
||
if tp > 0:
|
||
k_exp = len(chapters_to_expand)
|
||
n_total = vol_ch.subchapter_total_effective(tp, k_exp, random.Random())
|
||
per_main = vol_ch.allocate_subchapters_to_mains(n_total, k_exp)
|
||
|
||
# 全局信号量已保护AI调用，此处可提高到接近LLM上限（默认12-20）
|
||
max_workers = min(len(chapters_to_expand), getattr(config, 'MAX_CONCURRENT_SECTIONS', 15))
|
||
with ThreadPoolExecutor(max_workers=max_workers) as executor:
|
||
future_to_chapter = {
|
||
executor.submit(
|
||
_generate_sub_chapters,
|
||
ch['title'],
|
||
summary,
|
||
rating_requirements,
|
||
idx + 1,
|
||
project_id,
|
||
per_main[i] if per_main else None,
|
||
): (idx, ch['title'])
|
||
for i, (idx, ch) in enumerate(chapters_to_expand)
|
||
}
|
||
for future in as_completed(future_to_chapter):
|
||
idx, title = future_to_chapter[future]
|
||
try:
|
||
results[idx] = future.result()
|
||
logger.info(f'主章节扩展成功: {title}')
|
||
except Exception as e:
|
||
logger.error(f'主章节扩展失败: {title}, 错误: {e}')
|
||
results[idx] = ''
|
||
|
||
# 组装结果
|
||
for idx, chapter in enumerate(main_chapters):
|
||
chapter_num = idx + 1
|
||
cn_num = _CN_NUMS_LIST[chapter_num] if chapter_num < len(_CN_NUMS_LIST) else str(chapter_num)
|
||
expanded_lines.append(f'{cn_num}、{chapter["title"]}')
|
||
if results[idx]:
|
||
expanded_lines.append(results[idx])
|
||
|
||
return '\n'.join(expanded_lines)
|
||
|
||
|
||
def _extract_title_text(title: str) -> str:
|
||
"""从标题中提取纯文本内容，去除序号和标点符号。"""
|
||
text = re.sub(r'^[一二三四五六七八九十百]+[、。.]\s*', '', title.strip())
|
||
text = re.sub(r'^\d+(?:\.\d+)*[、。.]?\s*', '', text)
|
||
text = re.sub(r'^\s*[、。，,；;：:]+\s*', '', text)
|
||
text = re.sub(r'\s*[、。，,；;：:]+\s*$', '', text)
|
||
return text.strip()
|
||
|
||
|
||
def _generate_sub_chapters(
|
||
chapter_title: str,
|
||
summary: str,
|
||
rating_requirements: str,
|
||
chapter_num: int,
|
||
project_id: int = 0,
|
||
max_subchapters: Optional[int] = None,
|
||
) -> str:
|
||
"""为单个主章节生成子章节大纲。"""
|
||
if max_subchapters is not None and max_subchapters <= 0:
|
||
return ''
|
||
|
||
boq_summary = _get_boq_summary_for_chapter(chapter_title, summary)
|
||
prompt = P.get_chapter_outline_prompt(
|
||
summary, chapter_title, rating_requirements, max_subchapters=max_subchapters
|
||
)
|
||
if boq_summary:
|
||
prompt += (
|
||
'\n\n【工程量清单关键信息】\n'
|
||
f'{boq_summary}\n\n请严格根据工程量清单中的工程项目生成子章节，确保每个子章节都与具体工程内容对应。'
|
||
)
|
||
|
||
try:
|
||
response = ai_client.chat(
|
||
prompt,
|
||
system='你是一位专业的标书大纲生成专家。请根据主章节标题和工程量清单内容生成合适的子章节列表，严格遵守编号规则：'
|
||
'绝对禁止出现1.0、2.0、1.0.1等0开头编号；'
|
||
'二级从X.1开始，三级从X.1.1开始，四级从X.1.1.1开始；'
|
||
'只输出子章节，不重复主章节标题。',
|
||
temperature=0.5,
|
||
max_tokens=2048,
|
||
request_timeout=getattr(config, 'OUTLINE_REQUEST_TIMEOUT', 300),
|
||
)
|
||
logger.info(f'_generate_sub_chapters AI响应章节={chapter_title}，长度={len(response)}')
|
||
|
||
main_title_text = _extract_title_text(chapter_title)
|
||
lines = response.strip().split('\n')
|
||
level_counts = {1: 0, 2: 0, 3: 0, 4: 0}
|
||
result_lines = []
|
||
|
||
for line in lines:
|
||
if not line or not line.strip():
|
||
continue
|
||
|
||
indent_count = 0
|
||
remaining = line
|
||
while remaining and (remaining[0] == '\u3000' or remaining[0] == ' '):
|
||
indent_count += 1
|
||
remaining = remaining[1:]
|
||
|
||
remaining = re.sub(r'^[\s#*>\-]+', '', remaining).strip()
|
||
if not remaining:
|
||
continue
|
||
|
||
m = re.match(r'^(\d+(?:\.\d+)*)[、。．.]?\s*(.*)', remaining)
|
||
if m:
|
||
original_num = m.group(1)
|
||
parts = original_num.split('.')
|
||
has_invalid_zero = any(i > 0 and part and part[0] == '0' for i, part in enumerate(parts))
|
||
if has_invalid_zero:
|
||
continue
|
||
if len(parts) > 1:
|
||
level = len(parts) - 1
|
||
else:
|
||
if indent_count == 0:
|
||
level = 1
|
||
elif indent_count <= 2:
|
||
level = 2
|
||
else:
|
||
level = 3
|
||
title = m.group(2).strip()
|
||
else:
|
||
m_cn = re.match(r'^([一二三四五六七八九十百]+)[、。．.]\s*(.*)', remaining)
|
||
if m_cn:
|
||
title = m_cn.group(2).strip()
|
||
level = 1
|
||
else:
|
||
title = remaining
|
||
if indent_count == 0:
|
||
level = 1
|
||
elif indent_count <= 2:
|
||
level = 2
|
||
else:
|
||
level = 3
|
||
|
||
title = _extract_title_text(title)
|
||
if not title or len(title) < 2:
|
||
continue
|
||
|
||
if main_title_text and _extract_title_text(title) == main_title_text:
|
||
continue
|
||
|
||
level = min(max(level, 1), 3)
|
||
level_counts[level] += 1
|
||
for l in range(level + 1, 5):
|
||
level_counts[l] = 0
|
||
|
||
if level == 1:
|
||
num = f'{chapter_num}.{level_counts[1]}'
|
||
indent = ''
|
||
elif level == 2:
|
||
num = f'{chapter_num}.{level_counts[1]}.{level_counts[2]}'
|
||
indent = '\u3000'
|
||
else:
|
||
num = f'{chapter_num}.{level_counts[1]}.{level_counts[2]}.{level_counts[3]}'
|
||
indent = '\u3000\u3000'
|
||
|
||
result_lines.append(f'{indent}{num} {title}')
|
||
|
||
if max_subchapters is not None and max_subchapters > 0 and len(result_lines) > max_subchapters:
|
||
result_lines = result_lines[:max_subchapters]
|
||
|
||
return '\n'.join(result_lines)
|
||
except Exception:
|
||
logger.exception(f'生成子章节失败 chapter={chapter_title}')
|
||
return ''
|
||
|
||
|
||
def _get_boq_summary_for_chapter(chapter_title: str, summary: str) -> str:
|
||
"""
|
||
从摘要中提取与施工方案相关的工程量清单信息。
|
||
"""
|
||
if not summary:
|
||
return ''
|
||
|
||
boq_keywords = [
|
||
'项目编码', '清单编码', '编码', '编号', '序号', '项目编号', '清单编号',
|
||
'项目名称', '清单名称', '名称', '工程名称', '清单项目名称', '分项名称',
|
||
'计量单位', '单位', '计量', '工程量', '数量', '清单数量', '清单工程量',
|
||
'综合单价', '单价', '投标单价', '综合价', '合价', '金额', '合计金额', '综合合价', '合计', '总价', '小计',
|
||
'项目特征', '项目特征描述', '特征描述', '做法说明', '工程内容', '工作内容', '详述', '说明', '特征', '项目特征及内容',
|
||
'施工内容', '工艺要求', '技术措施', '施工要求', '施工方法'
|
||
]
|
||
|
||
lines = summary.strip().split('\n')
|
||
boq_lines = []
|
||
for line in lines:
|
||
if any(keyword in line for keyword in boq_keywords):
|
||
boq_lines.append(line.strip())
|
||
|
||
if boq_lines:
|
||
return '\n'.join(boq_lines[:20])
|
||
return ''
|