markdocx 0.1.0__py3-none-any.whl

markdocx/__init__.py

@@ -0,0 +1,11 @@
+"""
+markdocx
+========
+Convert AI-generated Markdown textbooks to polished DOCX
+with native math equations and syntax-highlighted code.
+"""
+
+from markdocx.core import convert_file, convert_directory
+
+__version__ = "0.1.0"
+__all__ = ["convert_file", "convert_directory"]

markdocx/cli.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+markdocx — CLI Entry Point
+===========================
+Convert Markdown textbooks to polished DOCX with native
+math equations and syntax-highlighted code.
+
+Usage:
+    markdocx input.md                     # Convert single file
+    markdocx input.md -o output.docx      # Specify output path
+    markdocx ./docs/                       # Convert all .md in directory
+    markdocx ./docs/ -r -o ./output/       # Recursive + output dir
+"""
+
+import argparse
+import os
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="markdocx",
+        description="Convert Markdown textbooks to DOCX "
+                    "(math equations, code syntax highlighting, tables, images...)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  markdocx chapter1.md
+  markdocx chapter1.md -o bai1.docx
+  markdocx ./chapters/ -o ./output/ -r
+  markdocx ./chapters/ -r -v
+        """,
+    )
+
+    parser.add_argument(
+        "input",
+        help="Markdown file or directory containing .md files to convert",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        help="Output .docx file path (or directory if input is a directory)",
+        default=None,
+    )
+    parser.add_argument(
+        "-r", "--recursive",
+        action="store_true",
+        help="Recursively find .md files in subdirectories",
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Show detailed processing logs",
+    )
+
+    args = parser.parse_args()
+
+    # Lazy import to speed up --help
+    from markdocx.core import convert_file, convert_directory
+
+    input_path = os.path.abspath(args.input)
+
+    try:
+        if os.path.isfile(input_path):
+            # ── Convert single file ──
+            if not input_path.lower().endswith(".md"):
+                print(f"Error: Expected a .md file, got: {input_path}", file=sys.stderr)
+                sys.exit(1)
+
+            output = convert_file(input_path, args.output, verbose=args.verbose)
+            print(f"\nDone: {output}")
+
+        elif os.path.isdir(input_path):
+            # ── Convert directory ──
+            results = convert_directory(
+                input_path,
+                output_dir=args.output,
+                recursive=args.recursive,
+                verbose=args.verbose,
+            )
+
+            if not results:
+                print("No .md files found.", file=sys.stderr)
+                sys.exit(1)
+
+            print("\n" + "=" * 60)
+            print("CONVERSION RESULTS")
+            print("=" * 60)
+            for md_path, docx_path, success, error in results:
+                status = "OK" if success else "FAIL"
+                name = os.path.basename(md_path)
+                if success:
+                    print(f"  [{status}] {name} -> {os.path.basename(docx_path)}")
+                else:
+                    print(f"  [{status}] {name} — Error: {error}")
+
+            success_count = sum(1 for *_, ok, _ in results if ok)
+            fail_count = len(results) - success_count
+            print(f"\nTotal: {success_count} succeeded, {fail_count} failed")
+
+        else:
+            print(f"Error: Invalid path: {input_path}", file=sys.stderr)
+            sys.exit(1)
+
+    except KeyboardInterrupt:
+        print("\nCancelled by user.", file=sys.stderr)
+        sys.exit(130)
+    except Exception as e:
+        print(f"\nError: {e}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

markdocx/code_renderer.py

@@ -0,0 +1,164 @@
+"""
+Code syntax highlighting renderer.
+Sử dụng Pygments để tạo syntax highlighting cho code blocks trong DOCX.
+"""
+
+import logging
+
+from pygments import lex
+from pygments.lexers import get_lexer_by_name, TextLexer, guess_lexer
+from pygments.token import Token
+
+from docx.shared import Pt, RGBColor
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+
+from markdocx.styles import (
+    FONT_CODE,
+    FONT_SIZE_CODE_BLOCK,
+    COLOR_CODE_BLOCK_BG,
+    COLOR_CODE_BLOCK_BORDER,
+    get_syntax_color,
+    set_paragraph_shading,
+    set_paragraph_borders,
+)
+
+logger = logging.getLogger(__name__)
+
+# Language aliases for common names
+LANGUAGE_ALIASES = {
+    "py": "python",
+    "js": "javascript",
+    "ts": "typescript",
+    "rb": "ruby",
+    "cs": "csharp",
+    "c++": "cpp",
+    "c#": "csharp",
+    "sh": "bash",
+    "shell": "bash",
+    "yml": "yaml",
+    "md": "markdown",
+    "tex": "latex",
+    "rs": "rust",
+    "kt": "kotlin",
+    "m": "objectivec",
+    "dockerfile": "docker",
+    "plaintext": "text",
+    "plain": "text",
+    "txt": "text",
+    "": "text",
+}
+
+
+def get_lexer(language):
+    """Get a Pygments lexer for the given language."""
+    lang = language.strip().lower() if language else ""
+    lang = LANGUAGE_ALIASES.get(lang, lang)
+
+    try:
+        return get_lexer_by_name(lang, stripall=False)
+    except Exception:
+        try:
+            return get_lexer_by_name("text", stripall=False)
+        except Exception:
+            return TextLexer()
+
+
+def tokenize_code(code, language):
+    """
+    Tokenize source code using Pygments.
+
+    Args:
+        code: Source code string
+        language: Programming language name
+
+    Returns:
+        List of (token_type, token_value) tuples
+    """
+    lexer = get_lexer(language)
+    tokens = list(lex(code, lexer))
+    return tokens
+
+
+def add_code_block_to_doc(doc, code, language=""):
+    """
+    Add a syntax-highlighted code block to the document.
+
+    Args:
+        doc: python-docx Document
+        code: Source code string
+        language: Programming language name
+
+    Returns:
+        The created paragraph
+    """
+    # Remove trailing newline if present
+    code = code.rstrip("\n")
+    if not code:
+        return None
+
+    tokens = tokenize_code(code, language)
+
+    # Add language label if specified
+    lang_display = language.strip() if language else ""
+    if lang_display:
+        label_para = doc.add_paragraph()
+        label_para.paragraph_format.space_after = Pt(0)
+        label_para.paragraph_format.space_before = Pt(8)
+        label_run = label_para.add_run(f"  {lang_display}")
+        label_run.font.name = FONT_CODE
+        label_run.font.size = Pt(8)
+        label_run.font.color.rgb = RGBColor(0x88, 0x88, 0x88)
+        label_run.font.italic = True
+        # Set East Asian font for the run
+        rPr = label_run._element.get_or_add_rPr()
+        rFonts = rPr.find(qn("w:rFonts"))
+        if rFonts is None:
+            rFonts = OxmlElement("w:rFonts")
+            rPr.insert(0, rFonts)
+        rFonts.set(qn("w:eastAsia"), FONT_CODE)
+
+    # Create the code paragraph
+    para = doc.add_paragraph()
+    para.paragraph_format.space_before = Pt(2) if lang_display else Pt(8)
+    para.paragraph_format.space_after = Pt(8)
+    para.paragraph_format.line_spacing = 1.0
+
+    # Style: gray background + borders
+    set_paragraph_shading(para, COLOR_CODE_BLOCK_BG)
+    set_paragraph_borders(para, color=COLOR_CODE_BLOCK_BORDER, size="4", space="6")
+
+    # Add padding via indentation
+    para.paragraph_format.left_indent = Pt(10)
+    para.paragraph_format.right_indent = Pt(10)
+
+    # Render each token with syntax coloring
+    for token_type, token_value in tokens:
+        if not token_value:
+            continue
+
+        color = get_syntax_color(token_type)
+
+        # Split token value by newlines
+        parts = token_value.split("\n")
+        for idx, part in enumerate(parts):
+            if part:
+                run = para.add_run(part)
+                run.font.name = FONT_CODE
+                run.font.size = FONT_SIZE_CODE_BLOCK
+                if color:
+                    run.font.color.rgb = color
+                # East Asian font
+                rPr = run._element.get_or_add_rPr()
+                rFonts = rPr.find(qn("w:rFonts"))
+                if rFonts is None:
+                    rFonts = OxmlElement("w:rFonts")
+                    rPr.insert(0, rFonts)
+                rFonts.set(qn("w:eastAsia"), FONT_CODE)
+
+            # Add line break between lines (not after last line)
+            if idx < len(parts) - 1:
+                br_run = para.add_run()
+                br_run.add_break()
+
+    return para

markdocx/core.py

@@ -0,0 +1,130 @@
+"""
+Core conversion orchestrator.
+Điều phối quá trình chuyển đổi từ Markdown sang DOCX.
+"""
+
+import os
+import glob
+import logging
+import time
+
+from markdocx.md_parser import parse_markdown
+from markdocx.docx_builder import DocxBuilder
+
+logger = logging.getLogger(__name__)
+
+
+def convert_file(input_path, output_path=None, verbose=False):
+    """
+    Convert a single Markdown file to DOCX.
+
+    Args:
+        input_path: Path to the .md file
+        output_path: Path for the output .docx file (auto-generated if None)
+        verbose: Enable verbose logging
+
+    Returns:
+        Path to the output .docx file
+
+    Raises:
+        FileNotFoundError: If input file doesn't exist
+        ValueError: If input is not a .md file
+    """
+    _setup_logging(verbose)
+
+    input_path = os.path.abspath(input_path)
+
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"File not found: {input_path}")
+
+    if not input_path.lower().endswith(".md"):
+        raise ValueError(f"Expected a .md file, got: {input_path}")
+
+    if output_path is None:
+        output_path = os.path.splitext(input_path)[0] + ".docx"
+    output_path = os.path.abspath(output_path)
+
+    logger.info(f"Converting: {input_path}")
+    start = time.time()
+
+    # Read markdown
+    with open(input_path, "r", encoding="utf-8") as f:
+        md_text = f.read()
+
+    # Parse
+    tokens = parse_markdown(md_text)
+    logger.info(f"  Parsed {len(tokens)} tokens")
+
+    # Build DOCX
+    base_dir = os.path.dirname(input_path)
+    builder = DocxBuilder(base_dir=base_dir)
+    builder.build(tokens, output_path)
+
+    elapsed = time.time() - start
+    logger.info(f"  Done in {elapsed:.2f}s → {output_path}")
+
+    return output_path
+
+
+def convert_directory(input_dir, output_dir=None, recursive=False, verbose=False):
+    """
+    Convert all Markdown files in a directory to DOCX.
+
+    Args:
+        input_dir: Path to the directory containing .md files
+        output_dir: Path for output .docx files (uses input_dir if None)
+        recursive: Search for .md files recursively
+        verbose: Enable verbose logging
+
+    Returns:
+        List of (input_path, output_path, success, error) tuples
+    """
+    _setup_logging(verbose)
+
+    input_dir = os.path.abspath(input_dir)
+    if not os.path.isdir(input_dir):
+        raise NotADirectoryError(f"Not a directory: {input_dir}")
+
+    if output_dir is None:
+        output_dir = input_dir
+    output_dir = os.path.abspath(output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Find markdown files
+    pattern = os.path.join(input_dir, "**", "*.md") if recursive else os.path.join(input_dir, "*.md")
+    md_files = sorted(glob.glob(pattern, recursive=recursive))
+
+    if not md_files:
+        logger.warning(f"No .md files found in: {input_dir}")
+        return []
+
+    logger.info(f"Found {len(md_files)} markdown file(s)")
+
+    results = []
+    for md_file in md_files:
+        # Compute output path preserving relative structure
+        rel_path = os.path.relpath(md_file, input_dir)
+        out_path = os.path.join(output_dir, os.path.splitext(rel_path)[0] + ".docx")
+
+        try:
+            convert_file(md_file, out_path, verbose=verbose)
+            results.append((md_file, out_path, True, None))
+        except Exception as e:
+            logger.error(f"Failed to convert {md_file}: {e}")
+            results.append((md_file, out_path, False, str(e)))
+
+    # Summary
+    success = sum(1 for *_, ok, _ in results if ok)
+    failed = len(results) - success
+    logger.info(f"\nConversion complete: {success} succeeded, {failed} failed")
+
+    return results
+
+
+def _setup_logging(verbose=False):
+    """Configure logging."""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(levelname)s: %(message)s",
+    )