doc_parser.py

"""
文档解析模块 - 深度学习报告模板格式
支持 .docx 和 .doc 格式，提取标题层级、字数统计、实验数量等
"""

import os
import re
import glob
import struct
from docx import Document
from docx.shared import Pt, RGBColor, Inches
from docx.enum.text import WD_ALIGN_PARAGRAPH
import olefile


class TemplateLearner:
    """深度报告模板学习器"""
    
    def __init__(self, reports_dir):
        self.reports_dir = reports_dir
        self.templates = []
        self.learned_patterns = {
            'title_patterns': [],
            'heading_patterns': [],
            'section_structures': [],
            'avg_word_count': 0,
            'avg_exp_count': 0,
            'font_styles': {},
            'header_fields': []
        }
        self.learned = False
    
    def learn_all(self):
        """学习所有报告文件"""
        if not os.path.exists(self.reports_dir):
            return False
        
        files = glob.glob(os.path.join(self.reports_dir, "*.doc*"))
        if not files:
            return False
        
        for filepath in files:
            try:
                template = self._parse_file(filepath)
                if template:
                    self.templates.append(template)
            except Exception as e:
                print(f"解析失败 {filepath}: {e}")
        
        if self.templates:
            self._deep_analyze()
            self.learned = True
            print(f"成功学习 {len(self.templates)} 个模板，平均字数: {self.learned_patterns['avg_word_count']}")
            return True
        return False
    
    def _parse_file(self, filepath):
        """解析单个文件"""
        if filepath.endswith('.docx'):
            return self._parse_docx(filepath)
        elif filepath.endswith('.doc'):
            return self._parse_doc(filepath)
        return None
    
    def _parse_docx(self, filepath):
        """解析 .docx"""
        doc = Document(filepath)
        template = {
            'filename': os.path.basename(filepath),
            'type': 'docx',
            'title': '',
            'total_words': 0,
            'experiments': [],
            'headings': [],
            'header_info': {},
            'paragraphs': []
        }
        
        full_text = []
        for para in doc.paragraphs:
            text = para.text.strip()
            if text:
                full_text.append(text)
                template['total_words'] += len(text)
                
                # 检测标题层级
                heading_info = self._detect_heading_level(text, para)
                if heading_info:
                    template['headings'].append(heading_info)
                
                # 检测实验
                if self._is_experiment_title(text):
                    template['experiments'].append(text)
                
                # 提取字体信息
                if para.runs:
                    run = para.runs[0]
                    template['paragraphs'].append({
                        'text': text,
                        'style': para.style.name if para.style else 'Normal',
                        'font_size': run.font.size.pt if run.font.size else None,
                        'font_name': run.font.name,
                        'bold': run.font.bold,
                        'alignment': str(para.alignment)
                    })
        
        template['full_text'] = '\n'.join(full_text)
        return template
    
    def _parse_doc(self, filepath):
        """解析 .doc (旧格式)"""
        try:
            ole = olefile.OleFileIO(filepath)
            template = {
                'filename': os.path.basename(filepath),
                'type': 'doc',
                'title': '',
                'total_words': 0,
                'experiments': [],
                'headings': [],
                'header_info': {},
                'paragraphs': []
            }
            
            if ole.exists('WordDocument'):
                word_stream = ole.openstream('WordDocument').read()
                
                # 从FIB提取文本
                fc_min = struct.unpack('<I', word_stream[0x18:0x1C])[0]
                ccp_text = struct.unpack('<I', word_stream[0x4C:0x50])[0]
                
                text_data = word_stream[fc_min:fc_min + ccp_text * 2]
                text = text_data.decode('utf-16le', errors='ignore')
                
                # 按段落分割
                paragraphs = text.split('\r')
                full_text = []
                
                for p in paragraphs:
                    p = p.strip()
                    if p:
                        full_text.append(p)
                        template['total_words'] += len(p)
                        
                        # 检测标题
                        heading_info = self._detect_heading_level(p, None)
                        if heading_info:
                            template['headings'].append(heading_info)
                        
                        # 检测实验
                        if self._is_experiment_title(p):
                            template['experiments'].append(p)
                        
                        template['paragraphs'].append({
                            'text': p,
                            'style': 'Normal',
                            'font_size': None,
                            'font_name': None,
                            'bold': False
                        })
                
                template['full_text'] = '\n'.join(full_text)
            
            ole.close()
            return template
            
        except Exception as e:
            print(f"解析.doc失败: {e}")
            return None
    
    def _detect_heading_level(self, text, para):
        """检测标题层级"""
        text = text.strip()
        
        # 大标题: 实验一、实验二等
        if re.match(r'^实验[一二三四五六七八九十]+[、\s]', text) and len(text) < 80:
            return {'level': 0, 'text': text, 'type': 'experiment_title'}
        
        # 一级标题: 一、二、三...
        if re.match(r'^[一二三四五六七八九十]+、', text) and len(text) < 50:
            return {'level': 1, 'text': text, 'type': 'heading_1'}
        
        # 二级标题: 1.1, 2.1, 3.1...
        if re.match(r'^\d+\.\d+', text) and len(text) < 60:
            return {'level': 2, 'text': text, 'type': 'heading_2'}
        
        # 三级标题: 1., 2., 3. (后面不是数字)
        if re.match(r'^\d+\.\s', text) and len(text) < 80:
            return {'level': 3, 'text': text, 'type': 'heading_3'}
        
        return None
    
    def _is_experiment_title(self, text):
        """检测是否是实验标题"""
        patterns = [
            r'^实验[一二三四五六七八九十]+[、\s]',
            r'实验名称[：:]',
        ]
        for p in patterns:
            if re.search(p, text):
                return True
        return False
    
    def _deep_analyze(self):
        """深度分析模板结构"""
        if not self.templates:
            return
        
        # 统计字数
        total_words = sum(t['total_words'] for t in self.templates)
        self.learned_patterns['avg_word_count'] = total_words // len(self.templates)
        
        # 统计实验数量
        total_exps = sum(len(t['experiments']) for t in self.templates)
        self.learned_patterns['avg_exp_count'] = total_exps // len(self.templates)
        
        # 收集标题模式
        all_headings = []
        for t in self.templates:
            all_headings.extend(t['headings'])
        
        # 分析一级标题结构
        h1_patterns = {}
        for h in all_headings:
            if h['level'] == 1:
                text = h['text']
                # 提取关键词
                keywords = re.findall(r'[\u4e00-\u9fa5]+', text)
                for kw in keywords:
                    h1_patterns[kw] = h1_patterns.get(kw, 0) + 1
        
        self.learned_patterns['heading_patterns'] = sorted(
            h1_patterns.items(), key=lambda x: x[1], reverse=True
        )[:20]
        
        # 分析字体大小
        font_sizes = []
        for t in self.templates:
            for p in t['paragraphs']:
                if p.get('font_size'):
                    font_sizes.append(p['font_size'])
        
        if font_sizes:
            from collections import Counter
            size_counter = Counter(font_sizes)
            most_common = size_counter.most_common(1)
            if most_common:
                self.learned_patterns['common_font_size'] = most_common[0][0]
            self.learned_patterns['title_font_size'] = max(font_sizes)
        
        # 收集表头字段
        header_fields = set()
        for t in self.templates:
            text = t.get('full_text', '')
            fields = re.findall(r'(课程名称|实验名称|实验地点|专业班级|学号|学生姓名|指导教师|日期)[：:]', text)
            header_fields.update(fields)
        
        self.learned_patterns['header_fields'] = list(header_fields)
    
    def get_template_info(self):
        """获取学习到的模板信息"""
        if not self.learned:
            return None
        
        return {
            'patterns': self.learned_patterns,
            'template_count': len(self.templates),
            'sample_template': self.templates[0] if self.templates else None
        }
    
    def get_avg_word_count(self):
        """获取平均字数"""
        return self.learned_patterns.get('avg_word_count', 5000)
    
    def get_avg_exp_count(self):
        """获取平均实验数量"""
        return self.learned_patterns.get('avg_exp_count', 1)
    
    def get_heading_patterns(self):
        """获取标题模式"""
        return self.learned_patterns.get('heading_patterns', [])


