hos-m2f 0.5.4__py3-none-any.whl → 0.5.5__py3-none-any.whl

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/converters/md_to_epub.py

@@ -2,14 +2,18 @@
 
 from typing import Any, Optional, Dict
 from hos_m2f.converters.base_converter import BaseConverter
-import ebooklib
-from ebooklib import epub
-import mistune
+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
         
@@ -23,73 +27,41 @@ class MDToEPUBConverter(BaseConverter):
         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()
-
+        # 使用BookParser解析Markdown内容
+        parsed_content = self.book_parser.parse(input_content, options)
         
-        # 转换为HTML
-        html_content = markdown(input_content)
+        # 增强解析结果
+        parsed_content = self._enhance_parsed_content(parsed_content, options)
         
-        # 创建章节
-        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>
-        '''
+        # 使用EPUBRenderer渲染EPUB文件
+        epub_content = self.renderer.render(parsed_content, options)
         
-        # 添加章节
-        book.add_item(chapter)
-        
-        # 创建目录
-        book.toc = [chapter]
-        
-        # 添加导航文件
-        book.add_item(epub.EpubNcx())
-        book.add_item(epub.EpubNav())
-        
-        # 定义spine
-        book.spine = ['nav', chapter]
+        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']
         
-        # 保存为二进制数据
-        import io
-        output = io.BytesIO()
-        epub.write_epub(output, book, {})
-        output.seek(0)
+        # 添加封面信息
+        if 'cover' in options:
+            parsed_content['cover'] = {
+                'src': options['cover'],
+                'type': 'image'
+            }
         
-        return output.getvalue()
+        return parsed_content
     
     def get_supported_formats(self) -> tuple:
         """获取支持的格式"""

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/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.dist-info → hos_m2f-0.5.5.dist-info}/METADATA

@@ -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.dist-info → hos_m2f-0.5.5.dist-info}/RECORD

@@ -7,17 +7,20 @@ hos_m2f/converters/docx_to_md.py,sha256=_HBp3TOD9ZkTFhHR_f3ObLlpDcv0tnSPjPfeGxuv
 hos_m2f/converters/epub_to_md.py,sha256=cFfHmK4IrJKwzEWVE3ue7Jw8tBfWu1q7wG9o7oMf4Pw,4612
 hos_m2f/converters/html_to_md.py,sha256=26GqdynSxKKO2NTxPKgfFs9bTuisLaEIJdBhz4CJ5Eg,4487
 hos_m2f/converters/json_to_md.py,sha256=jeLBQ3jTkgA5a2Kr2gsOPjZB-D4PZxumciFHbyPKNmc,3670
-hos_m2f/converters/md_to_docx.py,sha256=CPlw5GZDVBCyveBGX3ZqlNN33w-y_KYXocYiAzR0kCk,9963
-hos_m2f/converters/md_to_epub.py,sha256=1cQlzkx_8eqZDHzEMKFrmFG4gpVMos2weF11v987W5A,2668
+hos_m2f/converters/md_to_docx.py,sha256=GFAAQppSiCff7pkDAPEmvuoj_f4DMzNWHsbv-9cbqmU,12248
+hos_m2f/converters/md_to_epub.py,sha256=wNoniOSgIz7qiuIagJzqsF6f4pu_HLUigq-w0a_HoFg,2572
 hos_m2f/converters/md_to_html.py,sha256=Pn5K6_QiCdasK1M3hdyr4jlTzzu3OpQLJ-wznGiomPo,2502
 hos_m2f/converters/md_to_json.py,sha256=4VzUQFQ8nStmqm7td6MOFKji25hSiydMZhVJcsRHdYU,11246
+hos_m2f/converters/md_to_latex.py,sha256=7Fra7f984XLLWJTSbjPJP3ljSUldvpc2sqF2QyyPUJg,2348
 hos_m2f/converters/md_to_xml.py,sha256=ARuf4rEX4Of-VdGJI45lAejJV8OmtlHQMK8rltzg6B0,14217
+hos_m2f/converters/pdf_to_md.py,sha256=CgKrvv3CWc6H94nNrDO5nLIegttDzokDpoP2E2oSmEs,3851
 hos_m2f/converters/xml_to_md.py,sha256=zOkaEaSZdvyHag05kIHiWF4VyGMMjfmWmBllBpzwJ4E,4051
 tests/__init__.py,sha256=q1Fh8atmZO-c9dA8JDMvlWaIZxlwABwe_HgNgFNDKJc,16
 tests/test_converters.py,sha256=0sAG1fLR0UjJIWzlKWBR2QU7yl8a8LP8NwwSaU1TI5E,5150
+tests/test_latex.py,sha256=-KCCYKRDu6RoI3gOt0HTtExsW2IJ6KoNfIWeocbdFyY,6619
 tests/test_modes.py,sha256=FFZN1cp4sUJUR5fjbZXo2z-Z4Q5akCRBmSIiR7MCdVA,5887
-hos_m2f-0.5.4.dist-info/METADATA,sha256=6VH8kNleEj0SZUtsUgOjsrNYO5VbkQgUgsvWTqUslV4,1764
-hos_m2f-0.5.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-hos_m2f-0.5.4.dist-info/entry_points.txt,sha256=1opnVMOGIufdlQMvWG_e-oTUS0Yca5ysnFKhmYvBmTM,76
-hos_m2f-0.5.4.dist-info/top_level.txt,sha256=EOB5321A6FNFviV_29qnjHtmLG-F6peX7v5s9Rw96V0,14
-hos_m2f-0.5.4.dist-info/RECORD,,
+hos_m2f-0.5.5.dist-info/METADATA,sha256=qzJMupv3Rq2KQqfw2sJb025gy5nSzJOq6kjuyvqCeXc,1764
+hos_m2f-0.5.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hos_m2f-0.5.5.dist-info/entry_points.txt,sha256=1opnVMOGIufdlQMvWG_e-oTUS0Yca5ysnFKhmYvBmTM,76
+hos_m2f-0.5.5.dist-info/top_level.txt,sha256=EOB5321A6FNFviV_29qnjHtmLG-F6peX7v5s9Rw96V0,14
+hos_m2f-0.5.5.dist-info/RECORD,,

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()