dev：精简冗余

core/construction_review/doc_worker/extra/README.md

@@ -1,251 +0,0 @@
-# 文档分类切分库 (doc_classifier)
-
-一个统一的Python库，用于处理PDF和Word文档的目录提取、智能分类和文本切分。
-
-## 主要特性
-
-- 支持PDF和Word文档格式
-- 自动提取文档目录结构
-- 使用大语言模型进行智能分类
-- 按目录层级和字符数智能切分文本
-- 支持自定义分块大小
-- 输出多种格式（JSON、Markdown、统计报告）
-
-## 安装
-
-```bash
-pip install -r requirements.txt
-```
-
-## 快速开始
-
-### 基础使用
-
-```python
-from doc_classifier import DocumentClassifier
-
-# 创建分类器实例
-classifier = DocumentClassifier(
-    model_url="http://172.16.35.50:8000/v1/chat/completions"
-)
-
-# 处理文档
-result = classifier.process_document(
-    file_path="document.pdf",
-    target_level=2,
-    output_dir="./output"
-)
-
-print(f"生成了 {len(result['chunks'])} 个文本块")
-```
-
-### 处理Word文档
-
-```python
-# 支持.docx和.doc格式
-result = classifier.process_document(
-    file_path="document.docx",
-    target_level=2
-)
-```
-
-### 自定义分块大小
-
-```python
-result = classifier.process_document(
-    file_path="document.pdf",
-    target_level=2,
-    max_chunk_size=1500,  # 最大1500字符
-    min_chunk_size=800    # 最小800字符
-)
-```
-
-## 分块逻辑
-
-新的智能分块逻辑：
-
-1. **按目录层级定位**：定位到指定层级的正文标题
-2. **子标题切分**：在正文块中按最低层级子标题进行初步分块
-3. **大块分割**：超过`max_chunk_size`的块按句子级分割（保持语义完整）
-4. **小块合并**：不足`min_chunk_size`的块尝试合并（合并后不超过`max_chunk_size`）
-
-注意：分割产生的块不参与合并，确保语义完整性。
-
-## 输出数据格式
-
-每个文本块包含以下字段：
-
-```python
-{
-    "file_name": "文档名称.pdf",
-    "chunk_id": "doc_chunk_1.2.1",
-    "section_label": "第一章.工程概况->【1】 工程简介->〖1.2〗 自然及环境条件 ->1.2.1 位置及交通",
-    "context_summary": "自然及环境条件",
-    "project_plan_type": "overview",  # 分类代码
-    "element_tag": {
-        "chunk_id": "doc_chunk_1.2.1",
-        "page": 5,
-        "serial_number": "1.2.1"
-    },
-    "review_chunk_content": "正文内容..."
-}
-```
-
-## 分类类别
-
-支持以下预定义分类：
-
-| 中文名称 | 英文代码 | 说明 |
-|---------|---------|------|
-| 编制依据 | basis | 编制依据、规范标准等 |
-| 工程概况 | overview | 项目概况、工程特点等 |
-| 施工计划 | plan | 施工计划、进度安排等 |
-| 施工工艺计算 | technology | 施工工艺、技术方案等 |
-| 安全保证措施 | safety | 安全管理、安全防护等 |
-| 质量保证措施 | quality | 质量管理、质量控制等 |
-| 环境保证措施 | environment | 环境保护、文明施工等 |
-| 施工管理及作业人员配备与分工 | management | 人员配置、组织机构等 |
-| 验收要求 | acceptance | 验收标准、验收程序等 |
-| 其它资料 | other | 其他内容 |
-
-## 输出文件
-
-处理完成后会生成以下文件：
-
-1. **完整结果JSON**：包含所有数据的JSON文件
-2. **分类文件夹**：按类别分组的Markdown文件
-3. **索引文件**：README.md，包含所有文本块的索引
-4. **统计报告**：详细的统计信息
-
-## API参考
-
-### DocumentClassifier
-
-主要的文档处理类。
-
-#### 初始化
-
-```python
-classifier = DocumentClassifier(model_url="http://...")
-```
-
-参数：
-- `model_url` (str): 大语言模型API地址
-
-#### process_document
-
-处理文档的主要方法。
-
-```python
-result = classifier.process_document(
-    file_path,
-    target_level=2,
-    output_dir=None,
-    max_chunk_size=1000,
-    min_chunk_size=500
-)
-```
-
-参数：
-- `file_path` (str): 文档路径（PDF或Word）
-- `target_level` (int): 要分类的目标层级，默认2
-- `output_dir` (str): 输出目录，默认为源文件同目录下的"分类切分结果"
-- `max_chunk_size` (int): 最大分块字符数，默认1000
-- `min_chunk_size` (int): 最小分块字符数，默认500
-
-返回：
-- `dict`: 包含处理结果的字典
-
-## 高级用法
-
-### 单独使用各模块
-
-```python
-from doc_classifier import TOCExtractor, LLMClassifier, TextSplitter
-
-# 只提取目录
-toc_extractor = TOCExtractor()
-toc_info = toc_extractor.extract_toc("document.pdf")
-
-# 只进行分类
-llm_classifier = LLMClassifier(model_url="http://...")
-classification = llm_classifier.classify(toc_info['toc_items'], target_level=2)
-
-# 只切分文本
-text_splitter = TextSplitter()
-pages_content = text_splitter.extract_full_text("document.pdf")
-chunks = text_splitter.split_by_hierarchy(
-    classification['items'],
-    pages_content,
-    toc_info,
-    target_level=2
-)
-```
-
-### 批量处理
-
-```python
-from pathlib import Path
-
-classifier = DocumentClassifier()
-
-for file_path in Path("./documents").glob("*.pdf"):
-    try:
-        result = classifier.process_document(file_path)
-        print(f"完成: {file_path}")
-    except Exception as e:
-        print(f"错误: {file_path} - {str(e)}")
-```
-
-## 注意事项
-
-1. 文档必须包含目录结构，否则无法处理
-2. 目录项需要有明确的编号格式（如1.1、第一章等）
-3. 需要确保大语言模型API可访问
-4. 处理大文档时可能需要较长时间
-
-## 与旧版本对比
-
-### 主要改进
-
-1. **统一接口**：整合PDF和Word处理为单一接口
-2. **智能分块**：新增按字符数的智能分割和合并
-3. **新数据格式**：更规范的输出数据结构
-4. **库模块化**：可作为Python库被其他项目调用
-5. **更好的文档**：完整的API文档和使用示例
-
-### 迁移指南
-
-旧版本：
-```python
-from pdf_classifier.main import process_pdf_with_classification_and_split
-
-process_pdf_with_classification_and_split(
-    pdf_path="doc.pdf",
-    target_level=2
-)
-```
-
-新版本：
-```python
-from doc_classifier import DocumentClassifier
-
-classifier = DocumentClassifier()
-result = classifier.process_document(
-    file_path="doc.pdf",
-    target_level=2
-)
-```
-
-## 示例
-
-更多示例请参考 `example.py` 文件。
-
-## 许可证
-
-MIT License
-
-## 贡献
-
-欢迎提交问题和改进建议。
-

core/construction_review/doc_worker/extra/config.yaml

