hos-m2f 0.5.4__tar.gz → 0.5.5__tar.gz

{hos_m2f-0.5.4 → hos_m2f-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hos-m2f
-Version: 0.5.4
+Version: 0.5.5
 Summary: HOS-M2F: Markdown to Industry Standard Format Compiler Engine
 Author: HOS Team
 Author-email: team@hos-m2f.com

hos_m2f-0.5.5/README.md

@@ -0,0 +1,426 @@
+# HOS-M2F v1.0
+
+## 多场景结构化内容编译引擎
+
+HOS-M2F = 面向 AI 写作与专业文档生产的 **内容编译器引擎**
+
+Markdown 是源码，不同 Mode 是"目标行业标准"
+
+## 快速开始
+
+### 安装
+
+```bash
+# 克隆仓库
+git clone <repository-url>
+cd HOS-M2F
+
+# 安装依赖
+pip install -e .
+```
+
+### 基本使用
+
+```bash
+# 构建电子书
+HOS_M2F build input.md --mode book --format epub
+
+# 构建技术文档
+HOS_M2F build report.md --mode paper --format pdf
+
+# 校验专利文档
+HOS_M2F check patent.md --mode patent
+```
+
+## 核心功能
+
+### 内置官方模式
+
+| Mode      | 领域    | 核心产出           |
+| --------- | ----- | -------------- |
+| `paper`   | 技术文档  | 报告 / 论文排版      |
+| `patent`  | 专利申请  | 合规专利文件         |
+| `book` 📚 | 电子书出版 | EPUB / KDP     |
+| `sop` 🛠  | 运维与实施 | 巡检 / 报错 / 实施报告 |
+
+### 输出支持
+
+| 格式          | 描述                |
+| ----------- | ----------------- |
+| EPUB        | 电子书格式，支持KDP出版     |
+| DOCX        | Microsoft Word文档格式 |
+| PDF         | 可打印文档格式           |
+| JSON        | 结构化数据格式           |
+| HTML        | 网页格式              |
+| XML         | 标记语言格式            |
+| LaTeX       | 学术排版格式            |
+
+### 输入支持
+
+| 格式          | 描述                |
+| ----------- | ----------------- |
+| Markdown    | 主要输入格式            |
+| PDF         | 支持PDF转Markdown     |
+| DOCX        | 支持Word转Markdown    |
+| EPUB        | 支持电子书转Markdown    |
+| HTML        | 支持网页转Markdown     |
+| XML         | 支持XML转Markdown     |
+
+## 详细使用指南
+
+### CLI 命令
+
+#### 构建命令
+
+```bash
+# 基本构建
+HOS_M2F build input.md --mode book --format epub
+
+# 指定输出路径
+HOS_M2F build input.md --mode paper --format pdf --output output.pdf
+
+# 使用KDP模式构建电子书
+HOS_M2F build book.md --mode book --format epub --options "{\"platform\": \"kdp\"}"
+
+# 批量构建
+HOS_M2F build ./docs/ --mode sop --format pdf --batch
+```
+
+#### 校验命令
+
+```bash
+# 校验书籍
+HOS_M2F check book.md --mode book --platform kdp
+
+# 校验专利
+HOS_M2F check patent.md --mode patent
+
+# 校验SOP文档
+HOS_M2F check sop.md --mode sop
+```
+
+#### 转换命令
+
+```bash
+# Markdown转DOCX
+HOS_M2F convert input.md output.docx --from markdown --to docx
+
+# PDF转Markdown
+HOS_M2F convert input.pdf output.md --from pdf --to markdown
+```
+
+### Python SDK
+
+#### 基本使用
+
+```python
+from hos_m2f import Engine
+
+# 初始化引擎
+engine = Engine()
+
+# 构建电子书
+with open("input.md", "r", encoding="utf-8") as f:
+    markdown_content = f.read()
+
+result = engine.build(
+    content=markdown_content,
+    mode="book",
+    output_format="epub",
+    options={"platform": "kdp", "title": "我的电子书", "author": "作者名"}
+)
+
+# 保存输出
+with open("output.epub", "wb") as f:
+    f.write(result.binary)
+```
+
+#### 格式转换
+
+```python
+from hos_m2f import Engine
+
+# 初始化引擎
+engine = Engine()
+
+# 读取PDF文件
+with open("input.pdf", "rb") as f:
+    pdf_content = f.read()
+
+# 转换为Markdown
+md_content = engine.convert_content(
+    input_format="pdf",
+    output_format="markdown",
+    input_content=pdf_content
+)
+
+# 保存结果
+with open("output.md", "wb") as f:
+    f.write(md_content)
+```
+
+#### 校验文档
+
+```python
+from hos_m2f import Engine
+
+# 初始化引擎
+engine = Engine()
+
+# 读取文档
+with open("patent.md", "r", encoding="utf-8") as f:
+    patent_content = f.read()
+
+# 校验文档
+validation_result = engine.check(
+    content=patent_content,
+    mode="patent"
+)
+
+# 打印校验结果
+print(f"Valid: {validation_result['valid']}")
+if not validation_result['valid']:
+    print("Errors:")
+    for error in validation_result['errors']:
+        print(f"- {error}")
+    print("Warnings:")
+    for warning in validation_result['warnings']:
+        print(f"- {warning}")
+```
+
+## 高级功能
+
+### LaTeX 支持
+
+HOS-M2F 支持 LaTeX 格式输出，特别适合学术论文和技术报告：
+
+```bash
+# 构建LaTeX文档
+HOS_M2F build paper.md --mode paper --format latex
+
+# 构建并编译为PDF
+HOS_M2F build paper.md --mode paper --format latex --options "{\"compile\": true}"
+```
+
+### 自定义模式
+
+您可以通过 YAML 文件创建自定义模式：
+
+```yaml
+# user_modes/meeting_notes.yaml
+name: meeting_notes
+base: paper
+description: 会议记录模式
+
+rules:
+  - type: required_section
+    title: 会议主题
+    level: 2
+  - type: required_section
+    title: 参会人员
+    level: 2
+  - type: required_section
+    title: 会议内容
+    level: 2
+  - type: required_section
+    title: 行动项
+    level: 2
+  - type: required_section
+    title: 下次会议
+    level: 2
+```
+
+使用自定义模式：
+
+```bash
+HOS_M2F build meeting.md --mode meeting_notes --format docx
+```
+
+### KDP 出版支持
+
+HOS-M2F 提供了专门的 KDP 模式，确保您的电子书符合 Amazon KDP 的出版要求：
+
+```bash
+# 构建KDP兼容的电子书
+HOS_M2F build book.md --mode book --format epub --options "{\"platform\": \"kdp\"}"
+
+# 校验KDP兼容性
+HOS_M2F check book.md --mode book --platform kdp
+```
+
+## 项目结构
+
+```
+hos_m2f/
+├── engine/               # ⭐ 对外统一引擎接口
+│   └── engine.py
+│
+├── modes/                # 内置模式
+│   ├── book_mode.py
+│   ├── patent_mode.py
+│   ├── sop_mode.py
+│   └── paper_mode.py
+│
+├── user_modes/           # 用户自定义模式
+│   └── *.yaml
+│
+├── structure/            # 结构解析层
+│   ├── semantic_parser.py
+│   ├── book_parser.py
+│   ├── patent_parser.py
+│   └── sop_parser.py
+│
+├── renderers/            # 渲染适配层
+│   ├── epub_renderer.py
+│   ├── pdf_renderer.py
+│   ├── docx_renderer.py
+│   ├── json_renderer.py
+│   ├── html_renderer.py
+│   ├── xml_renderer.py
+│   └── latex_renderer.py
+│
+├── converters/           # 格式转换层
+│   ├── md_to_docx.py
+│   ├── md_to_epub.py
+│   ├── md_to_html.py
+│   ├── md_to_json.py
+│   ├── md_to_latex.py
+│   ├── md_to_xml.py
+│   ├── docx_to_md.py
+│   ├── epub_to_md.py
+│   ├── html_to_md.py
+│   ├── json_to_md.py
+│   ├── pdf_to_md.py
+│   └── xml_to_md.py
+│
+└── ide/                  # IDE 集成接口
+    ├── api.py
+    └── preview_server.py
+```
+
+## 扩展能力
+
+### 语义校验引擎
+- 专利是否缺少摘要
+- 书籍是否缺版权页
+- SOP 是否缺结论
+- 论文是否缺参考文献
+
+### 风格主题系统
+企业可统一视觉风格：
+
+```yaml
+theme: blue_enterprise
+font: Source Han Sans
+cover_style: minimal
+```
+
+### 增量构建能力
+只更新修改过的章节，提高大书籍或长报告构建速度
+
+### 结构化数据导出
+SOP 报告可导出 JSON 供企业系统分析
+
+### Mermaid 图表支持
+自动渲染 Mermaid 图表为图片：
+
+```markdown
+```mermaid
+graph TD
+    A[开始] --> B[处理]
+    B --> C[结束]
+```
+```
+
+### 表格增强
+支持复杂表格的渲染，包括对齐和样式：
+
+```markdown
+| 左对齐 | 居中 | 右对齐 |
+| :--- | :---: | ---: |
+| 内容 | 内容 | 内容 |
+| 内容 | 内容 | 内容 |
+```
+
+## 故障排除
+
+### 常见问题
+
+#### 1. LaTeX 编译失败
+
+**问题**：LaTeX 编译失败，提示缺少依赖。
+
+**解决方案**：安装 LaTeX 发行版，如 TeX Live 或 MiKTeX。
+
+#### 2. PDF 渲染失败
+
+**问题**：PDF 渲染失败，提示缺少 WeasyPrint 依赖。
+
+**解决方案**：安装 WeasyPrint：
+```bash
+pip install weasyprint
+```
+
+#### 3. EPUB 生成错误
+
+**问题**：EPUB 生成失败，提示缺少 ebooklib 依赖。
+
+**解决方案**：安装 ebooklib：
+```bash
+pip install ebooklib
+```
+
+#### 4. Mermaid 图表不显示
+
+**问题**：Mermaid 图表在输出中不显示。
+
+**解决方案**：确保网络连接正常，Mermaid 图表需要通过网络渲染。
+
+### 错误代码
+
+| 错误代码 | 描述                | 解决方案              |
+| ---- | ----------------- | ------------------ |
+| 1001 | 模式不存在             | 检查模式名称是否正确         |
+| 1002 | 输出格式不支持           | 检查格式是否在支持列表中       |
+| 1003 | 输入文件不存在           | 检查文件路径是否正确         |
+| 1004 | 依赖项缺失             | 安装缺失的依赖项          |
+| 1005 | 文档结构无效            | 检查文档结构是否符合模式要求     |
+| 1006 | KDP 兼容性错误         | 修复 KDP 兼容性问题       |
+| 1007 | LaTeX 编译失败         | 检查 LaTeX 语法和依赖项    |
+| 1008 | PDF 渲染失败          | 检查 WeasyPrint 安装和配置 |
+
+## 性能优化
+
+### 大文档处理
+
+对于大型文档（超过 100 页），建议使用以下优化：
+
+1. **启用增量构建**：只更新修改过的章节
+2. **使用分段处理**：将大文档拆分为多个小文档
+3. **选择合适的输出格式**：对于预览，使用 HTML 格式
+4. **限制图片分辨率**：减少图片大小以提高处理速度
+
+### 批量处理
+
+对于批量处理多个文档，建议：
+
+1. **使用 `--batch` 参数**：启用批量处理模式
+2. **设置合理的并发数**：避免系统资源耗尽
+3. **使用日志记录**：跟踪处理进度和错误
+
+## 许可证
+MIT License
+
+## 贡献
+
+欢迎贡献代码、报告问题或提出建议！
+
+## 联系方式
+
+- 项目主页：<repository-url>
+- 问题反馈：<repository-url>/issues
+- 邮件：<contact-email>
+
+---
+
+**HOS-M2F** - 让专业文档生产更简单！

{hos_m2f-0.5.4 → hos_m2f-0.5.5}/hos_m2f/converters/md_to_docx.py

@@ -95,10 +95,28 @@ class MDToDOCXConverter(BaseConverter):
                     # 填充表头
                     header_row = table.rows[0]
                     for i, cell_text in enumerate(header_cells):
-                        header_row.cells[i].text = cell_text
+                        cell = header_row.cells[i]
+                        cell.text = cell_text
+                        # 设置表头样式
+                        for paragraph in cell.paragraphs:
+                            for run in paragraph.runs:
+                                run.bold = True
+                                run.font.size = Pt(11)
+                            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
                     
-                    # 跳过分隔线行
+                    # 跳过分隔线行，并解析对齐方式
+                    alignments = []
                     if len(rows) > 1 and '---' in rows[1]:
+                        # 解析对齐方式
+                        alignment_row = rows[1]
+                        alignment_cells = [cell.strip() for cell in alignment_row.split('|') if cell.strip()]
+                        for cell in alignment_cells:
+                            if cell.startswith(':') and cell.endswith(':'):
+                                alignments.append(WD_ALIGN_PARAGRAPH.CENTER)
+                            elif cell.endswith(':'):
+                                alignments.append(WD_ALIGN_PARAGRAPH.RIGHT)
+                            else:
+                                alignments.append(WD_ALIGN_PARAGRAPH.LEFT)
                         data_rows = rows[2:]
                     else:
                         data_rows = rows[1:]
@@ -110,7 +128,12 @@ class MDToDOCXConverter(BaseConverter):
                             new_row = table.add_row()
                             for i, cell_text in enumerate(cells):
                                 if i < len(new_row.cells):
-                                    new_row.cells[i].text = cell_text
+                                    cell = new_row.cells[i]
+                                    cell.text = cell_text
+                                    # 设置对齐方式
+                                    if i < len(alignments):
+                                        for paragraph in cell.paragraphs:
+                                            paragraph.alignment = alignments[i]
                 except Exception as e:
                     # 如果解析失败，回退到简单处理
                     self.doc.add_paragraph('Table: ' + text[:100] + '...')
@@ -217,9 +240,31 @@ class MDToDOCXConverter(BaseConverter):
             
             def _render_mermaid(self, mermaid_code):
                 """渲染Mermaid图表为图片"""
-                # 简化处理，实际项目中需要使用mermaid-cli或其他工具
-                # 这里返回None，回退到显示代码块
-                return None
+                # 使用mermaid.ink API渲染Mermaid图表
+                try:
+                    import requests
+                    from io import BytesIO
+                    import urllib.parse
+                    
+                    # 编码Mermaid代码
+                    encoded_code = urllib.parse.quote(mermaid_code)
+                    
+                    # 构建API URL
+                    url = f"https://mermaid.ink/img/{encoded_code}"
+                    
+                    # 发送请求
+                    response = requests.get(url, timeout=10)
+                    
+                    if response.status_code == 200:
+                        # 返回图片数据流
+                        return BytesIO(response.content)
+                    else:
+                        # 如果API调用失败，返回None
+                        return None
+                except Exception as e:
+                    # 如果处理失败，返回None
+                    print(f"Error rendering Mermaid chart: {e}")
+                    return None
         
         # 渲染Markdown
         renderer = DOCXRenderer(doc)

hos_m2f-0.5.5/hos_m2f/converters/md_to_epub.py

@@ -0,0 +1,68 @@
+"""Markdown到EPUB格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+from hos_m2f.renderers.epub_renderer import EPUBRenderer
+from hos_m2f.structure.book_parser import BookParser
+
+
+class MDToEPUBConverter(BaseConverter):
+    """Markdown到EPUB格式转换器"""
+    
+    def __init__(self):
+        """初始化转换器"""
+        self.renderer = EPUBRenderer()
+        self.book_parser = BookParser()
+    
+    def convert(self, input_content: str, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将Markdown转换为EPUB
+        
+        Args:
+            input_content: Markdown内容
+            options: 转换选项
+            
+        Returns:
+            bytes: EPUB文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 使用BookParser解析Markdown内容
+        parsed_content = self.book_parser.parse(input_content, options)
+        
+        # 增强解析结果
+        parsed_content = self._enhance_parsed_content(parsed_content, options)
+        
+        # 使用EPUBRenderer渲染EPUB文件
+        epub_content = self.renderer.render(parsed_content, options)
+        
+        return epub_content
+    
+    def _enhance_parsed_content(self, parsed_content: Dict[str, Any], options: Dict[str, Any]) -> Dict[str, Any]:
+        """增强解析结果"""
+        # 添加选项中的元数据
+        if 'title' in options:
+            parsed_content.setdefault('book_metadata', {})['title'] = options['title']
+        if 'author' in options:
+            parsed_content.setdefault('book_metadata', {})['author'] = options['author']
+        if 'language' in options:
+            parsed_content.setdefault('book_metadata', {})['language'] = options['language']
+        if 'publisher' in options:
+            parsed_content.setdefault('book_metadata', {})['publisher'] = options['publisher']
+        if 'publish_date' in options:
+            parsed_content.setdefault('book_metadata', {})['publish_date'] = options['publish_date']
+        if 'description' in options:
+            parsed_content.setdefault('book_metadata', {})['description'] = options['description']
+        
+        # 添加封面信息
+        if 'cover' in options:
+            parsed_content['cover'] = {
+                'src': options['cover'],
+                'type': 'image'
+            }
+        
+        return parsed_content
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('markdown', 'epub')

hos_m2f-0.5.5/hos_m2f/converters/md_to_latex.py

@@ -0,0 +1,63 @@
+"""Markdown到LaTeX格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+from hos_m2f.renderers.latex_renderer import LaTeXRenderer
+from hos_m2f.structure.semantic_parser import SemanticParser
+
+
+class MDToLaTeXConverter(BaseConverter):
+    """Markdown到LaTeX格式转换器"""
+    
+    def __init__(self):
+        """初始化转换器"""
+        self.renderer = LaTeXRenderer()
+        self.parser = SemanticParser()
+    
+    def convert(self, input_content: str, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将Markdown转换为LaTeX
+        
+        Args:
+            input_content: Markdown内容
+            options: 转换选项
+            
+        Returns:
+            bytes: LaTeX文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 使用SemanticParser解析Markdown内容
+        parsed_content = self.parser.parse(input_content)
+        
+        # 增强解析结果
+        parsed_content = self._enhance_parsed_content(parsed_content, options)
+        
+        # 使用LaTeXRenderer渲染LaTeX文件
+        latex_content = self.renderer.render(parsed_content, options)
+        
+        return latex_content
+    
+    def _enhance_parsed_content(self, parsed_content: Dict[str, Any], options: Dict[str, Any]) -> Dict[str, Any]:
+        """增强解析结果"""
+        # 添加选项中的元数据
+        if 'title' in options:
+            parsed_content.setdefault('metadata', {})['title'] = options['title']
+        if 'author' in options:
+            parsed_content.setdefault('metadata', {})['author'] = options['author']
+        if 'date' in options:
+            parsed_content.setdefault('metadata', {})['date'] = options['date']
+        if 'abstract' in options:
+            parsed_content.setdefault('metadata', {})['abstract'] = options['abstract']
+        if 'keywords' in options:
+            parsed_content.setdefault('metadata', {})['keywords'] = options['keywords']
+        
+        # 添加文档类型
+        if 'document_class' in options:
+            parsed_content['document_class'] = options['document_class']
+        
+        return parsed_content
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('markdown', 'latex')

hos_m2f-0.5.5/hos_m2f/converters/pdf_to_md.py

@@ -0,0 +1,120 @@
+"""PDF到Markdown格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+
+# 延迟导入PyPDF2
+pypdf2_available = False
+PdfReader = None
+
+
+def _check_pypdf2():
+    """检查PyPDF2是否可用"""
+    global pypdf2_available, PdfReader
+    if not pypdf2_available:
+        try:
+            from PyPDF2 import PdfReader
+            pypdf2_available = True
+        except ImportError as e:
+            print(f"Warning: PyPDF2 not available: {e}")
+            print("PDF to Markdown conversion is disabled.")
+
+
+class PDFToMDConverter(BaseConverter):
+    """PDF到Markdown格式转换器"""
+    
+    def convert(self, input_content: bytes, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将PDF转换为Markdown
+        
+        Args:
+            input_content: PDF文件的二进制数据
+            options: 转换选项
+            
+        Returns:
+            bytes: Markdown文件的二进制数据
+        """
+        # 检查PyPDF2是否可用
+        _check_pypdf2()
+        if not pypdf2_available:
+            raise ImportError("PyPDF2 is not available. PDF to Markdown conversion is disabled.")
+        
+        if options is None:
+            options = {}
+        
+        # 解析PDF内容
+        markdown_content = self._parse_pdf(input_content, options)
+        
+        return markdown_content.encode('utf-8')
+    
+    def _parse_pdf(self, pdf_content: bytes, options: Dict[str, Any]) -> str:
+        """解析PDF内容并转换为Markdown"""
+        import io
+        
+        # 创建PDF阅读器
+        pdf_reader = PdfReader(io.BytesIO(pdf_content))
+        
+        # 提取文本
+        text_content = []
+        for page_num in range(len(pdf_reader.pages)):
+            page = pdf_reader.pages[page_num]
+            text = page.extract_text()
+            if text:
+                text_content.append(text)
+        
+        # 合并文本
+        full_text = '\n\n'.join(text_content)
+        
+        # 转换为Markdown
+        markdown_content = self._text_to_markdown(full_text, options)
+        
+        return markdown_content
+    
+    def _text_to_markdown(self, text: str, options: Dict[str, Any]) -> str:
+        """将纯文本转换为Markdown"""
+        import re
+        
+        # 分割行
+        lines = text.split('\n')
+        
+        # 处理标题
+        markdown_lines = []
+        for line in lines:
+            line = line.strip()
+            if not line:
+                markdown_lines.append('')
+                continue
+            
+            # 简单的标题识别
+            # 假设以数字开头的行可能是标题
+            if re.match(r'^\d+\.', line):
+                # 检查数字级别
+                match = re.match(r'^(\d+)\.', line)
+                if match:
+                    level = len(match.group(1).split('.'))
+                    if level <= 6:
+                        markdown_lines.append(f'{'#' * level} {line}')
+                        continue
+            
+            # 检查是否是大写标题
+            if line.isupper() and len(line) < 50:
+                markdown_lines.append(f'## {line}')
+                continue
+            
+            # 普通行
+            markdown_lines.append(line)
+        
+        # 合并行
+        markdown_content = '\n'.join(markdown_lines)
+        
+        # 处理列表
+        markdown_content = re.sub(r'^\s*\-\s(.*)$', r'* \1', markdown_content, flags=re.MULTILINE)
+        markdown_content = re.sub(r'^\s*\*\s(.*)$', r'* \1', markdown_content, flags=re.MULTILINE)
+        
+        # 处理粗体
+        markdown_content = re.sub(r'\b([A-Z]{3,})\b', r'**\1**', markdown_content)
+        
+        return markdown_content
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('pdf', 'md')

{hos_m2f-0.5.4 → hos_m2f-0.5.5}/hos_m2f.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hos-m2f
-Version: 0.5.4
+Version: 0.5.5
 Summary: HOS-M2F: Markdown to Industry Standard Format Compiler Engine
 Author: HOS Team
 Author-email: team@hos-m2f.com

{hos_m2f-0.5.4 → hos_m2f-0.5.5}/hos_m2f.egg-info/SOURCES.txt

@@ -19,8 +19,11 @@ hos_m2f/converters/md_to_docx.py
 hos_m2f/converters/md_to_epub.py
 hos_m2f/converters/md_to_html.py
 hos_m2f/converters/md_to_json.py
+hos_m2f/converters/md_to_latex.py
 hos_m2f/converters/md_to_xml.py
+hos_m2f/converters/pdf_to_md.py
 hos_m2f/converters/xml_to_md.py
 tests/__init__.py
 tests/test_converters.py
+tests/test_latex.py
 tests/test_modes.py

{hos_m2f-0.5.4 → hos_m2f-0.5.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="hos-m2f",
-    version="0.5.4",
+    version="0.5.5",
     description="HOS-M2F: Markdown to Industry Standard Format Compiler Engine",
     long_description="""HOS-M2F is a powerful compiler engine that converts Markdown files to various industry standard formats.
 

hos_m2f-0.5.5/tests/test_latex.py

@@ -0,0 +1,182 @@
+"""测试LaTeX渲染器和转换器"""
+
+import unittest
+import os
+import tempfile
+from hos_m2f.renderers.latex_renderer import LaTeXRenderer
+from hos_m2f.converters.md_to_latex import MDToLaTeXConverter
+
+
+class TestLaTeX(unittest.TestCase):
+    """测试LaTeX渲染器和转换器"""
+    
+    def setUp(self):
+        """设置测试环境"""
+        # 创建测试用的Markdown内容
+        self.test_content = """
+# 测试文档
+
+## 摘要
+
+这是一个测试文档，用于测试LaTeX渲染功能。
+
+## 引言
+
+这是引言章节的内容。
+
+### 背景
+
+这是背景部分的内容。
+
+## 方法
+
+这是方法章节的内容。
+
+### 实验设计
+
+这是实验设计部分的内容。
+
+## 结果
+
+这是结果章节的内容。
+
+### 数据表格
+
+| 列1 | 列2 | 列3 |
+| --- | --- | --- |
+| 行1 | 行1 | 行1 |
+| 行2 | 行2 | 行2 |
+
+### 代码示例
+
+```python
+print("Hello, world!")
+```
+
+## 讨论
+
+这是讨论章节的内容。
+
+## 结论
+
+这是结论章节的内容。
+
+## 参考文献
+
+[1] 参考文献1
+[2] 参考文献2
+        """.strip()
+        
+        # 创建测试用的结构化内容
+        self.structured_content = {
+            "metadata": {
+                "title": "测试文档",
+                "author": "测试作者",
+                "date": "2023-01-01",
+                "abstract": "这是一个测试文档，用于测试LaTeX渲染功能。",
+                "keywords": ["测试", "LaTeX", "渲染"]
+            },
+            "structure": [
+                {"level": 1, "title": "测试文档", "line_number": 1},
+                {"level": 2, "title": "摘要", "line_number": 3},
+                {"level": 2, "title": "引言", "line_number": 7},
+                {"level": 3, "title": "背景", "line_number": 9},
+                {"level": 2, "title": "方法", "line_number": 13},
+                {"level": 3, "title": "实验设计", "line_number": 15},
+                {"level": 2, "title": "结果", "line_number": 19},
+                {"level": 3, "title": "数据表格", "line_number": 21},
+                {"level": 3, "title": "代码示例", "line_number": 29},
+                {"level": 2, "title": "讨论", "line_number": 35},
+                {"level": 2, "title": "结论", "line_number": 39},
+                {"level": 2, "title": "参考文献", "line_number": 43}
+            ],
+            "chapters": [
+                {"title": "测试文档", "content": "", "level": 1, "start_line": 1, "end_line": 1},
+                {"title": "摘要", "content": "这是一个测试文档，用于测试LaTeX渲染功能。", "level": 2, "start_line": 3, "end_line": 5},
+                {"title": "引言", "content": "这是引言章节的内容。", "level": 2, "start_line": 7, "end_line": 8},
+                {"title": "背景", "content": "这是背景部分的内容。", "level": 3, "start_line": 9, "end_line": 11},
+                {"title": "方法", "content": "这是方法章节的内容。", "level": 2, "start_line": 13, "end_line": 14},
+                {"title": "实验设计", "content": "这是实验设计部分的内容。", "level": 3, "start_line": 15, "end_line": 17},
+                {"title": "结果", "content": "这是结果章节的内容。", "level": 2, "start_line": 19, "end_line": 20},
+                {"title": "数据表格", "content": "| 列1 | 列2 | 列3 |\n| --- | --- | --- |\n| 行1 | 行1 | 行1 |\n| 行2 | 行2 | 行2 |", "level": 3, "start_line": 21, "end_line": 28},
+                {"title": "代码示例", "content": "```python\nprint(\"Hello, world!\")\n```", "level": 3, "start_line": 29, "end_line": 34},
+                {"title": "讨论", "content": "这是讨论章节的内容。", "level": 2, "start_line": 35, "end_line": 37},
+                {"title": "结论", "content": "这是结论章节的内容。", "level": 2, "start_line": 39, "end_line": 41},
+                {"title": "参考文献", "content": "[1] 参考文献1\n[2] 参考文献2", "level": 2, "start_line": 43, "end_line": 46}
+            ],
+            "references": [
+                {"text": "参考文献1"},
+                {"text": "参考文献2"}
+            ]
+        }
+    
+    def test_latex_renderer(self):
+        """测试LaTeX渲染器"""
+        renderer = LaTeXRenderer()
+        
+        # 测试渲染功能
+        latex_content = renderer.render(self.structured_content)
+        self.assertIsInstance(latex_content, bytes)
+        self.assertGreater(len(latex_content), 0)
+        
+        # 保存为临时文件，以便手动检查
+        with tempfile.NamedTemporaryFile(suffix=".tex", delete=False) as tmp:
+            tmp.write(latex_content)
+            tmp_path = tmp.name
+        
+        try:
+            # 验证文件存在且大小大于0
+            self.assertTrue(os.path.exists(tmp_path))
+            self.assertGreater(os.path.getsize(tmp_path), 0)
+        finally:
+            # 清理临时文件
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+    
+    def test_md_to_latex_converter(self):
+        """测试Markdown到LaTeX转换器"""
+        converter = MDToLaTeXConverter()
+        
+        # 测试转换功能
+        result = converter.convert(self.test_content)
+        self.assertIsInstance(result, bytes)
+        self.assertGreater(len(result), 0)
+        
+        # 保存为临时文件，以便手动检查
+        with tempfile.NamedTemporaryFile(suffix=".tex", delete=False) as tmp:
+            tmp.write(result)
+            tmp_path = tmp.name
+        
+        try:
+            # 验证文件存在且大小大于0
+            self.assertTrue(os.path.exists(tmp_path))
+            self.assertGreater(os.path.getsize(tmp_path), 0)
+        finally:
+            # 清理临时文件
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+    
+    def test_latex_with_options(self):
+        """测试带选项的LaTeX渲染"""
+        renderer = LaTeXRenderer()
+        converter = MDToLaTeXConverter()
+        
+        # 测试带选项的渲染
+        options = {
+            "document_class": "article",
+            "document_options": "a4paper, 12pt",
+            "table_of_contents": True
+        }
+        
+        latex_content = renderer.render(self.structured_content, options)
+        self.assertIsInstance(latex_content, bytes)
+        self.assertGreater(len(latex_content), 0)
+        
+        # 测试带选项的转换
+        result = converter.convert(self.test_content, options)
+        self.assertIsInstance(result, bytes)
+        self.assertGreater(len(result), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

hos_m2f-0.5.4/README.md

@@ -1,130 +0,0 @@
-# HOS-M2F v1.0
-
-## 多场景结构化内容编译引擎
-
-HOS-M2F = 面向 AI 写作与专业文档生产的 **内容编译器引擎**
-
-Markdown 是源码，不同 Mode 是"目标行业标准"
-
-## 核心功能
-
-### 内置官方模式
-
-| Mode      | 领域    | 核心产出           |
-| --------- | ----- | -------------- |
-| `paper`   | 技术文档  | 报告 / 论文排版      |
-| `patent`  | 专利申请  | 合规专利文件         |
-| `book` 📚 | 电子书出版 | EPUB / KDP     |
-| `sop` 🛠  | 运维与实施 | 巡检 / 报错 / 实施报告 |
-
-### 输出支持
-
-| 平台         | 格式          |
-| ---------- | ----------- |
-| Amazon KDP | EPUB / DOCX |
-| Kindle     | MOBI / AZW3 |
-| 通用阅读器      | EPUB 3      |
-| 印刷         | Print PDF   |
-| 企业系统       | JSON / HTML |
-
-## 安装
-
-```bash
-pip install -e .
-```
-
-## 使用方法
-
-### CLI 命令
-
-```bash
-# 构建
-HOS_M2F build input.md --mode book
-HOS_M2F build report.md --mode sop --format pdf
-
-# 校验
-HOS_M2F check book.md --mode book --platform kdp
-HOS_M2F check report.md --mode sop
-
-# 批量
-HOS_M2F build ./reports/ --mode sop --batch
-```
-
-### Python SDK
-
-```python
-from hos_m2f import Engine
-
-engine = Engine()
-
-result = engine.build(
-    content=markdown_text,
-    mode="book",
-    output_format="epub",
-    options={"platform": "kdp"}
-)
-
-with open("output.epub", "wb") as f:
-    f.write(result.binary)
-```
-
-## 项目结构
-
-```
-hos_m2f/
-├── engine/               # ⭐ 对外统一引擎接口
-│   └── engine.py
-│
-├── modes/                # 内置模式
-│   ├── book_mode.py
-│   ├── patent_mode.py
-│   ├── sop_mode.py
-│   └── paper_mode.py
-│
-├── user_modes/           # 用户自定义模式
-│   └── *.yaml
-│
-├── structure/            # 结构解析层
-│   ├── semantic_parser.py
-│   ├── book_parser.py
-│   ├── patent_parser.py
-│   └── sop_parser.py
-│
-├── renderers/            # 渲染适配层
-│   ├── epub_renderer.py
-│   ├── pdf_renderer.py
-│   ├── docx_renderer.py
-│   └── json_renderer.py
-│
-└── ide/                  # IDE 集成接口
-    ├── api.py
-    └── preview_server.py
-```
-
-## 扩展能力
-
-### 语义校验引擎
-- 专利是否缺少摘要
-- 书籍是否缺版权页
-- SOP 是否缺结论
-
-### 风格主题系统
-企业可统一视觉风格：
-
-```yaml
-theme: blue_enterprise
-font: Source Han Sans
-cover_style: minimal
-```
-
-### 增量构建能力
-只更新修改过的章节，提高大书籍或长报告构建速度
-
-### 结构化数据导出
-SOP 报告可导出 JSON 供企业系统分析
-
-### AI 协同接口（未来扩展）
-让大模型直接输出符合某 Mode 的结构，而不是自由 Markdown
-
-## 许可证
-MIT License

hos_m2f-0.5.4/hos_m2f/converters/md_to_epub.py

@@ -1,96 +0,0 @@
-"""Markdown到EPUB格式转换器"""
-
-from typing import Any, Optional, Dict
-from hos_m2f.converters.base_converter import BaseConverter
-import ebooklib
-from ebooklib import epub
-import mistune
-
-
-class MDToEPUBConverter(BaseConverter):
-    """Markdown到EPUB格式转换器"""
-    
-    def convert(self, input_content: str, options: Optional[Dict[str, Any]] = None) -> bytes:
-        """将Markdown转换为EPUB
-        
-        Args:
-            input_content: Markdown内容
-            options: 转换选项
-            
-        Returns:
-            bytes: EPUB文件的二进制数据
-        """
-        if options is None:
-            options = {}
-        
-        # 创建EPUB书籍
-        book = epub.EpubBook()
-        
-        # 设置元数据
-        book.set_identifier('id12345')
-        book.set_title(options.get('title', 'Untitled'))
-        book.set_language(options.get('language', 'zh'))
-        book.add_author(options.get('author', 'Unknown'))
-        
-        # 添加封面
-        if 'cover' in options:
-            cover_image = epub.EpubItem(
-                uid='cover-image',
-                file_name='images/cover.jpg',
-                media_type='image/jpeg',
-                content=options['cover']
-            )
-            book.add_item(cover_image)
-            book.set_cover('images/cover.jpg', cover_image)
-        
-        # 解析Markdown
-        markdown = mistune.create_markdown()
-
-        
-        # 转换为HTML
-        html_content = markdown(input_content)
-        
-        # 创建章节
-        chapter = epub.EpubHtml(
-            title=options.get('title', 'Chapter 1'),
-            file_name='chapter1.xhtml',
-            lang='zh'
-        )
-        chapter.content = f'''
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>{options.get('title', 'Untitled')}</title>
-            <meta charset="utf-8" />
-        </head>
-        <body>
-            <h1>{options.get('title', 'Untitled')}</h1>
-            {html_content}
-        </body>
-        </html>
-        '''
-        
-        # 添加章节
-        book.add_item(chapter)
-        
-        # 创建目录
-        book.toc = [chapter]
-        
-        # 添加导航文件
-        book.add_item(epub.EpubNcx())
-        book.add_item(epub.EpubNav())
-        
-        # 定义spine
-        book.spine = ['nav', chapter]
-        
-        # 保存为二进制数据
-        import io
-        output = io.BytesIO()
-        epub.write_epub(output, book, {})
-        output.seek(0)
-        
-        return output.getvalue()
-    
-    def get_supported_formats(self) -> tuple:
-        """获取支持的格式"""
-        return ('markdown', 'epub')