hos-m2f 0.5.0__tar.gz → 0.5.2__tar.gz

hos_m2f-0.5.2/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: hos-m2f
+Version: 0.5.2
+Summary: HOS-M2F: Markdown to Industry Standard Format Compiler Engine
+Author: HOS Team
+Author-email: team@hos-m2f.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: mistune>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: ebooklib>=0.17.0
+Requires-Dist: weasyprint>=54.0
+Requires-Dist: python-docx>=0.8.11
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+HOS-M2F is a powerful compiler engine that converts Markdown files to various industry standard formats.
+
+Key Features:
+- Multiple output formats: PDF, DOCX, EPUB, and JSON
+- Specialized modes for different document types:
+  - Book mode for book-length documents
+  - Paper mode for academic papers
+  - Patent mode for patent applications
+  - SOP (Standard Operating Procedure) mode for technical procedures
+- Command-line interface for easy automation
+- Semantic parsing for intelligent document structure
+- Extensible architecture for custom renderers and modes
+
+Use Cases:
+- Convert technical documentation to professional formats
+- Generate academic papers from Markdown sources
+- Create standardized operating procedures
+- Prepare patent applications with proper formatting
+- Build eBooks from Markdown content
+
+HOS-M2F simplifies the process of creating professionally formatted documents from plain Markdown, saving time and ensuring consistency across document types.

{hos_m2f-0.5.0 → hos_m2f-0.5.2}/hos_m2f/cli/cli.py

@@ -27,23 +27,31 @@ class CLI:
         build_parser = self.subparsers.add_parser('build', help='Build document from Markdown')
         build_parser.add_argument('input', help='Input Markdown file')
         build_parser.add_argument('output', help='Output file path')
-        build_parser.add_argument('--mode', choices=['book', 'patent', 'sop', 'paper'], default='paper', help='Document mode')
-        build_parser.add_argument('--format', choices=['epub', 'pdf', 'docx', 'json'], default='epub', help='Output format')
+        build_parser.add_argument('--mode', default='paper', help='Document mode')
+        build_parser.add_argument('--format', choices=['epub', 'pdf', 'docx', 'json', 'html', 'xml'], default='epub', help='Output format')
         build_parser.add_argument('--options', type=str, default='{}', help='Additional options as JSON string')
         
         # check命令
         check_parser = self.subparsers.add_parser('check', help='Check document structure and compliance')
         check_parser.add_argument('input', help='Input Markdown file')
-        check_parser.add_argument('--mode', choices=['book', 'patent', 'sop', 'paper'], default='paper', help='Document mode')
+        check_parser.add_argument('--mode', default='paper', help='Document mode')
         check_parser.add_argument('--options', type=str, default='{}', help='Additional options as JSON string')
         
         # parse命令
         parse_parser = self.subparsers.add_parser('parse', help='Parse Markdown content and output structured data')
         parse_parser.add_argument('input', help='Input Markdown file')
-        parse_parser.add_argument('--mode', choices=['book', 'patent', 'sop', 'paper'], default='paper', help='Document mode')
+        parse_parser.add_argument('--mode', default='paper', help='Document mode')
         parse_parser.add_argument('--output', help='Output JSON file (default: stdout)')
         parse_parser.add_argument('--options', type=str, default='{}', help='Additional options as JSON string')
         
+        # convert命令
+        convert_parser = self.subparsers.add_parser('convert', help='Convert between different formats')
+        convert_parser.add_argument('input', help='Input file')
+        convert_parser.add_argument('output', help='Output file path')
+        convert_parser.add_argument('--from', dest='from_format', required=True, choices=['md', 'docx', 'json', 'epub', 'html', 'xml'], help='Input format')
+        convert_parser.add_argument('--to', dest='to_format', required=True, choices=['md', 'docx', 'json', 'epub', 'html', 'xml'], help='Output format')
+        convert_parser.add_argument('--options', type=str, default='{}', help='Additional options as JSON string')
+        
         # preview命令
         preview_parser = self.subparsers.add_parser('preview', help='Start preview server')
         preview_parser.add_argument('--port', type=int, default=8000, help='Port to run the server on')
@@ -54,7 +62,7 @@ class CLI:
         
         # validate命令
         validate_parser = self.subparsers.add_parser('validate', help='Validate options for a specific mode')
