hos-m2f 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

hos_m2f/converters/md_to_docx.py

@@ -0,0 +1,171 @@
+"""Markdown到DOCX格式转换器"""
+
+from typing import Any, Optional, Dict
+from docx import Document
+from docx.shared import Inches, Pt
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.style import WD_STYLE_TYPE
+from hos_m2f.converters.base_converter import BaseConverter
+import mistune
+
+
+class MDToDOCXConverter(BaseConverter):
+    """Markdown到DOCX格式转换器"""
+    
+    def convert(self, input_content: str, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将Markdown转换为DOCX
+        
+        Args:
+            input_content: Markdown内容
+            options: 转换选项
+            
+        Returns:
+            bytes: DOCX文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 创建文档
+        doc = Document()
+        
+        # 设置默认样式
+        self._setup_styles(doc)
+        
+        # 解析Markdown
+        markdown = mistune.create_markdown(
+            plugins=[
+                'url',
+                'abbr',
+                'def_list',
+                'footnotes',
+                'tables',
+                'task_lists',
+                'strikethrough',
+                'highlight',
+                'superscript',
+                'subscript'
+            ]
+        )
+        
+        # 自定义渲染器
+        class DOCXRenderer(mistune.HTMLRenderer):
+            def __init__(self, doc):
+                super().__init__()
+                self.doc = doc
+                self.current_paragraph = None
+                self.list_level = 0
+                self.lists = []
+            
+            def paragraph(self, text):
+                if text.strip():
+                    p = self.doc.add_paragraph()
+                    p.add_run(text)
+                return ''
+            
+            def heading(self, text, level):
+                if level == 1:
+                    self.doc.add_heading(text, level=0)
+                else:
+                    self.doc.add_heading(text, level=level-1)
+                return ''
+            
+            def list(self, text, ordered, level, start=None):
+                self.list_level += 1
+                self.lists.append(ordered)
+                return ''
+            
+            def list_item(self, text, level):
+                if text.strip():
+                    p = self.doc.add_paragraph(
+                        text,
+                        style='List Number' if self.lists[level-1] else 'List Bullet'
+                    )
+                    # 缩进
+                    for i in range(level-1):
+                        p.paragraph_format.left_indent += Inches(0.5)
+                return ''
+            
+            def list_end(self, level):
+                self.list_level -= 1
+                if self.lists:
+                    self.lists.pop()
+                return ''
+            
+            def table(self, text):
+                # 简化处理，实际项目中需要更复杂的表格解析
+                self.doc.add_paragraph('Table: ' + text[:100] + '...')
+                return ''
+            
+            def image(self, src, alt='', title=None):
+                try:
+                    # 简化处理，实际项目中需要处理本地和远程图片
+                    self.doc.add_paragraph(f'Image: {alt} ({src})')
+                except Exception:
+                    pass
+                return ''
+            
+            def link(self, link, text=None, title=None):
+                if text:
+                    p = self.doc.add_paragraph()
+                    run = p.add_run(text)
+                    # 实际项目中需要添加超链接
+                return ''
+            
+            def emphasis(self, text):
+                if self.current_paragraph:
+                    run = self.current_paragraph.add_run(text)
+                    run.italic = True
+                return ''
+            
+            def strong(self, text):
+                if self.current_paragraph:
+                    run = self.current_paragraph.add_run(text)
+                    run.bold = True
+                return ''
+            
+            def codespan(self, text):
+                p = self.doc.add_paragraph()
+                run = p.add_run(text)
+                run.font.name = 'Courier New'
+                return ''
+            
+            def block_code(self, code, lang=None):
+                p = self.doc.add_paragraph()
+                run = p.add_run(code)
+                run.font.name = 'Courier New'
+                p.paragraph_format.left_indent = Inches(0.5)
+                return ''
+        
+        # 渲染Markdown
+        renderer = DOCXRenderer(doc)
+        markdown(input_content, renderer)
+        
+        # 保存为二进制数据
+        import io
+        output = io.BytesIO()
+        doc.save(output)
+        output.seek(0)
+        
+        return output.getvalue()
+    
+    def _setup_styles(self, doc):
+        """设置文档样式"""
+        styles = doc.styles
+        
+        # 设置正文样式
+        normal_style = styles['Normal']
+        font = normal_style.font
+        font.name = 'Microsoft YaHei'
+        font.size = Pt(12)
+        
+        # 设置标题样式
+        for i in range(1, 6):
+            heading_style = styles[f'Heading {i}']
+            font = heading_style.font
+            font.name = 'Microsoft YaHei'
+            font.size = Pt(14 + (6 - i) * 2)
+            font.bold = True
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('markdown', 'docx')

hos_m2f/converters/md_to_epub.py

@@ -0,0 +1,108 @@
+"""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(
+            plugins=[
+                'url',
+                'abbr',
+                'def_list',
+                'footnotes',
+                'tables',
+                'task_lists',
+                'strikethrough',
+                'highlight',
+                'superscript',
+                'subscript'
+            ]
+        )
+        
+        # 转换为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')

hos_m2f/converters/md_to_html.py

@@ -0,0 +1,100 @@
+"""Markdown到HTML格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+import mistune
+
+
+class MDToHTMLConverter(BaseConverter):
+    """Markdown到HTML格式转换器"""
+    
+    def convert(self, input_content: str, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将Markdown转换为HTML
+        
+        Args:
+            input_content: Markdown内容
+            options: 转换选项
+            
+        Returns:
+            bytes: HTML文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 解析Markdown
+        markdown = mistune.create_markdown(
+            plugins=[
+                'url',
+                'abbr',
+                'def_list',
+                'footnotes',
+                'tables',
+                'task_lists',
+                'strikethrough',
+                'highlight',
+                'superscript',
+                'subscript'
+            ]
+        )
+        
+        # 转换为HTML
+        html_content = markdown(input_content)
+        
+        # 生成完整的HTML文档
+        full_html = f'''
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>{options.get('title', 'Untitled')}</title>
+            <meta charset="utf-8" />
+            <style>
+                body {{
+                    font-family: Arial, sans-serif;
+                    line-height: 1.6;
+                    margin: 20px;
+                    max-width: 800px;
+                }}
+                h1, h2, h3, h4, h5, h6 {{
+                    color: #333;
+                }}
+                code {{
+                    background-color: #f4f4f4;
+                    padding: 2px 4px;
+                    border-radius: 3px;
+                }}
+                pre {{
+                    background-color: #f4f4f4;
+                    padding: 10px;
+                    border-radius: 3px;
+                    overflow-x: auto;
+                }}
+                table {{
+                    border-collapse: collapse;
+                    width: 100%;
+                    margin: 20px 0;
+                }}
+                th, td {{
+                    border: 1px solid #ddd;
+                    padding: 8px;
+                    text-align: left;
+                }}
+                th {{
+                    background-color: #f2f2f2;
+                }}
+                img {{
+                    max-width: 100%;
+                    height: auto;
+                }}
+            </style>
+        </head>
+        <body>
+            {html_content}
+        </body>
+        </html>
+        '''
+        
+        return full_html.encode('utf-8')
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('markdown', 'html')

hos_m2f/converters/md_to_json.py

@@ -0,0 +1,284 @@
+"""Markdown到JSON格式转换器"""
+
+from typing import Any, Optional, Dict, List
+from hos_m2f.converters.base_converter import BaseConverter
+import mistune
+import json
+
+
+class MDToJSONConverter(BaseConverter):
+    """Markdown到JSON格式转换器"""
+    
+    def convert(self, input_content: str, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将Markdown转换为JSON
+        
+        Args:
+            input_content: Markdown内容
+            options: 转换选项
+            
+        Returns:
+            bytes: JSON文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 解析Markdown结构
+        structure = self._parse_markdown(input_content)
+        
+        # 转换为JSON
+        json_content = json.dumps(structure, ensure_ascii=False, indent=2)
+        
+        return json_content.encode('utf-8')
+    
+    def _parse_markdown(self, content: str) -> Dict[str, Any]:
+        """解析Markdown内容为结构化数据
+        
+        Args:
+            content: Markdown内容
+            
+        Returns:
+            Dict[str, Any]: 结构化数据
+        """
+        lines = content.split('\n')
+        structure = {
+            'type': 'document',
+            'children': [],
+            'metadata': {}
+        }
+        
+        current_heading = None
+        current_level = 0
+        current_paragraph = []
+        current_list = None
+        current_list_items = []
+        list_level = 0
+        
+        # 解析YAML头
+        if lines and lines[0] == '---':
+            metadata = []
+            for i, line in enumerate(lines[1:]):
+                if line == '---':
+                    break
+                metadata.append(line)
+            
+            # 解析YAML元数据
+            if metadata:
+                import yaml
+                try:
+                    metadata_content = '\n'.join(metadata)
+                    structure['metadata'] = yaml.safe_load(metadata_content)
+                except Exception:
+                    pass
+            
+            # 跳过YAML头
+            lines = lines[i+2:]
+        
+        # 解析内容
+        for line in lines:
+            line = line.rstrip()
+            
+            # 处理标题
+            if line.startswith('#'):
+                # 保存当前段落
+                if current_paragraph:
+                    structure['children'].append({
+                        'type': 'paragraph',
+                        'content': '\n'.join(current_paragraph)
+                    })
+                    current_paragraph = []
+                
+                # 保存当前列表
+                if current_list is not None:
+                    structure['children'].append({
+                        'type': 'list',
+                        'ordered': current_list,
+                        'items': current_list_items
+                    })
+                    current_list = None
+                    current_list_items = []
+                
+                # 解析标题
+                level = len(line.split(' ')[0])
+                title = line[level:].strip()
+                structure['children'].append({
+                    'type': 'heading',
+                    'level': level,
+                    'content': title
+                })
+                current_heading = title
+                current_level = level
+            
+            # 处理有序列表
+            elif line.startswith('1. ') or line.startswith('\t1. ') or line.startswith('  1. '):
+                # 保存当前段落
+                if current_paragraph:
+                    structure['children'].append({
+                        'type': 'paragraph',
+                        'content': '\n'.join(current_paragraph)
+                    })
+                    current_paragraph = []
+                
+                # 开始新列表
+                if current_list is None:
+                    current_list = True
+                elif current_list != True:
+                    structure['children'].append({
+                        'type': 'list',
+                        'ordered': current_list,
+                        'items': current_list_items
+                    })
+                    current_list = True
+                    current_list_items = []
+                
+                # 解析列表项
+                content = line.lstrip('1234567890. \t')
+                current_list_items.append({
+                    'type': 'list_item',
+                    'content': content
+                })
+            
+            # 处理无序列表
+            elif line.startswith('- ') or line.startswith('* ') or line.startswith('+ ') or \
+                 line.startswith('\t- ') or line.startswith('\t* ') or line.startswith('\t+ ') or \
+                 line.startswith('  - ') or line.startswith('  * ') or line.startswith('  + '):
+                # 保存当前段落
+                if current_paragraph:
+                    structure['children'].append({
+                        'type': 'paragraph',
+                        'content': '\n'.join(current_paragraph)
+                    })
+                    current_paragraph = []
+                
+                # 开始新列表
+                if current_list is None:
+                    current_list = False
+                elif current_list != False:
+                    structure['children'].append({
+                        'type': 'list',
+                        'ordered': current_list,
+                        'items': current_list_items
+                    })
+                    current_list = False
+                    current_list_items = []
+                
+                # 解析列表项
+                content = line.lstrip('-*+ \t')
+                current_list_items.append({
+                    'type': 'list_item',
+                    'content': content
+                })
+            
+            # 处理代码块
+            elif line.startswith('```'):
+                # 保存当前段落
+                if current_paragraph:
+                    structure['children'].append({
+                        'type': 'paragraph',
+                        'content': '\n'.join(current_paragraph)
+                    })
+                    current_paragraph = []
+                
+                # 保存当前列表
+                if current_list is not None:
+                    structure['children'].append({
+                        'type': 'list',
+                        'ordered': current_list,
+                        'items': current_list_items
+                    })
+                    current_list = None
+                    current_list_items = []
+                
+                # 解析代码块
+                code_lines = []
+                language = line[3:].strip()
+                
+                # 读取代码内容
+                for i, code_line in enumerate(lines[lines.index(line)+1:]):
+                    if code_line.startswith('```'):
+                        break
+                    code_lines.append(code_line)
+                
+                structure['children'].append({
+                    'type': 'code_block',
+                    'language': language,
+                    'content': '\n'.join(code_lines)
+                })
+                
+                # 跳过已处理的代码行
+                lines = lines[:lines.index(line)] + lines[lines.index(line)+i+2:]
+            
+            # 处理表格
+            elif line.startswith('|') and '|' in line[1:]:
+                # 保存当前段落
+                if current_paragraph:
+                    structure['children'].append({
+                        'type': 'paragraph',
+                        'content': '\n'.join(current_paragraph)
+                    })
+                    current_paragraph = []
+                
+                # 保存当前列表
+                if current_list is not None:
+                    structure['children'].append({
+                        'type': 'list',
+                        'ordered': current_list,
+                        'items': current_list_items
+                    })
+                    current_list = None
+                    current_list_items = []
+                
+                # 解析表格
+                table_lines = [line]
+                
+                # 读取表格内容
+                for i, table_line in enumerate(lines[lines.index(line)+1:]):
+                    if table_line.startswith('|'):
+                        table_lines.append(table_line)
+                    else:
+                        break
+                
+                # 解析表格结构
+                if len(table_lines) >= 2:
+                    headers = [h.strip() for h in table_lines[0].split('|') if h.strip()]
+                    rows = []
+                    
+                    # 跳过分隔线
+                    for table_line in table_lines[2:]:
+                        cells = [c.strip() for c in table_line.split('|') if c.strip()]
+                        if cells:
+                            rows.append(dict(zip(headers, cells)))
+                    
+                    structure['children'].append({
+                        'type': 'table',
+                        'headers': headers,
+                        'rows': rows
+                    })
+                
+                # 跳过已处理的表格行
+                lines = lines[:lines.index(line)] + lines[lines.index(line)+i+1:]
+            
+            # 处理段落
+            else:
+                if line or current_paragraph:
+                    current_paragraph.append(line)
+        
+        # 保存最后一个段落
+        if current_paragraph:
+            structure['children'].append({
+                'type': 'paragraph',
+                'content': '\n'.join(current_paragraph)
+            })
+        
+        # 保存最后一个列表
+        if current_list is not None:
+            structure['children'].append({
+                'type': 'list',
+                'ordered': current_list,
+                'items': current_list_items
+            })
+        
+        return structure
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('markdown', 'json')