class DocParser:
    """文档解析器"""
    
    def __init__(self):
        self.learner = None
    
    def learn_templates(self, reports_dir):
        """学习模板"""
        self.learner = TemplateLearner(reports_dir)
        return self.learner.learn_all()
    
    def get_template_info(self):
        """获取模板信息"""
        if self.learner:
            return self.learner.get_template_info()
        return None
    
    def get_avg_word_count(self):
        """获取平均字数要求"""
        if self.learner:
            return self.learner.get_avg_word_count()
        return 5000
    
    def get_avg_exp_count(self):
        """获取平均实验数量"""
        if self.learner:
            return self.learner.get_avg_exp_count()
        return 1
    
    def parse(self, file_path):
        """解析单个文档"""
        if not os.path.exists(file_path):
            return None
        
        learner = TemplateLearner(os.path.dirname(file_path))
        return learner._parse_file(file_path)


if __name__ == "__main__":
    parser = DocParser()
    reports_dir = r"D:\HuaweiMoveData\Users\张文瑞\Desktop\作业提交\已完成报告"
    
    if parser.learn_templates(reports_dir):
        info = parser.get_template_info()
        print(f"模板数量: {info['template_count']}")
        print(f"平均字数: {info['patterns']['avg_word_count']}")
        print(f"平均实验数: {info['patterns']['avg_exp_count']}")
        print(f"标题模式: {info['patterns']['heading_patterns'][:10]}")
    else:
        print("学习失败")