-        validate_parser.add_argument('--mode', choices=['book', 'patent', 'sop', 'paper'], required=True, help='Document mode')
+        validate_parser.add_argument('--mode', required=True, help='Document mode')
         validate_parser.add_argument('--options', type=str, required=True, help='Options to validate as JSON string')
     
     def run(self, args=None):
@@ -82,6 +90,8 @@ class CLI:
                 return self._run_check(parsed_args)
             elif parsed_args.command == 'parse':
                 return self._run_parse(parsed_args)
+            elif parsed_args.command == 'convert':
+                return self._run_convert(parsed_args)
             elif parsed_args.command == 'preview':
                 return self._run_preview(parsed_args)
             elif parsed_args.command == 'info':
@@ -266,12 +276,29 @@ class CLI:
         
         print('\nValidation passed!')
         return 0
+    
+    def _run_convert(self, args):
+        """运行convert命令"""
+        # 解析选项
+        options = json.loads(args.options)
+        
+        # 执行转换
+        result = self.engine.convert(args.input, args.output, args.from_format, args.to_format, options)
+        
+        # 输出结果
+        print(f'Successfully converted {args.input} to {args.output}')
+        print(f'From format: {args.from_format}')
+        print(f'To format: {args.to_format}')
+        if result['metadata']:
+            print('Metadata:', json.dumps(result['metadata'], ensure_ascii=False, indent=2))
+        
+        return 0
 
 
-def main():
+def main(args=None):
     """CLI命令入口点"""
     cli = CLI()
-    sys.exit(cli.run())
+    sys.exit(cli.run(args))
 
 # 命令行入口
 if __name__ == '__main__':

hos_m2f-0.5.2/hos_m2f/converters/__init__.py

@@ -0,0 +1,27 @@
+"""基础格式互转模块"""
+
+from hos_m2f.converters.base_converter import BaseConverter
+from hos_m2f.converters.md_to_docx import MDToDOCXConverter
+from hos_m2f.converters.md_to_json import MDToJSONConverter
+from hos_m2f.converters.md_to_epub import MDToEPUBConverter
+from hos_m2f.converters.md_to_html import MDToHTMLConverter
+from hos_m2f.converters.md_to_xml import MDToXMLConverter
+from hos_m2f.converters.docx_to_md import DOCXToMDConverter
+from hos_m2f.converters.json_to_md import JSONToMDConverter
+from hos_m2f.converters.epub_to_md import EPUBToMDConverter
+from hos_m2f.converters.html_to_md import HTMLToMDConverter
+from hos_m2f.converters.xml_to_md import XMLToMDConverter
+
+__all__ = [
+    "BaseConverter",
+    "MDToDOCXConverter",
+    "MDToJSONConverter",
+    "MDToEPUBConverter",
+    "MDToHTMLConverter",
+    "MDToXMLConverter",
+    "DOCXToMDConverter",
+    "JSONToMDConverter",
+    "EPUBToMDConverter",
+    "HTMLToMDConverter",
+    "XMLToMDConverter"
+]

hos_m2f-0.5.2/hos_m2f/converters/base_converter.py