@@ -1,173 +0,0 @@
-# 文档分类切分库配置文件
-
-# 大语言模型配置
-llm:
-  # 模型API地址
-  model_url: "http://172.16.35.50:8000/v1/chat/completions"
-  # 模型名称
-  model_name: "Qwen2.5-7B-Instruct"
-  # 温度参数（越低越确定）
-  temperature: 0.1
-  # 请求超时时间（秒）
-  timeout: 60
-
-# 文本切分配置
-text_splitting:
-  # 目标层级（默认按几级目录分类）
-  target_level: 2
-  # 最大分块字符数
-  max_chunk_size: 1000
-  # 最小分块字符数
-  min_chunk_size: 500
-  # 模糊匹配阈值（0-1）
-  fuzzy_threshold: 0.80
-
-# 目录提取配置
-toc_extraction:
-  # 最多读取的页数（目录通常在前几页）
-  max_pages: 15
-  # Word文档每页段落数（模拟分页）
-  paragraphs_per_page: 30
-
-# 分类类别配置
-categories:
-  # 中文名称到英文代码的映射
-  mapping:
-    编制依据: basis
-    工程概况: overview
-    施工计划: plan
-    施工工艺计算: technology
-    安全保证措施: safety
-    质量保证措施: quality
-    环境保证措施: environment
-    施工管理及作业人员配备与分工: management
-    验收要求: acceptance
-    其它资料: other
-  
-  # 类别描述（用于LLM分类提示词）
-  descriptions:
-    编制依据: "包括编制依据、编制说明、规范标准、设计文件、相关法律法规等内容"
-    工程概况: "包括项目概况、工程概况、项目背景、建设概况、工程特点等内容"
-    施工计划: "包括施工计划、施工进度计划、施工部署、施工准备、总体安排等内容"
-    施工工艺计算: "包括施工工艺、施工方法、工艺流程、技术方案、施工计算等内容"
-    安全保证措施: "包括安全保证措施、安全管理、安全施工、安全防护、安全生产等内容"
-    质量保证措施: "包括质量保证措施、质量管理、质量控制、质量检验、质量标准等内容"
-    环境保证措施: "包括环境保护措施、环保施工、水土保持、文明施工、环境管理等内容"
-    施工管理及作业人员配备与分工: "包括人员配置、组织机构、人员分工、劳动力安排、管理体系等内容"
-    验收要求: "包括验收标准、验收程序、验收要求、交工验收、竣工验收等内容"
-    其它资料: "其他说明等不属于以上任何类别的内容"
-
-# LLM分类提示词模板
-prompts:
-  classification: |
-    你是一个专业的工程文档分析助手。现在需要你对以下目录项进行分类。
-
-    【分类类别说明】
-    {category_descriptions}
-
-    【待分类的目录项】
-    {toc_items}
-
-    【任务要求】
-    1. 请仔细阅读每个目录项的标题
-    2. 根据标题的语义，将每个目录项分配到最合适的类别中
-    3. 每个目录项只能属于一个类别
-    4. 如果某个目录项不确定或不属于任何明确类别，请归类到"其它资料"
-
-    【输出格式】
-    请严格按照以下JSON格式输出，不要包含任何其他文字说明：
-    {{
-      "分类结果": [
-        {{
-          "序号": 1,
-          "标题": "目录项标题",
-          "类别": "所属类别名称"
-        }}
-      ]
-    }}
-
-    请开始分类：
-
-# 输出配置
-output:
-  # 默认输出目录名称
-  default_dir_name: "分类切分结果"
-  # 是否默认保存结果
-  save_results: true
-  # 文件名最大长度
-  max_filename_length: 200
-
-# 标题层级识别配置
-title_patterns:
-  # 一级标题模式
-  level1:
-    - '^【\d+】'
-    - '^第[一二三四五六七八九十\d]+章'
-    - '^第[一二三四五六七八九十\d]+部分'
-    - '^[一二三四五六七八九十]、'
-    - '^\d+、'
-    - '^第\d+条'
-  
-  # 二级标题模式
-  level2:
-    - '^第[一二三四五六七八九十\d]+节'
-    - '^[一二三四五六七八九十]+、'
-    - '^\(\d+\)'
-    - '^（[一二三四五六七八九十\d]+）'
-    - '^〖\d+(?:\.\d+)*〗'
-  
-  # 三级标题模式
-  level3:
-    - '^\([一二三四五六七八九十]+\)'
-    - '^[①②③④⑤⑥⑦⑧⑨⑩]'
-
-# 编号格式配置
-numbering:
-  # 支持的编号格式
-  formats:
-    - '^【\d+】'
-    - '^第[一二三四五六七八九十\d]+[章节条款]'
-    - '^\d+[、．.]'
-    - '^[一二三四五六七八九十]+[、．.]'
-    - '^\d+\.\d+'
-    - '^\(\d+\)'
-    - '^（[一二三四五六七八九十\d]+）'
-    - '^\([一二三四五六七八九十]+\)'
-    - '^[①②③④⑤⑥⑦⑧⑨⑩]'
-    - '^〖\d+(?:\.\d+)*〗'
-
-# 噪音过滤配置
-noise_filters:
-  # 噪音模式（用于过滤非目录内容）
-  patterns:
-    - '^\d{4}[-年]\d{1,2}[-月]\d{1,2}'
-    - '^[A-Za-z0-9\-]{20,}$'
-    - '^http[s]?://'
-    - '^第\s*\d+\s*页'
-    - '^共\s*\d+\s*页'
-    - '^[\d\s\-_.]+$'
-
-# 目录识别配置
-toc_detection:
-  # 目录行的正则模式
-  patterns:
-    - '^(第[一二三四五六七八九十\d]+[章节条款].+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    - '^(〖\d+(?:\.\d+)*〗.+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    - '^(\d+[、．.]\s*.+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    - '^([一二三四五六七八九十]+[、．.]\s*.+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    - '^(\d+(?:\.\d+)+\s*.+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    - '^(.+?)[.·]{2,}\s*(\d{1,4})\s*$'
-  
-  # 标题长度限制
-  min_length: 3
-  max_length: 200
-
-# 日志配置
-logging:
-  # 日志级别（DEBUG, INFO, WARNING, ERROR）
-  level: INFO
-  # 日志格式
-  format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-  # 日志文件名
-  filename: 'doc_classifier.log'
-

core/construction_review/doc_worker/extra/example.py

@@ -1,175 +0,0 @@
-"""
-使用示例
-演示如何使用doc_classifier库
-"""
-
-from doc_classifier import DocumentClassifier
-
-
-def example_basic():
-    """基础使用示例"""
-    print("=" * 100)
-    print("示例1: 基础使用")
-    print("=" * 100)
-    
-    # 创建分类器实例
-    classifier = DocumentClassifier(
-        model_url="http://172.16.35.50:8000/v1/chat/completions"
-    )
-    
-    # 处理PDF文档
-    result = classifier.process_document(
-        file_path="example.pdf",
-        target_level=2,
-        output_dir="./output"
-    )
-    
-    print(f"\n处理完成！")
-    print(f"生成了 {len(result['chunks'])} 个文本块")
-    print(f"结果保存在: {result['output_dir']}")
-
-
-def example_word():
-    """处理Word文档示例"""
-    print("\n" + "=" * 100)
-    print("示例2: 处理Word文档")
-    print("=" * 100)
-    
-    classifier = DocumentClassifier()
-    
-    # 处理Word文档
-    result = classifier.process_document(
-        file_path="example.docx",
-        target_level=2,
-        output_dir="./output_word"
-    )
-    
-    print(f"\n处理完成！")
-    print(f"生成了 {len(result['chunks'])} 个文本块")
-
-
-def example_custom_chunk_size():
-    """自定义分块大小示例"""
-    print("\n" + "=" * 100)
-    print("示例3: 自定义分块大小")
-    print("=" * 100)
-    
-    classifier = DocumentClassifier()
-    
-    # 自定义分块大小
-    result = classifier.process_document(
-        file_path="example.pdf",
-        target_level=2,
-        max_chunk_size=1500,  # 最大1500字符
-        min_chunk_size=800,   # 最小800字符
-        output_dir="./output_custom"
-    )
-    
-    print(f"\n处理完成！")
-    print(f"生成了 {len(result['chunks'])} 个文本块")
-
-
-def example_no_save():
-    """不保存文件，只获取数据示例"""
-    print("\n" + "=" * 100)
-    print("示例4: 不保存文件，只获取数据")
-    print("=" * 100)
-    
-    classifier = DocumentClassifier()
-    
-    # 不保存文件，只处理数据
-    result = classifier.process_document(
-        file_path="example.pdf",
-        target_level=2,
-        save_results=False  # 不保存文件
-    )
-    
-    # 直接使用返回的数据
-    print(f"\n获取到 {len(result['chunks'])} 个文本块")
-    print("可以直接在内存中处理这些数据，无需保存文件")
-    
-    # 示例：筛选特定类别的内容
-    safety_chunks = [
-        chunk for chunk in result['chunks']
-        if chunk['project_plan_type'] == 'safety'
-    ]
-    print(f"其中安全保证措施类别有 {len(safety_chunks)} 个块")
-
-
-def example_access_chunks():
-    """访问文本块数据示例"""
-    print("\n" + "=" * 100)
-    print("示例5: 访问文本块数据")
-    print("=" * 100)
-    
-    classifier = DocumentClassifier()
-    
-    result = classifier.process_document(
-        file_path="example.pdf",
-        target_level=2,
-        save_results=False  # 不保存文件
-    )
-    
-    # 访问文本块数据
-    print(f"\n文本块数据结构示例：")
-    if result['chunks']:
-        chunk = result['chunks'][0]
-        print(f"文件名: {chunk['file_name']}")
-        print(f"块ID: {chunk['chunk_id']}")
-        print(f"章节标签: {chunk['section_label']}")
-        print(f"上下文摘要: {chunk['context_summary']}")
-        print(f"方案类型: {chunk['project_plan_type']}")
-        print(f"页码: {chunk['element_tag']['page']}")
-        print(f"内容长度: {len(chunk['review_chunk_content'])} 字符")
-        print(f"内容预览: {chunk['review_chunk_content'][:100]}...")
-
-
-def example_batch_processing():
-    """批量处理示例"""
-    print("\n" + "=" * 100)
-    print("示例6: 批量处理多个文档")
-    print("=" * 100)
-    
-    from pathlib import Path
-    
-    classifier = DocumentClassifier()
-    
-    # 要处理的文件列表
-    files = [
-        "doc1.pdf",
-        "doc2.docx",
-        "doc3.pdf"
-    ]
-    
-    results = []
-    for file_path in files:
-        if not Path(file_path).exists():
-            print(f"跳过不存在的文件: {file_path}")
-            continue
-        
-        try:
-            print(f"\n处理文件: {file_path}")
-            result = classifier.process_document(
-                file_path=file_path,
-                target_level=2
-            )
-            results.append(result)
-            print(f"完成: {file_path}")
-        except Exception as e:
-            print(f"错误: {file_path} - {str(e)}")
-    
-    print(f"\n批量处理完成！共处理 {len(results)} 个文件")
-
-
-if __name__ == "__main__":
-    # 运行示例（根据需要取消注释）
-    
-    # example_basic()
-    # example_word()
-    # example_custom_chunk_size()
-    # example_no_save()
-    # example_access_chunks()
-    # example_batch_processing()
-    
-    print("\n请取消注释要运行的示例函数")
-

core/construction_review/doc_worker/extra/main.py

@@ -1,112 +0,0 @@
-"""
-命令行入口程序
-提供命令行接口来使用doc_classifier库
-"""
-
-import sys
-import argparse
-from pathlib import Path
-from core import DocumentClassifier
-
-
-def main():
-    """主函数"""
-    parser = argparse.ArgumentParser(
-        description='文档分类切分工具 - 支持PDF和Word文档',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-使用示例:
-  python main.py document.pdf
-  python main.py document.docx -l 2 -o ./output
-  python main.py document.pdf --max-size 1500 --min-size 800
-        """
-    )
-    
-    parser.add_argument(
-        'file_path',
-        help='文档路径（PDF或Word）'
-    )
-    
-    parser.add_argument(
-        '-l', '--level',
-        type=int,
-        default=2,
-        help='要分类的目标层级（默认: 2）'
-    )
-    
-    parser.add_argument(
-        '-o', '--output',
-        help='输出目录（默认: 源文件同目录下的"分类切分结果"）'
-    )
-    
-    parser.add_argument(
-        '--max-size',
-        type=int,
-        default=1000,
-        help='最大分块字符数（默认: 1000）'
-    )
-    
-    parser.add_argument(
-        '--min-size',
-        type=int,
-        default=500,
-        help='最小分块字符数（默认: 500）'
-    )
-    
-    parser.add_argument(
-        '--model-url',
-        default='http://172.16.35.50:8000/v1/chat/completions',
-        help='大语言模型API地址'
-    )
-    
-    parser.add_argument(
-        '--no-save',
-        action='store_true',
-        help='不保存结果到文件（仅返回数据）'
-    )
-    
-    args = parser.parse_args()
-    
-    # 检查文件是否存在
-    file_path = Path(args.file_path)
-    if not file_path.exists():
-        print(f"错误: 文件不存在: {args.file_path}")
-        sys.exit(1)
-    
-    # 检查文件格式
-    if file_path.suffix.lower() not in ['.pdf', '.docx', '.doc']:
-        print(f"错误: 不支持的文件格式: {file_path.suffix}")
-        print("支持的格式: .pdf, .docx, .doc")
-        sys.exit(1)
-    
-    try:
-        # 创建分类器
-        classifier = DocumentClassifier(model_url=args.model_url)
-        
-        # 处理文档
-        result = classifier.process_document(
-            file_path=str(file_path),
-            target_level=args.level,
-            output_dir=args.output,
-            max_chunk_size=args.max_size,
-            min_chunk_size=args.min_size,
-            save_results=not args.no_save
-        )
-        
-        print("\n" + "=" * 100)
-        print("处理成功！")
-        print("=" * 100)
-        print(f"\n文本块总数: {len(result['chunks'])}")
-        if not args.no_save:
-            print(f"输出目录: {result['output_dir']}")
-        
-    except Exception as e:
-        print(f"\n错误: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
-

core/construction_review/doc_worker/extra/requirements.txt

@@ -1,5 +0,0 @@
-pymupdf>=1.23.0
-python-docx>=0.8.11
-requests>=2.31.0
-pyyaml>=6.0
-

core/construction_review/doc_worker/extra/test_basic.py

@@ -1,270 +0,0 @@
-"""
-基础测试脚本
-用于验证各模块的基本功能
-"""
-
-import sys
-from pathlib import Path
-
-# 添加当前目录到Python路径，以便导入模块
-sys.path.insert(0, str(Path(__file__).parent))
-
-
-def test_imports():
-    """测试模块导入"""
-    print("=" * 80)
-    print("测试1: 模块导入")
-    print("=" * 80)
-    
-    try:
-        from core import DocumentClassifier
-        print("✓ DocumentClassifier 导入成功")
-        
-        from toc_extractor import TOCExtractor
-        print("✓ TOCExtractor 导入成功")
-        
-        from llm_classifier import LLMClassifier
-        print("✓ LLMClassifier 导入成功")
-        
-        from text_splitter import TextSplitter
-        print("✓ TextSplitter 导入成功")
-        
-        from result_saver import ResultSaver
-        print("✓ ResultSaver 导入成功")
-        
-        print("\n所有模块导入成功！")
-        return True
-    except Exception as e:
-        print(f"\n✗ 导入失败: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_dependencies():
-    """测试依赖包"""
-    print("\n" + "=" * 80)
-    print("测试2: 依赖包检查")
-    print("=" * 80)
-    
-    dependencies = {
-        'fitz': 'PyMuPDF',
-        'docx': 'python-docx',
-        'requests': 'requests'
-    }
-    
-    all_ok = True
-    for module, package in dependencies.items():
-        try:
-            __import__(module)
-            print(f"✓ {package} 已安装")
-        except ImportError:
-            print(f"✗ {package} 未安装")
-            all_ok = False
-    
-    if all_ok:
-        print("\n所有依赖包已安装！")
-    else:
-        print("\n请运行: pip install -r requirements.txt")
-    
-    return all_ok
-
-
-def test_classifier_init():
-    """测试分类器初始化"""
-    print("\n" + "=" * 80)
-    print("测试3: 分类器初始化")
-    print("=" * 80)
-    
-    try:
-        from core import DocumentClassifier
-        
-        classifier = DocumentClassifier()
-        print("✓ 使用默认参数初始化成功")
-        
-        classifier = DocumentClassifier(
-            model_url="http://test.com/api"
-        )
-        print("✓ 使用自定义参数初始化成功")
-        
-        print("\n分类器初始化测试通过！")
-        return True
-    except Exception as e:
-        print(f"\n✗ 初始化失败: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_toc_extractor():
-    """测试目录提取器"""
-    print("\n" + "=" * 80)
-    print("测试4: 目录提取器")
-    print("=" * 80)
-    
-    try:
-        from toc_extractor import TOCExtractor
-        
-        extractor = TOCExtractor()
-        print("✓ TOCExtractor 创建成功")
-        
-        # 测试层级检测
-        test_titles = [
-            "第一章 工程概况",
-            "1.1 项目背景",
-            "1.1.1 位置交通",
-            "〖1.2〗 自然条件"
-        ]
-        
-        for title in test_titles:
-            level = extractor._detect_level(title)
-            print(f"  '{title}' -> 层级: {level}")
-        
-        print("\n目录提取器测试通过！")
-        return True
-    except Exception as e:
-        print(f"\n✗ 测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_text_splitter():
-    """测试文本切分器"""
-    print("\n" + "=" * 80)
-    print("测试5: 文本切分器")
-    print("=" * 80)
-    
-    try:
-        from text_splitter import TextSplitter
-        
-        splitter = TextSplitter()
-        print("✓ TextSplitter 创建成功")
-        
-        # 测试标题标准化
-        test_title = "  第一章   工程概况  "
-        normalized = splitter._normalize_title(test_title)
-        print(f"  标题标准化: '{test_title}' -> '{normalized}'")
-        
-        # 测试大块分割
-        long_text = "这是一个测试句子。" * 200  # 约2000字符
-        chunks = splitter._split_large_chunk(long_text, 1000, "测试标题")
-        print(f"  大块分割: {len(long_text)}字符 -> {len(chunks)}个块")
-        
-        print("\n文本切分器测试通过！")
-        return True
-    except Exception as e:
-        print(f"\n✗ 测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_llm_classifier():
-    """测试LLM分类器"""
-    print("\n" + "=" * 80)
-    print("测试6: LLM分类器")
-    print("=" * 80)
-    
-    try:
-        from llm_classifier import LLMClassifier
-        
-        classifier = LLMClassifier()
-        print("✓ LLMClassifier 创建成功")
-        
-        # 显示分类映射
-        print("\n  分类类别映射:")
-        for cn, en in classifier.category_mapping.items():
-            print(f"    {cn} -> {en}")
-        
-        print("\nLLM分类器测试通过！")
-        return True
-    except Exception as e:
-        print(f"\n✗ 测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_result_saver():
-    """测试结果保存器"""
-    print("\n" + "=" * 80)
-    print("测试7: 结果保存器")
-    print("=" * 80)
-    
-    try:
-        from result_saver import ResultSaver
-        
-        saver = ResultSaver()
-        print("✓ ResultSaver 创建成功")
-        
-        # 测试文件名清理
-        test_names = [
-            "正常文件名",
-            "包含<>:特殊字符",
-            "很长的文件名" * 50
-        ]
-        
-        for name in test_names:
-            sanitized = saver._sanitize_filename(name)
-            print(f"  '{name[:30]}...' -> '{sanitized[:30]}...'")
-        
-        print("\n结果保存器测试通过！")
-        return True
-    except Exception as e:
-        print(f"\n✗ 测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def main():
-    """运行所有测试"""
-    print("\n" + "=" * 80)
-    print("文档分类切分库 - 基础测试")
-    print("=" * 80)
-    
-    tests = [
-        ("模块导入", test_imports),
-        ("依赖包检查", test_dependencies),
-        ("分类器初始化", test_classifier_init),
-        ("目录提取器", test_toc_extractor),
-        ("文本切分器", test_text_splitter),
-        ("LLM分类器", test_llm_classifier),
-        ("结果保存器", test_result_saver)
-    ]
-    
-    results = []
-    for name, test_func in tests:
-        try:
-            result = test_func()
-            results.append((name, result))
-        except Exception as e:
-            print(f"\n测试 '{name}' 发生异常: {e}")
-            results.append((name, False))
-    
-    # 总结
-    print("\n" + "=" * 80)
-    print("测试总结")
-    print("=" * 80)
-    
-    passed = sum(1 for _, result in results if result)
-    total = len(results)
-    
-    for name, result in results:
-        status = "✓ 通过" if result else "✗ 失败"
-        print(f"{status} - {name}")
-    
-    print(f"\n总计: {passed}/{total} 个测试通过")
-    
-    if passed == total:
-        print("\n所有测试通过！库已准备就绪。")
-        return 0
-    else:
-        print("\n部分测试失败，请检查错误信息。")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-

core/construction_review/doc_worker/extra/优化完成说明.md

@@ -1,305 +0,0 @@
-# 文档分类切分库 - 优化完成说明
-
-## 项目概述
-
-已成功将`pdf_classifier`和`word_classifier`两个独立项目整合为统一的`doc_classifier`库模块，并实现了全新的智能分块逻辑。
-
-## 完成的优化内容
-
-### 1. 配置文件管理 ✓
-
-**新增文件**:
-- `config.yaml` - 统一配置文件
-- `config_loader.py` - 配置加载模块
-- `配置说明.md` - 配置文档
-
-**配置项包括**:
-- LLM参数（model_url, model_name, temperature, timeout）
-- 文本切分参数（target_level, max_chunk_size, min_chunk_size, fuzzy_threshold）
-- 目录提取参数（max_pages, paragraphs_per_page）
-- 分类类别（mapping, descriptions）
-- 提示词模板（classification prompt）
-- 输出配置（default_dir_name, save_results, max_filename_length）
-- 标题模式（level1_patterns, level2_patterns, level3_patterns）
-- 编号格式（numbering formats）
-- 噪音过滤（noise patterns）
-- 目录检测（toc patterns, min/max length）
-- 日志配置（level, format, filename）
-
-**特点**:
-- 所有配置集中管理，易于维护
-- 支持配置文件和函数参数两种方式
-- 配置优先级：函数参数 > 配置文件 > 默认值
-- 单例模式，全局共享配置
-
-### 2. 统一的库模块结构 ✓
-
-**位置**: `script/doc_classifier/`
-
-**模块组成**:
-- `__init__.py` - 库入口，导出主要类
-- `core.py` - 核心处理类 DocumentClassifier
-- `toc_extractor.py` - 目录提取模块（支持PDF和Word）
-- `llm_classifier.py` - LLM分类模块
-- `text_splitter.py` - 文本切分模块（新的智能分块逻辑）
-- `result_saver.py` - 结果保存模块
-- `config.yaml` - 配置文件
-- `config_loader.py` - 配置加载模块
-- `main.py` - 命令行入口
-- `example.py` - 使用示例
-- `test_basic.py` - 基础测试
-
-**特点**:
-- 统一接口，自动识别PDF和Word格式
-- 可作为Python库被其他项目导入
-- 支持相对导入和绝对导入
-
-### 3. 新的分块逻辑 ✓
-
-**核心改进**:
-
-#### 分块流程
-1. **定位标题**: 在正文中定位指定层级的标题（跳过目录页）
-2. **子标题切分**: 在每个标题块中查找更低层级的子标题进行切分
-3. **大块分割**: 超过`max_chunk_size`的块按句子级分割（保持语义完整）
-4. **小块合并**: 不足`min_chunk_size`的块尝试合并（仅在同一父标题内合并）
-
-#### 关键特性
-- **局部索引**: `chunk_id`是在每个指定层级标题内部的局部分块索引（整数：1, 2, 3, ...）
-- **父标题追踪**: 通过`serial_number`记录当前标题在指定层级中的位置
-- **智能合并**: 只在同一个父标题内合并小块，合并后重新编号
-- **分割块保护**: 分割产生的块不参与合并，确保语义完整
-
-#### 参数控制
-- `max_chunk_size`: 最大分块字符数（默认1000）
-- `min_chunk_size`: 最小分块字符数（默认500）
-- `target_level`: 目标层级（默认2级）
-
-### 4. 新的数据格式 ✓
-
-**文本块数据结构**:
-
-```json
-{
-  "file_name": "文档名称.pdf",
-  "chunk_id": 1,
-  "section_label": "第一章.工程概况->1.2 自然条件->1.2.1 位置交通",
-  "context_summary": "自然条件",
-  "project_plan_type": "overview",
-  "element_tag": {
-    "chunk_id": 1,
-    "page": 5,
-    "serial_number": 1
-  },
-  "review_chunk_content": "正文内容..."
-}
-```
-
-**字段说明**:
-- `chunk_id`: 在当前指定层级标题内部的局部分块索引（整数）
-- `serial_number`: 当前标题在指定层级中的索引（第几个指定层级的标题）
-- `section_label`: 完整的层级路径
-- `context_summary`: 上下文摘要（父标题）
-- `project_plan_type`: 分类代码（英文）
-
-### 5. 统一的API接口 ✓
-
-**主要接口**:
-
-```python
-from doc_classifier import DocumentClassifier
-
-classifier = DocumentClassifier(
-    model_url="http://172.16.35.50:8000/v1/chat/completions"
-)
-
-result = classifier.process_document(
-    file_path="document.pdf",      # 支持PDF和Word
-    target_level=2,                 # 目标层级
-    max_chunk_size=1000,            # 最大分块大小
-    min_chunk_size=500,             # 最小分块大小
-    output_dir="./output",          # 输出目录
-    save_results=True               # 是否保存文件
-)
-```
-
-**新增功能**:
-- `save_results=False`: 不保存文件，只返回数据
-- 命令行参数 `--no-save`: 不保存文件
-
-### 6. 完整的文档和示例 ✓
-
-**文档文件**:
-- `README.md` - 完整的API文档和使用说明
-- `快速开始.md` - 快速上手指南
-- `项目总览.md` - 项目架构和技术细节
-- `配置说明.md` - 配置文件详细说明
-- `example.py` - 6个使用示例
-- `优化完成说明.md` - 本文件
-
-**示例内容**:
-1. 基础使用
-2. 处理Word文档
-3. 自定义分块大小
-4. 不保存文件，只获取数据
-5. 访问文本块数据
-6. 批量处理
-
-## 测试结果
-
-运行 `test_basic.py` 测试结果：
-
-```
-✓ 通过 - 模块导入
-✓ 通过 - 依赖包检查
-✓ 通过 - 分类器初始化
-✓ 通过 - 目录提取器
-✓ 通过 - 文本切分器
-✓ 通过 - LLM分类器
-✓ 通过 - 结果保存器
-
-总计: 7/7 个测试通过
-```
-
-所有测试通过，库已准备就绪！
-
-## 使用方法
-
-### 方式1: 使用默认配置
-
-```python
-from doc_classifier import DocumentClassifier
-
-# 自动从config.yaml加载配置
-classifier = DocumentClassifier()
-
-# 使用配置文件中的默认参数
-result = classifier.process_document("document.pdf")
-```
-
-### 方式2: 覆盖部分配置
-
-```python
-from doc_classifier import DocumentClassifier
-
-# 覆盖model_url，其他使用配置文件
-classifier = DocumentClassifier(model_url="http://custom:8000/v1/chat/completions")
-
-# 覆盖分块参数，其他使用配置文件
-result = classifier.process_document(
-    file_path="document.pdf",
-    max_chunk_size=1500,
-    min_chunk_size=800,
-    save_results=False
-)
-```
-
-### 方式3: 修改配置文件
-
-直接编辑`config.yaml`：
-
-```yaml
-text_splitting:
-  max_chunk_size: 1500  # 修改默认值
-  min_chunk_size: 800
-```
-
-然后正常使用：
-
-```python
-classifier = DocumentClassifier()
-result = classifier.process_document("document.pdf")  # 使用新的默认值
-```
-
-### 方式2: 命令行
-
-```bash
-# 处理文档并保存
-python main.py document.pdf
-
-# 不保存文件
-python main.py document.pdf --no-save
-
-# 自定义参数
-python main.py document.pdf -l 2 --max-size 1500 --min-size 800 -o ./output
-```
-
-## 与旧版本对比
-
-| 特性 | 旧版本 | 新版本 |
-|-----|--------|--------|
-| 接口统一性 | PDF和Word分离 | 统一接口 |
-| 分块逻辑 | 仅按标题切分 | 智能分割+合并 |
-| chunk_id | 全局编号 | 局部索引（整数形式） |
-| 数据格式 | 简单格式 | 规范化格式+serial_number |
-| 使用方式 | 独立脚本 | 可作为库调用 |
-| 保存选项 | 必须保存 | 可选保存 |
-| 文档完整性 | 基础文档 | 完整文档+示例 |
-
-## 核心优势
-
-1. **局部索引**: chunk_id在每个父标题内独立编号（整数形式），便于理解和管理
-2. **父标题追踪**: serial_number明确标识当前块属于哪个指定层级的标题
-3. **智能合并**: 只在同一父标题内合并，避免跨标题混淆
-4. **灵活使用**: 可选保存，支持纯数据处理模式
-5. **统一接口**: 一个接口处理所有格式
-
-## 文件结构
-
-```
-doc_classifier/
-├── __init__.py              # 库入口
-├── core.py                  # 核心类
-├── toc_extractor.py         # 目录提取
-├── llm_classifier.py        # LLM分类
-├── text_splitter.py         # 文本切分（新逻辑）
-├── result_saver.py          # 结果保存
-├── config.yaml              # 配置文件
-├── config_loader.py         # 配置加载
-├── main.py                  # 命令行入口
-├── example.py               # 使用示例
-├── test_basic.py            # 基础测试
-├── requirements.txt         # 依赖包
-├── README.md                # 完整文档
-├── 快速开始.md              # 快速指南
-├── 项目总览.md              # 项目架构
-├── 配置说明.md              # 配置文档
-└── 优化完成说明.md          # 本文件
-```
-
-## 依赖包
-
-```
-pymupdf>=1.23.0
-python-docx>=0.8.11
-requests>=2.31.0
-pyyaml>=6.0
-```
-
-安装：
-```bash
-pip install -r requirements.txt
-```
-
-## 下一步建议
-
-1. **实际测试**: 使用真实的PDF/Word文档进行测试
-2. **性能优化**: 如需处理大量文档，可考虑并行处理
-3. **功能扩展**: 根据实际需求添加新的分类类别
-4. **错误处理**: 完善异常情况的处理逻辑
-
-## 技术支持
-
-如有问题，请查看：
-1. `README.md` - 完整文档
-2. `快速开始.md` - 快速上手
-3. `配置说明.md` - 配置详解
-4. `example.py` - 使用示例
-5. `test_basic.py` - 测试代码
-
----
-
-**优化完成时间**: 2025-11-13  
-**版本**: 2.0.0  
-**状态**: ✓ 已完成并通过测试
-

core/construction_review/doc_worker/extra/快速开始.md

@@ -1,231 +0,0 @@
-# 快速开始指南
-
-## 安装依赖
-
-首先安装所需的Python包：
-
-```bash
-pip install -r requirements.txt
-```
-
-需要的包：
-- pymupdf (处理PDF)
-- python-docx (处理Word)
-- requests (调用API)
-
-## 方式1: 作为Python库使用
-
-### 最简单的例子
-
-```python
-from doc_classifier import DocumentClassifier
-
-# 创建分类器
-classifier = DocumentClassifier()
-
-# 处理文档
-result = classifier.process_document("document.pdf")
-
-print(f"完成！生成了 {len(result['chunks'])} 个文本块")
-```
-
-### 处理Word文档
-
-```python
-# 同样的接口，自动识别格式
-result = classifier.process_document("document.docx")
-```
-
-### 自定义参数
-
-```python
-result = classifier.process_document(
-    file_path="document.pdf",
-    target_level=2,           # 按2级目录分类
-    max_chunk_size=1500,      # 最大1500字符
-    min_chunk_size=800,       # 最小800字符
-    output_dir="./my_output", # 自定义输出目录
-    save_results=True         # 是否保存结果到文件
-)
-```
-
-### 不保存文件，只获取数据
-
-```python
-# 只处理数据，不保存到文件
-result = classifier.process_document(
-    file_path="document.pdf",
-    save_results=False  # 不保存文件
-)
-
-# 直接使用返回的数据
-for chunk in result['chunks']:
-    print(chunk['section_label'])
-    print(chunk['review_chunk_content'])
-```
-
-### 访问结果数据
-
-```python
-result = classifier.process_document("document.pdf")
-
-# 访问文本块
-for chunk in result['chunks']:
-    print(f"章节: {chunk['section_label']}")
-    print(f"类别: {chunk['project_plan_type']}")
-    print(f"页码: {chunk['element_tag']['page']}")
-    print(f"内容: {chunk['review_chunk_content'][:100]}...")
-    print("-" * 50)
-```
-
-## 方式2: 使用命令行
-
-### 基础用法
-
-```bash
-python main.py document.pdf
-```
-
-### 指定参数
-
-```bash
-# 指定目标层级和输出目录
-python main.py document.pdf -l 2 -o ./output
-
-# 自定义分块大小
-python main.py document.pdf --max-size 1100 --min-size 900
-
-# 不保存文件，只处理数据
-python main.py document.pdf --no-save
-
-# 完整参数
-python main.py document.pdf -l 2 -o ./output --max-size 1500 --min-size 800
-```
-
-### 查看帮助
-
-```bash
-python main.py -h
-```
-
-## 输出结果说明
-
-处理完成后，会在输出目录生成以下文件：
-
-```
-分类切分结果/
-├── README.md                    # 索引文件
-├── 文档名_完整结果_时间戳.json   # 完整JSON数据
-├── 文档名_统计报告_时间戳.txt    # 统计报告
-├── overview/                    # 工程概况类别
-│   ├── 001_第一章_工程概况.md
-│   └── 002_1.1_项目背景.md
-├── technology/                  # 施工工艺计算类别
-│   ├── 001_第二章_施工工艺.md
-│   └── ...
-└── safety/                      # 安全保证措施类别
-    └── ...
-```
-
-## 数据格式说明
-
-每个文本块的JSON格式：
-
-```json
-{
-  "file_name": "文档名称.pdf",
-  "chunk_id": 1,
-  "section_label": "第一章.工程概况->1.2 自然条件->1.2.1 位置交通",
-  "context_summary": "自然条件",
-  "project_plan_type": "overview",
-  "element_tag": {
-    "chunk_id": 1,
-    "page": 5,
-    "serial_number": 1
-  },
-  "review_chunk_content": "正文内容..."
-}
-```
-
-说明：
-- `chunk_id`: 在当前指定层级标题内部的局部分块索引（整数：1, 2, 3, ...）
-- `serial_number`: 当前标题在指定层级中的索引（第几个指定层级的标题）
-
-## 分类类别对照表
-
-| 中文名称 | 英文代码 |
-|---------|---------|
-| 编制依据 | basis |
-| 工程概况 | overview |
-| 施工计划 | plan |
-| 施工工艺计算 | technology |
-| 安全保证措施 | safety |
-| 质量保证措施 | quality |
-| 环境保证措施 | environment |
-| 施工管理及作业人员配备与分工 | management |
-| 验收要求 | acceptance |
-| 其它资料 | other |
-
-## 批量处理示例
-
-```python
-from pathlib import Path
-from doc_classifier import DocumentClassifier
-
-classifier = DocumentClassifier()
-
-# 处理目录下所有PDF文件
-for pdf_file in Path("./documents").glob("*.pdf"):
-    print(f"处理: {pdf_file}")
-    try:
-        result = classifier.process_document(pdf_file)
-        print(f"完成: {len(result['chunks'])} 个块")
-    except Exception as e:
-        print(f"错误: {e}")
-```
-
-## 常见问题
-
-### Q: 提示"未检测到目录"怎么办？
-
-A: 确保文档包含目录结构，目录项需要有明确的编号格式（如1.1、第一章等）。
-
-### Q: 如何修改分类类别？
-
-A: 在 `llm_classifier.py` 中修改 `CATEGORY_MAPPING` 字典。
-
-### Q: 处理很慢怎么办？
-
-A: 大文档需要较长时间，可以：
-1. 减小目标层级（如改为1级）
-2. 增大最小分块大小
-3. 检查模型API响应速度
-
-### Q: 如何调整分块大小？
-
-A: 使用参数控制：
-```python
-result = classifier.process_document(
-    file_path="doc.pdf",
-    max_chunk_size=2000,  # 增大最大值
-    min_chunk_size=1000   # 增大最小值
-)
-```
-
-### Q: 支持其他文档格式吗？
-
-A: 目前支持：
-- PDF (.pdf)
-- Word (.docx, .doc)
-
-## 更多示例
-
-查看 `example.py` 文件获取更多使用示例。
-
-## 技术支持
-
-如有问题，请查看：
-1. README.md - 完整文档
-2. example.py - 示例代码
-3. 项目Issues - 已知问题和解决方案
-

core/construction_review/doc_worker/extra/配置说明.md

@@ -1,394 +0,0 @@
-# 配置说明文档
-
-## 概述
-
-`doc_classifier`库使用`config.yaml`文件进行统一的配置管理，包括LLM参数、分块逻辑、分类类别、提示词等所有可配置项。
-
-## 配置文件位置
-
-```
-doc_classifier/
-├── config.yaml          # 配置文件
-├── config_loader.py     # 配置加载模块
-└── ...
-```
-
-## 配置项说明
-
-### 1. 大语言模型配置 (llm)
-
-```yaml
-llm:
-  model_url: "http://172.16.35.50:8000/v1/chat/completions"  # 模型API地址
-  model_name: "Qwen2.5-7B-Instruct"                          # 模型名称
-  temperature: 0.1                                            # 温度参数
-  timeout: 60                                                 # 请求超时时间（秒）
-```
-
-**说明**：
-- `model_url`: LLM服务的API端点
-- `model_name`: 使用的模型名称
-- `temperature`: 控制输出的随机性，越低越确定
-- `timeout`: API请求超时时间
-
-### 2. 文本切分配置 (text_splitting)
-
-```yaml
-text_splitting:
-  target_level: 2           # 目标层级
-  max_chunk_size: 1000      # 最大分块字符数
-  min_chunk_size: 500       # 最小分块字符数
-  fuzzy_threshold: 0.80     # 模糊匹配阈值
-```
-
-**说明**：
-- `target_level`: 按几级目录进行分类（1=一级，2=二级）
-- `max_chunk_size`: 超过此字符数的块会被分割
-- `min_chunk_size`: 小于此字符数的块会尝试合并
-- `fuzzy_threshold`: 标题匹配的相似度阈值（0-1）
-
-### 3. 目录提取配置 (toc_extraction)
-
-```yaml
-toc_extraction:
-  max_pages: 15                  # 最多读取的页数
-  paragraphs_per_page: 30        # Word文档每页段落数
-```
-
-**说明**：
-- `max_pages`: 目录通常在前几页，限制读取页数提高效率
-- `paragraphs_per_page`: Word文档模拟分页的段落数
-
-### 4. 分类类别配置 (categories)
-
-```yaml
-categories:
-  # 中文名称到英文代码的映射
-  mapping:
-    编制依据: basis
-    工程概况: overview
-    施工计划: plan
-    # ... 更多类别
-  
-  # 类别描述（用于LLM分类提示词）
-  descriptions:
-    编制依据: "包括编制依据、编制说明、规范标准..."
-    工程概况: "包括项目概况、工程概况、项目背景..."
-    # ... 更多描述
-```
-
-**说明**：
-- `mapping`: 中文类别名称与英文代码的对应关系
-- `descriptions`: 每个类别的详细描述，用于生成LLM提示词
-
-**如何添加新类别**：
-1. 在`mapping`中添加新的键值对
-2. 在`descriptions`中添加对应的描述
-
-### 5. LLM分类提示词模板 (prompts)
-
-```yaml
-prompts:
-  classification: |
-    你是一个专业的工程文档分析助手...
-    
-    【分类类别说明】
-    {category_descriptions}
-    
-    【待分类的目录项】
-    {toc_items}
-    
-    ...
-```
-
-**说明**：
-- 使用`|`表示多行文本
-- `{category_descriptions}`和`{toc_items}`是占位符，会被实际内容替换
-- 可以自定义提示词内容和格式
-
-### 6. 输出配置 (output)
-
-```yaml
-output:
-  default_dir_name: "分类切分结果"   # 默认输出目录名称
-  save_results: true                 # 是否默认保存结果
-  max_filename_length: 200           # 文件名最大长度
-```
-
-**说明**：
-- `default_dir_name`: 未指定输出目录时使用的默认名称
-- `save_results`: 是否默认保存结果到文件
-- `max_filename_length`: 文件名超过此长度会被截断
-
-### 7. 标题层级识别配置 (title_patterns)
-
-```yaml
-title_patterns:
-  level1:
-    - '^【\d+】'
-    - '^第[一二三四五六七八九十\d]+章'
-    # ... 更多模式
-  
-  level2:
-    - '^第[一二三四五六七八九十\d]+节'
-    - '^〖\d+(?:\.\d+)*〗'
-    # ... 更多模式
-  
-  level3:
-    - '^\([一二三四五六七八九十]+\)'
-    # ... 更多模式
-```
-
-**说明**：
-- 使用正则表达式匹配不同层级的标题
-- 可以添加新的模式以支持更多标题格式
-
-### 8. 编号格式配置 (numbering)
-
-```yaml
-numbering:
-  formats:
-    - '^【\d+】'
-    - '^第[一二三四五六七八九十\d]+[章节条款]'
-    - '^\d+[、．.]'
-    # ... 更多格式
-```
-
-**说明**：
-- 定义哪些格式被认为是有效的编号
-- 用于判断文本是否为标题
-
-### 9. 噪音过滤配置 (noise_filters)
-
-```yaml
-noise_filters:
-  patterns:
-    - '^\d{4}[-年]\d{1,2}[-月]\d{1,2}'  # 日期
-    - '^http[s]?://'                    # URL
-    - '^第\s*\d+\s*页'                  # 页码
-    # ... 更多模式
-```
-
-**说明**：
-- 用于过滤非目录内容
-- 匹配这些模式的文本会被忽略
-
-### 10. 目录识别配置 (toc_detection)
-
-```yaml
-toc_detection:
-  patterns:
-    - '^(第[一二三四五六七八九十\d]+[章节条款].+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    - '^(〖\d+(?:\.\d+)*〗.+?)[.·]{2,}\s*(\d{1,4})\s*$'
-    # ... 更多模式
-  
-  min_length: 3      # 标题最小长度
-  max_length: 200    # 标题最大长度
-```
-
-**说明**：
-- `patterns`: 目录行的正则表达式模式
-- `min_length`/`max_length`: 标题长度限制
-
-### 11. 日志配置 (logging)
-
-```yaml
-logging:
-  level: INFO                                                  # 日志级别
-  format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'  # 日志格式
-  filename: 'doc_classifier.log'                              # 日志文件名
-```
-
-**说明**：
-- `level`: DEBUG, INFO, WARNING, ERROR
-- `format`: Python logging格式字符串
-- `filename`: 日志文件名
-
-## 使用方法
-
-### 方式1: 使用默认配置
-
-```python
-from doc_classifier import DocumentClassifier
-
-# 自动加载config.yaml中的配置
-classifier = DocumentClassifier()
-result = classifier.process_document("document.pdf")
-```
-
-### 方式2: 覆盖部分配置
-
-```python
-from doc_classifier import DocumentClassifier
-
-# 覆盖model_url，其他使用配置文件
-classifier = DocumentClassifier(model_url="http://custom-url:8000/v1/chat/completions")
-
-# 覆盖分块大小，其他使用配置文件
-result = classifier.process_document(
-    "document.pdf",
-    max_chunk_size=1500,
-    min_chunk_size=800
-)
-```
-
-### 方式3: 修改配置文件
-
-直接编辑`config.yaml`文件，修改后重新运行程序即可生效。
-
-### 方式4: 使用自定义配置文件
-
-```python
-from doc_classifier.config_loader import Config
-
-# 加载自定义配置文件
-config = Config()
-config.load_config("my_custom_config.yaml")
-
-# 然后正常使用
-from doc_classifier import DocumentClassifier
-classifier = DocumentClassifier()
-```
-
-## 配置优先级
-
-参数来源的优先级（从高到低）：
-
-1. **函数参数**: 直接传递给函数的参数
-2. **配置文件**: config.yaml中的配置
-3. **默认值**: 代码中的硬编码默认值
-
-示例：
-```python
-# config.yaml中: max_chunk_size: 1000
-classifier = DocumentClassifier()
-
-# 使用配置文件的值（1000）
-result = classifier.process_document("doc.pdf")
-
-# 使用函数参数的值（1500），覆盖配置文件
-result = classifier.process_document("doc.pdf", max_chunk_size=1500)
-```
-
-## 常见配置场景
-
-### 场景1: 调整分块大小
-
-```yaml
-text_splitting:
-  max_chunk_size: 1500  # 增大到1500
-  min_chunk_size: 800   # 增大到800
-```
-
-### 场景2: 更换LLM服务
-
-```yaml
-llm:
-  model_url: "http://new-server:8000/v1/chat/completions"
-  model_name: "new-model-name"
-```
-
-### 场景3: 添加新的分类类别
-
-```yaml
-categories:
-  mapping:
-    # ... 现有类别
-    新类别: new_category
-  
-  descriptions:
-    # ... 现有描述
-    新类别: "新类别的描述说明"
-```
-
-### 场景4: 自定义提示词
-
-```yaml
-prompts:
-  classification: |
-    你是一个专业助手。
-    
-    【自定义的提示词内容】
-    {category_descriptions}
-    
-    【自定义的格式】
-    {toc_items}
-```
-
-### 场景5: 支持新的标题格式
-
-```yaml
-title_patterns:
-  level2:
-    - '^〖\d+(?:\.\d+)*〗'  # 现有格式
-    - '^§\d+\.\d+'         # 新增格式
-```
-
-## 配置验证
-
-运行测试以验证配置是否正确：
-
-```bash
-python test_basic.py
-```
-
-如果所有测试通过，说明配置正确。
-
-## 配置备份
-
-建议在修改配置前备份原文件：
-
-```bash
-cp config.yaml config.yaml.backup
-```
-
-## 故障排除
-
-### 问题1: 配置文件未找到
-
-**错误**: `FileNotFoundError: 配置文件不存在`
-
-**解决**: 确保`config.yaml`文件在`doc_classifier`目录下
-
-### 问题2: YAML格式错误
-
-**错误**: `yaml.scanner.ScannerError`
-
-**解决**: 检查YAML语法，注意缩进（使用空格，不要用Tab）
-
-### 问题3: 配置未生效
-
-**解决**: 
-1. 检查配置文件是否正确保存
-2. 重新运行程序
-3. 确认没有函数参数覆盖配置
-
-### 问题4: 缺少pyyaml依赖
-
-**错误**: `ModuleNotFoundError: No module named 'yaml'`
-
-**解决**: 
-```bash
-pip install pyyaml
-```
-
-## 最佳实践
-
-1. **版本控制**: 将`config.yaml`加入版本控制
-2. **环境区分**: 为不同环境创建不同的配置文件
-3. **文档更新**: 修改配置后更新相关文档
-4. **测试验证**: 修改配置后运行测试确保正常
-5. **备份重要配置**: 定期备份配置文件
-
-## 相关文件
-
-- `config.yaml` - 配置文件
-- `config_loader.py` - 配置加载模块
-- `test_basic.py` - 测试脚本
-- `README.md` - 完整文档
-
----
-
-**更新时间**: 2025-11-13  
-**版本**: 2.0.0
-

core/construction_review/doc_worker/extra/项目总览.md

@@ -1,341 +0,0 @@
-# 文档分类切分库 - 项目总览
-
-## 项目简介
-
-这是一个统一的Python库，用于处理PDF和Word文档的目录提取、智能分类和文本切分。它整合了原有的`pdf_classifier`和`word_classifier`两个独立项目，提供了更加统一、灵活和强大的文档处理能力。
-
-## 核心功能
-
-1. **目录提取**：自动从PDF和Word文档中提取目录结构
-2. **智能分类**：使用大语言模型对目录项进行语义分类
-3. **智能切分**：按目录层级和字符数进行智能文本切分
-4. **多格式输出**：支持JSON、Markdown、统计报告等多种输出格式
-
-## 项目架构
-
-```
-doc_classifier/
-├── __init__.py           # 库入口，导出主要类
-├── core.py              # 核心处理类 DocumentClassifier
-├── toc_extractor.py     # 目录提取模块 TOCExtractor
-├── llm_classifier.py    # LLM分类模块 LLMClassifier
-├── text_splitter.py     # 文本切分模块 TextSplitter
-├── result_saver.py      # 结果保存模块 ResultSaver
-├── main.py              # 命令行入口
-├── example.py           # 使用示例
-├── requirements.txt     # 依赖包
-├── README.md            # 完整文档
-├── 快速开始.md          # 快速开始指南
-└── 项目总览.md          # 本文件
-```
-
-## 模块说明
-
-### 1. core.py - 核心处理模块
-
-**主要类**: `DocumentClassifier`
-
-**功能**:
-- 统一的文档处理接口
-- 协调各个子模块的工作流程
-- 提供简单易用的API
-
-**主要方法**:
-- `process_document()`: 处理文档的主要方法
-
-### 2. toc_extractor.py - 目录提取模块
-
-**主要类**: `TOCExtractor`
-
-**功能**:
-- 从PDF中提取目录（基于文本模式匹配）
-- 从Word中提取目录（内置目录结构 + 文本模式）
-- 识别目录项的层级结构
-
-**支持的目录格式**:
-- 数字编号：1.1、1.1.1、1.1.1.1
-- 中文编号：第一章、第二节
-- 特殊格式：【1】、〖1.2〗
-- 其他格式：一、二、三、(1)、(2)
-
-### 3. llm_classifier.py - LLM分类模块
-
-**主要类**: `LLMClassifier`
-
-**功能**:
-- 调用大语言模型API
-- 构建分类提示词
-- 解析分类结果
-- 映射中英文类别名称
-
-**预定义分类**:
-- 编制依据 (basis)
-- 工程概况 (overview)
-- 施工计划 (plan)
-- 施工工艺计算 (technology)
-- 安全保证措施 (safety)
-- 质量保证措施 (quality)
-- 环境保证措施 (environment)
-- 施工管理及作业人员配备与分工 (management)
-- 验收要求 (acceptance)
-- 其它资料 (other)
-
-### 4. text_splitter.py - 文本切分模块
-
-**主要类**: `TextSplitter`
-
-**功能**:
-- 提取PDF/Word全文
-- 在正文中定位标题
-- 按目录层级切分文本
-- 智能分割大块
-- 智能合并小块
-
-**切分逻辑**:
-
-1. **定位标题**: 在正文中定位指定层级的标题（跳过目录页）
-2. **子标题切分**: 在每个标题块中查找更低层级的子标题进行切分
-3. **大块分割**: 超过`max_chunk_size`的块按句子级分割（保持语义完整）
-4. **小块合并**: 不足`min_chunk_size`的块尝试合并（合并后不超过`max_chunk_size`）
-
-**特点**:
-- 分割产生的块不参与合并，确保语义完整
-- 支持表格内容提取（Word）
-- 模糊匹配标题，应对OCR错误
-
-### 5. result_saver.py - 结果保存模块
-
-**主要类**: `ResultSaver`
-
-**功能**:
-- 保存完整JSON结果
-- 按类别保存Markdown文件
-- 生成索引文件
-- 生成统计报告
-
-**输出文件**:
-- `{文档名}_完整结果_{时间戳}.json`: 包含所有数据
-- `{文档名}_统计报告_{时间戳}.txt`: 详细统计信息
-- `README.md`: 索引文件
-- `{类别}/`: 按类别分组的Markdown文件
-
-## 数据流程
-
-```
-输入文档 (PDF/Word)
-    ↓
-[TOCExtractor] 提取目录
-    ↓
-目录项列表
-    ↓
-[LLMClassifier] 智能分类
-    ↓
-已分类的目录项
-    ↓
-[TextSplitter] 提取全文
-    ↓
-页面内容列表
-    ↓
-[TextSplitter] 定位标题
-    ↓
-标题位置列表
-    ↓
-[TextSplitter] 智能切分
-    ↓
-文本块列表
-    ↓
-[ResultSaver] 保存结果
-    ↓
-输出文件
-```
-
-## 数据格式
-
-### 目录项格式
-
-```python
-{
-    'title': '1.1 工程概况',
-    'page': '5',
-    'level': 2,
-    'category': '工程概况',
-    'category_code': 'overview',
-    'original': '1.1 工程概况 ......... 5'
-}
-```
-
-### 文本块格式
-
-```python
-{
-    'file_name': '文档名.pdf',
-    'chunk_id': 'doc_chunk_1.2.1',
-    'section_label': '第一章->1.2 自然条件->1.2.1 位置交通',
-    'context_summary': '自然条件',
-    'project_plan_type': 'overview',
-    'element_tag': {
-        'chunk_id': 'doc_chunk_1.2.1',
-        'page': 5,
-        'serial_number': '1.2.1'
-    },
-    'review_chunk_content': '正文内容...'
-}
-```
-
-## 与旧版本对比
-
-### 主要改进
-
-| 特性 | 旧版本 | 新版本 |
-|-----|--------|--------|
-| 接口统一性 | PDF和Word分离 | 统一接口 |
-| 分块逻辑 | 仅按标题切分 | 智能分割+合并 |
-| 数据格式 | 简单格式 | 规范化格式 |
-| 使用方式 | 独立脚本 | 可作为库调用 |
-| 文档完整性 | 基础文档 | 完整文档+示例 |
-| 可扩展性 | 较低 | 高度模块化 |
-
-### 新增功能
-
-1. **智能分块**: 根据字符数自动分割和合并
-2. **统一接口**: 一个接口处理所有格式
-3. **库模块化**: 可被其他项目导入使用
-4. **命令行工具**: 提供命令行接口
-5. **更好的文档**: 完整的API文档和使用示例
-
-## 使用场景
-
-### 场景1: 文档预处理
-
-将长文档切分成适合RAG系统的小块：
-
-```python
-classifier = DocumentClassifier()
-result = classifier.process_document(
-    "long_document.pdf",
-    max_chunk_size=1000,
-    min_chunk_size=500
-)
-# 使用result['chunks']进行后续处理
-```
-
-### 场景2: 文档分类整理
-
-按类别整理大量文档：
-
-```python
-for doc in documents:
-    result = classifier.process_document(doc)
-    # 结果自动按类别保存到文件夹
-```
-
-### 场景3: 批量数据提取
-
-从多个文档中提取特定类别的内容：
-
-```python
-all_safety_content = []
-for doc in documents:
-    result = classifier.process_document(doc)
-    safety_chunks = [
-        chunk for chunk in result['chunks']
-        if chunk['project_plan_type'] == 'safety'
-    ]
-    all_safety_content.extend(safety_chunks)
-```
-
-## 技术栈
-
-- **Python 3.7+**
-- **PyMuPDF (fitz)**: PDF处理
-- **python-docx**: Word处理
-- **requests**: HTTP请求
-- **大语言模型**: 文本分类
-
-## 性能考虑
-
-### 处理速度
-
-- 小文档（<50页）: 1-2分钟
-- 中等文档（50-200页）: 2-5分钟
-- 大文档（>200页）: 5-15分钟
-
-主要耗时在：
-1. LLM分类调用
-2. 全文提取
-3. 标题定位
-
-### 优化建议
-
-1. 减小目标层级（处理更少的目录项）
-2. 增大分块大小（生成更少的块）
-3. 使用更快的LLM服务
-4. 批量处理时使用多进程
-
-## 扩展性
-
-### 添加新的分类类别
-
-在`llm_classifier.py`中修改：
-
-```python
-CATEGORY_MAPPING = {
-    "编制依据": "basis",
-    "新类别": "new_category",  # 添加新类别
-    # ...
-}
-```
-
-### 支持新的文档格式
-
-在`toc_extractor.py`和`text_splitter.py`中添加新的提取方法。
-
-### 自定义分块逻辑
-
-继承`TextSplitter`类并重写`split_by_hierarchy`方法。
-
-## 测试
-
-建议测试的场景：
-
-1. 不同格式的文档（PDF、Word）
-2. 不同的目录结构（数字编号、中文编号）
-3. 不同大小的文档（小、中、大）
-4. 边界情况（无目录、目录格式异常）
-
-## 未来计划
-
-1. 支持更多文档格式（如HTML、Markdown）
-2. 增加更多分类类别
-3. 优化处理速度
-4. 添加可视化界面
-5. 支持分布式处理
-
-## 贡献指南
-
-欢迎贡献代码！请遵循以下步骤：
-
-1. Fork项目
-2. 创建特性分支
-3. 提交更改
-4. 推送到分支
-5. 创建Pull Request
-
-## 许可证
-
-MIT License
-
-## 联系方式
-
-如有问题或建议，请通过以下方式联系：
-
-- 提交Issue
-- 发送邮件
-- 项目讨论区
-
----
-
-**版本**: 2.0.0  
-**更新日期**: 2025-11-13  
-**作者**: Your Name
-