@@ -0,0 +1,30 @@
+"""基础转换器类"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Dict
+
+
+class BaseConverter(ABC):
+    """基础转换器抽象类"""
+    
+    @abstractmethod
+    def convert(self, input_content: Any, options: Optional[Dict[str, Any]] = None) -> Any:
+        """转换方法
+        
+        Args:
+            input_content: 输入内容
+            options: 转换选项
+            
+        Returns:
+            Any: 转换后的内容
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式
+        
+        Returns:
+            tuple: (输入格式, 输出格式)
+        """
+        pass

hos_m2f-0.5.2/hos_m2f/converters/docx_to_md.py

@@ -0,0 +1,89 @@
+"""DOCX到Markdown格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+from docx import Document
+
+
+class DOCXToMDConverter(BaseConverter):
+    """DOCX到Markdown格式转换器"""
+    
+    def convert(self, input_content: bytes, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将DOCX转换为Markdown
+        
+        Args:
+            input_content: DOCX文件的二进制数据
+            options: 转换选项
+            
+        Returns:
+            bytes: Markdown文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 加载DOCX文档
+        import io
+        doc = Document(io.BytesIO(input_content))
+        
+        # 转换为Markdown
+        md_content = []
+        
+        # 处理段落
+        for paragraph in doc.paragraphs:
+            # 处理标题
+            if paragraph.style.name.startswith('Heading'):
+                level = int(paragraph.style.name.split(' ')[1])
+                md_content.append('#' * level + ' ' + paragraph.text)
+            # 处理列表
+            elif paragraph.style.name in ['List Bullet', 'List Number']:
+                # 检测缩进级别
+                indent_level = int(paragraph.paragraph_format.left_indent.inches // 0.5)
+                prefix = '  ' * indent_level
+                
+                if paragraph.style.name == 'List Number':
+                    # 简化处理，实际项目中需要更复杂的列表编号处理
+                    md_content.append(prefix + '1. ' + paragraph.text)
+                else:
+                    md_content.append(prefix + '- ' + paragraph.text)
+            # 处理普通段落
+            else:
+                if paragraph.text:
+                    md_content.append(paragraph.text)
+            
+            # 添加空行
+            md_content.append('')
+        
+        # 处理表格
+        for table in doc.tables:
+            # 表头
+            headers = []
+            for cell in table.rows[0].cells:
+                headers.append(cell.text)
+            
+            # 表格分隔线
+            separators = ['---'] * len(headers)
+            
+            # 表格数据
+            rows = []
+            for row in table.rows[1:]:
+                row_cells = []
+                for cell in row.cells:
+                    row_cells.append(cell.text)
+                rows.append(row_cells)
+            
+            # 生成Markdown表格
+            if headers:
+                md_content.append('| ' + ' | '.join(headers) + ' |')
+                md_content.append('| ' + ' | '.join(separators) + ' |')
+                for row in rows:
+                    md_content.append('| ' + ' | '.join(row) + ' |')
+                md_content.append('')
+        
+        # 生成Markdown内容
+        md_text = '\n'.join(md_content)
+        
+        return md_text.encode('utf-8')
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('docx', 'markdown')

hos_m2f-0.5.2/hos_m2f/converters/epub_to_md.py

@@ -0,0 +1,118 @@
+"""EPUB到Markdown格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+
+
+class EPUBToMDConverter(BaseConverter):
+    """EPUB到Markdown格式转换器"""
+    
+    def convert(self, input_content: bytes, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将EPUB转换为Markdown
+        
+        Args:
+            input_content: EPUB文件的二进制数据
+            options: 转换选项
+            
+        Returns:
+            bytes: Markdown文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 加载EPUB书籍
+        import io
+        book = epub.read_epub(io.BytesIO(input_content))
+        
+        # 转换为Markdown
+        md_content = []
+        
+        # 提取元数据
+        md_content.append('---')
+        if book.get_metadata('DC', 'title'):
+            md_content.append(f'title: {book.get_metadata("DC", "title")[0][0]}')
+        if book.get_metadata('DC', 'creator'):
+            md_content.append(f'author: {book.get_metadata("DC", "creator")[0][0]}')
+        if book.get_metadata('DC', 'language'):
+            md_content.append(f'language: {book.get_metadata("DC", "language")[0][0]}')
+        md_content.append('---')
+        md_content.append('')
+        
+        # 处理章节
+        for item in book.get_items():
+            if item.get_type() == ebooklib.ITEM_DOCUMENT:
+                # 解析HTML内容
+                soup = BeautifulSoup(item.get_content(), 'html.parser')
+                
+                # 提取标题
+                h1 = soup.find('h1')
+                if h1:
+                    md_content.append(f'# {h1.get_text()}')
+                    md_content.append('')
+                
+                # 提取段落
+                for p in soup.find_all('p'):
+                    text = p.get_text().strip()
+                    if text:
+                        md_content.append(text)
+                        md_content.append('')
+                
+                # 提取列表
+                for ul in soup.find_all('ul'):
+                    for li in ul.find_all('li'):
+                        text = li.get_text().strip()
+                        if text:
+                            md_content.append(f'- {text}')
+                    md_content.append('')
+                
+                for ol in soup.find_all('ol'):
+                    for i, li in enumerate(ol.find_all('li'), 1):
+                        text = li.get_text().strip()
+                        if text:
+                            md_content.append(f'{i}. {text}')
+                    md_content.append('')
+                
+                # 提取表格
+                for table in soup.find_all('table'):
+                    # 提取表头
+                    headers = []
+                    thead = table.find('thead')
+                    if thead:
+                        for th in thead.find_all('th'):
+                            headers.append(th.get_text().strip())
+                    else:
+                        # 尝试从第一行提取表头
+                        first_row = table.find('tr')
+                        if first_row:
+                            for th in first_row.find_all(['th', 'td']):
+                                headers.append(th.get_text().strip())
+                    
+                    if headers:
+                        # 生成表格
+                        md_content.append('| ' + ' | '.join(headers) + ' |')
+                        md_content.append('| ' + ' | '.join(['---'] * len(headers)) + ' |')
+                        
+                        # 提取表格数据
+                        tbody = table.find('tbody')
+                        rows = tbody.find_all('tr') if tbody else table.find_all('tr')[1:] if table.find_all('tr') else []
+                        
+                        for row in rows:
+                            cells = []
+                            for td in row.find_all('td'):
+                                cells.append(td.get_text().strip())
+                            if cells:
+                                md_content.append('| ' + ' | '.join(cells) + ' |')
+                        
+                        md_content.append('')
+        
+        # 生成Markdown内容
+        md_text = '\n'.join(md_content)
+        
+        return md_text.encode('utf-8')
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('epub', 'markdown')

hos_m2f-0.5.2/hos_m2f/converters/html_to_md.py

@@ -0,0 +1,132 @@
+"""HTML到Markdown格式转换器"""
+
+from typing import Any, Optional, Dict
+from hos_m2f.converters.base_converter import BaseConverter
+from bs4 import BeautifulSoup
+
+
+class HTMLToMDConverter(BaseConverter):
+    """HTML到Markdown格式转换器"""
+    
+    def convert(self, input_content: bytes, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将HTML转换为Markdown
+        
+        Args:
+            input_content: HTML文件的二进制数据
+            options: 转换选项
+            
+        Returns:
+            bytes: Markdown文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 解析HTML
+        soup = BeautifulSoup(input_content, 'html.parser')
+        
+        # 转换为Markdown
+        md_content = self._html_to_md(soup)
+        
+        return md_content.encode('utf-8')
+    
+    def _html_to_md(self, soup: BeautifulSoup) -> str:
+        """将HTML转换为Markdown
+        
+        Args:
+            soup: BeautifulSoup对象
+            
+        Returns:
+            str: Markdown字符串
+        """
+        md_parts = []
+        
+        # 处理标题
+        for level in range(1, 7):
+            for heading in soup.find_all(f'h{level}'):
+                md_parts.append('#' * level + ' ' + heading.get_text())
+                md_parts.append('')
+        
+        # 处理段落
+        for paragraph in soup.find_all('p'):
+            text = paragraph.get_text().strip()
+            if text:
+                md_parts.append(text)
+                md_parts.append('')
+        
+        # 处理列表
+        for ul in soup.find_all('ul'):
+            for li in ul.find_all('li'):
+                text = li.get_text().strip()
+                if text:
+                    md_parts.append('- ' + text)
+            md_parts.append('')
+        
+        for ol in soup.find_all('ol'):
+            for i, li in enumerate(ol.find_all('li'), 1):
+                text = li.get_text().strip()
+                if text:
+                    md_parts.append(f'{i}. ' + text)
+            md_parts.append('')
+        
+        # 处理表格
+        for table in soup.find_all('table'):
+            # 提取表头
+            headers = []
+            thead = table.find('thead')
+            if thead:
+                for th in thead.find_all('th'):
+                    headers.append(th.get_text().strip())
+            else:
+                # 尝试从第一行提取表头
+                first_row = table.find('tr')
+                if first_row:
+                    for th in first_row.find_all(['th', 'td']):
+                        headers.append(th.get_text().strip())
+            
+            if headers:
+                # 生成表格
+                md_parts.append('| ' + ' | '.join(headers) + ' |')
+                md_parts.append('| ' + ' | '.join(['---'] * len(headers)) + ' |')
+                
+                # 提取表格数据
+                tbody = table.find('tbody')
+                rows = tbody.find_all('tr') if tbody else table.find_all('tr')[1:] if table.find_all('tr') else []
+                
+                for row in rows:
+                    cells = []
+                    for td in row.find_all('td'):
+                        cells.append(td.get_text().strip())
+                    if cells:
+                        md_parts.append('| ' + ' | '.join(cells) + ' |')
+                
+                md_parts.append('')
+        
+        # 处理代码块
+        for pre in soup.find_all('pre'):
+            code = pre.find('code')
+            if code:
+                language = code.get('class', [''])[0].replace('language-', '')
+                md_parts.append(f'```python' if language == 'python' else '```')
+                md_parts.append(code.get_text())
+                md_parts.append('```')
+                md_parts.append('')
+        
+        # 处理链接
+        for a in soup.find_all('a', href=True):
+            text = a.get_text().strip()
+            if text:
+                md_parts.append(f'[{text}]({a["href"]})')
+                md_parts.append('')
+        
+        # 处理图片
+        for img in soup.find_all('img', src=True):
+            alt = img.get('alt', '')
+            src = img['src']
+            md_parts.append(f'![{alt}]({src})')
+            md_parts.append('')
+        
+        return '\n'.join(md_parts)
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('html', 'markdown')

hos_m2f-0.5.2/hos_m2f/converters/json_to_md.py

@@ -0,0 +1,97 @@
+"""JSON到Markdown格式转换器"""
+
+from typing import Any, Optional, Dict, List
+from hos_m2f.converters.base_converter import BaseConverter
+import json
+
+
+class JSONToMDConverter(BaseConverter):
+    """JSON到Markdown格式转换器"""
+    
+    def convert(self, input_content: bytes, options: Optional[Dict[str, Any]] = None) -> bytes:
+        """将JSON转换为Markdown
+        
+        Args:
+            input_content: JSON文件的二进制数据
+            options: 转换选项
+            
+        Returns:
+            bytes: Markdown文件的二进制数据
+        """
+        if options is None:
+            options = {}
+        
+        # 解析JSON
+        json_content = json.loads(input_content.decode('utf-8'))
+        
+        # 转换为Markdown
+        md_content = self._json_to_md(json_content)
+        
+        return md_content.encode('utf-8')
+    
+    def _json_to_md(self, data: Any, indent: int = 0) -> str:
+        """将JSON数据转换为Markdown
+        
+        Args:
+            data: JSON数据
+            indent: 缩进级别
+            
+        Returns:
+            str: Markdown字符串
+        """
+        md_parts = []
+        prefix = '  ' * indent
+        
+        if isinstance(data, dict):
+            for key, value in data.items():
+                # 处理标题
+                if key in ['title', 'heading', 'Header']:
+                    md_parts.append('#' * (indent + 1) + ' ' + str(value))
+                # 处理列表
+                elif key in ['items', 'list', 'List']:
+                    md_parts.append(f'{prefix}{key}:')
+                    if isinstance(value, list):
+                        for item in value:
+                            md_parts.append(f'{prefix}- {self._json_to_md(item, indent + 1)}')
+                # 处理表格
+                elif key in ['table', 'Table']:
+                    if isinstance(value, dict) and 'headers' in value and 'rows' in value:
+                        # 生成表格
+                        headers = value['headers']
+                        rows = value['rows']
+                        
+                        # 表头
+                        md_parts.append('| ' + ' | '.join(headers) + ' |')
+                        # 分隔线
+                        md_parts.append('| ' + ' | '.join(['---'] * len(headers)) + ' |')
+                        # 数据行
+                        for row in rows:
+                            if isinstance(row, dict):
+                                cells = [str(row.get(header, '')) for header in headers]
+                            else:
+                                cells = [str(cell) for cell in row]
+                            md_parts.append('| ' + ' | '.join(cells) + ' |')
+                # 处理普通键值对
+                else:
+                    if isinstance(value, (dict, list)):
+                        md_parts.append(f'{prefix}{key}:')
+                        md_parts.append(self._json_to_md(value, indent + 1))
+                    else:
+                        md_parts.append(f'{prefix}{key}: {value}')
+        
+        elif isinstance(data, list):
+            for item in data:
+                if isinstance(item, (dict, list)):
+                    md_parts.append(f'{prefix}-')
+                    md_parts.append(self._json_to_md(item, indent + 1))
+                else:
+                    md_parts.append(f'{prefix}- {item}')
+        
+        elif isinstance(data, str):
+            md_parts.append(f'{prefix}{data}')
+        
+        return '\n'.join(md_parts)
+    
+    def get_supported_formats(self) -> tuple:
+        """获取支持的格式"""
+        return ('json', 'markdown')