Автоматизация создания документов Word через Markdown и Python

Пост опубликован в блогах iXBT.com, его автор не имеет отношения к редакции iXBT.com
Проблема шаблонов Word

Традиционный подход к созданию документов в Word предполагает использование шаблонов (.dotx/.dotm). Шаблон содержит предопределённые стили, форматы и настройки, которые применяются ко всем документам, созданным на его основе.


Автор: Nick_Verdi/Qwen.ai
Технические ограничения подхода

Бинарный формат. Шаблоны Word — бинарные файлы. Системы контроля версий (Git, SVN) не могут отслеживать изменения на уровне отдельных свойств стилей. Diff показывает только факт изменения файла, но не содержание правок.

Глобальное состояние. Шаблон — это глобальный объект. Изменение стиля в шаблоне влияет на все документы, созданные на его основе. Откатить изменение для конкретного документа без затрагивания остальных невозможно.

Ручное управление. Для изменения стиля необходимо:

  1. Открыть шаблон в Word.
  2. Найти нужный стиль в диалоге управления стилями.
  3. Внести изменения через графический интерфейс.
  4. Сохранить шаблон.
  5. Пересоздать документы, если требуется применить изменения к существующим файлам.

Зависимость от среды. Результат зависит от версии Word, локали, настроек темы. Документ, созданный в Word 2016, может отличаться от документа, созданного в Word 2021, даже при использовании одного шаблона.

Ограниченная автоматизация. Макросы VBA позволяют автоматизировать некоторые операции, но:

  • VBA имеет ограниченные возможности работы с OOXML.
  • Макросы не версионируются (хранятся внутри .dotm).
  • Отладка макросов сложнее, чем обычных скриптов.
Существующие решения

На рынке есть инструменты конвертации Markdown → DOCX:

Pandoc — универсальный конвертер документов. Поддерживает Markdown, LaTeX, HTML, DOCX и десятки других форматов. Команда:


▼pandoc input.md -o output.docx --reference-doc=template.docx

Pandoc использует --reference-doc для применения стилей из шаблона Word. Это решает часть проблем, но:

  • Стили всё равно хранятся в бинарном шаблоне.
  • Настройка стилей требует редактирования .docx вручную.
  • Сложная логика (условия, циклы) реализуется через фильтры Lua, что добавляет сложность.

markdown2docx, mammoth, docxtemplater — другие варианты конвертеров. Каждый имеет свои ограничения: неполная поддержка OOXML, зависимость от шаблонов, отсутствие гибкости в управлении стилями.

Когда эти инструменты подходят:

  • Простая конвертация без сложной настройки стилей.
  • Один шаблон на все документы.
  • Не требуется версионирование описания стилей.

Когда требуется другой подход:

  • Каждый документ имеет уникальные стили.
  • Нужна автоматизация с условиями и циклами.
  • Требуется версионирование описания стилей в Git.
  • Необходим полный контроль над OOXML.
Альтернативный подход: документ как код

Решение — хранить описание стилей и контент в текстовом формате, который можно версионировать, автоматизировать и воспроизводить независимо от среды выполнения.

Архитектура

Формат контента: Markdown — текстовый формат с простой разметкой.

Управление стилями: Python-блоки внутри Markdown-файла. Скрипт извлекает эти блоки, выполняет их и настраивает стили Word через библиотеку python-docx.

Сборка документа: Скрипт md_to_docx.py обрабатывает .md файл и генерирует .docx.

Структура проекта
▼project/
├── md_to_docx.py          # основной скрипт сборки
├── py_block.py            # модуль выполнения Python-блоков
├── helpers.py             # опционально: переиспользуемые функции
├── document.md            # исходный документ
└── document.docx          # результат сборки

Зависимости

На компьютере должен быть установлен Python, например, версии 3.13. Следующая консольная команда устанавливает нужные пакеты:

▼pip install mistune python-docx pywin32

  • mistune — парсер Markdown.
  • python-docx — генерация DOCX, работа со стилями.
  • pywin32 — опционально, для управления открытыми файлами Word.
Реализация
Модуль py_block.py

Извлекает Python-блоки из Markdown и выполняет их в контексте документа.

# -*- coding: utf-8 -*-
"""py_block.py — выполнение Python-блоков ```py ... ``` из Markdown."""

import re
import sys
import traceback
from dataclasses import dataclass
from typing import Callable

from docx import Document
from docx.enum.style import WD_STYLE_TYPE
from docx.enum.text import (WD_ALIGN_PARAGRAPH, WD_COLOR_INDEX,
                            WD_LINE_SPACING, WD_UNDERLINE)
from docx.oxml import parse_xml
from docx.oxml.ns import qn
from docx.oxml.shared import OxmlElement
from docx.shared import Cm, Emu, Inches, Mm, Pt, RGBColor


@dataclass
class PyBlock:
    code: str
    line: int


# Регэксп: ```py / ```python ... ``` (не жадный, многострочный)
_RE = re.compile(r"^```(?:py|python)s*n(.*?)^```s*$", re.M | re.S)


def norm(name: str) -> str:
    return " ".join(str(name).split()).casefold()

def extract(md_text: str) -> tuple[str, list[PyBlock]]:
    """Вырезает py-блоки, возвращает очищенный текст и список блоков."""
    blocks = []
    for m in _RE.finditer(md_text):
        line_no = md_text.count("n", 0, m.start()) + 1
        blocks.append(PyBlock(code=m.group(1), line=line_no))
    cleaned = _RE.sub("", md_text)
    return cleaned, blocks


def make_sandbox(doc: Document, generator) -> dict:
    # Импорт алиасов из md_to_docx
    import sys
    md_to_docx = sys.modules.get("__main__")
    ALIASES = getattr(md_to_docx, "ALIASES", {})

    def black():
        """Возвращает RGBColor для черного."""
        return RGBColor(0, 0, 0)

    def style(name):
        """Ищет стиль по любому имени (рус/англ/ID)."""
        # Прямой поиск
        try:
            return doc.styles[name]
        except KeyError:
            pass
        # Через алиасы
        from py_block import norm
        key = norm(name)
        if key in ALIASES:
            try:
                return doc.styles[ALIASES[key]]
            except KeyError:
                pass
        # Перебор всех стилей
        for s in doc.styles:
            if norm(s.name) == key or norm(s.style_id) == key:
                return s
        raise KeyError(f"Стиль '{name}' не найден")

    """Переменные, доступные внутри ```py блоков."""
    return {
        # Документ и генератор (чтобы можно было вызывать render_inline и т.п.)
        "doc": doc,
        "gen": generator,
        "style": style,

        # Типы стилей
        "PARAGRAPH": WD_STYLE_TYPE.PARAGRAPH,
        "CHARACTER": WD_STYLE_TYPE.CHARACTER,
        "TABLE":     WD_STYLE_TYPE.TABLE,
        "LIST":      WD_STYLE_TYPE.LIST,

        # OOXML
        "OxmlElement": OxmlElement,
        "parse_xml":   parse_xml,
        "qn":          qn,

        # Единицы и цвета
        "Pt": Pt, "Cm": Cm, "Mm": Mm, "Inches": Inches, "Emu": Emu,
        "RGBColor": RGBColor,

        # Константы
        "ALIGN": {
            "left": WD_ALIGN_PARAGRAPH.LEFT, "center": WD_ALIGN_PARAGRAPH.CENTER,
            "right": WD_ALIGN_PARAGRAPH.RIGHT, "justify": WD_ALIGN_PARAGRAPH.JUSTIFY,
        },
        "UNDERLINE": {k: getattr(WD_UNDERLINE, k) for k in
                      ("SINGLE", "DOUBLE", "DOTTED", "DASH", "WAVY", "WORDS")},
        "LINE_SPACING": {k: getattr(WD_LINE_SPACING, k) for k in
                         ("SINGLE", "ONE_POINT_FIVE", "DOUBLE", "AT_LEAST",
                          "EXACTLY", "MULTIPLE")},

        # Хелперы
        "add_style": lambda name, stype=WD_STYLE_TYPE.PARAGRAPH, base=None: _add_style(doc, name, stype, base),
        "set_font":  _set_font,
        "set_para":  _set_para,
        "set_border": _set_border,
        "set_shading": _set_shading,
        "set_outline_level": _set_outline_level,

        # Стандартные библиотеки
        "re": re, "os": __import__("os"), "sys": sys,
        "Path": __import__("pathlib").Path,
    }


def _add_style(doc, name, stype, base=None):
    s = doc.styles.add_style(name, stype)
    if base:
        s.base_style = doc.styles[base] if isinstance(base, str) else base
    return s


def _set_font(style, *, name=None, size=None, bold=None, italic=None,
              color=None, underline=None):
    f = style.font
    if name is not None:
        rpr = style.element.get_or_add_rPr()
        fonts = rpr.find(qn("w:rFonts"))
        if fonts is None:
            fonts = OxmlElement("w:rFonts")
            rpr.append(fonts)
        for a in ("ascii", "hAnsi", "eastAsia", "cs"):
            fonts.set(qn("w:" + a), name)
        for a in ("asciiTheme", "hAnsiTheme", "eastAsiaTheme", "cstheme"):
            fonts.attrib.pop(qn("w:" + a), None)
    if size is not None:      f.size = size
    if bold is not None:      f.bold = bold
    if italic is not None:    f.italic = italic
    
    # Обработка цвета
    if color is not None:
        if color == "auto":
            # Сбросить цвет — наследуется от стиля
            rpr = style.element.find(qn("w:rPr"))
            if rpr is not None:
                for el in rpr.findall(qn("w:color")):
                    rpr.remove(el)
        else:
            f.color.rgb = color
    
    if underline is not None: f.underline = underline


def _set_para(style, *, align=None, left_indent=None, right_indent=None,
              first_line_indent=None, space_before=None, space_after=None,
              line_spacing=None, line_spacing_rule=None,
              keep_with_next=None, keep_together=None, page_break_before=None,
              widow_control=None, outline_level=None):
    pf = style.paragraph_format
    if align is not None:              pf.alignment = align
    if left_indent is not None:        pf.left_indent = left_indent
    if right_indent is not None:       pf.right_indent = right_indent
    if first_line_indent is not None:  pf.first_line_indent = first_line_indent
    if space_before is not None:       pf.space_before = space_before
    if space_after is not None:        pf.space_after = space_after
    if line_spacing is not None:       pf.line_spacing = line_spacing
    if line_spacing_rule is not None:  pf.line_spacing_rule = line_spacing_rule
    if keep_with_next is not None:     pf.keep_with_next = keep_with_next
    if keep_together is not None:      pf.keep_together = keep_together
    if page_break_before is not None:  pf.page_break_before = page_break_before
    if widow_control is not None:      pf.widow_control = widow_control
    if outline_level is not None:
        ppr = style.element.get_or_add_pPr()
        ol = ppr.find(qn("w:outlineLvl"))
        if ol is None:
            ol = OxmlElement("w:outlineLvl")
            ppr.append(ol)
        ol.set(qn("w:val"), str(int(outline_level)))


def _set_border(style, side="all", *, style_name="single", size_pt=0.5,
                color="000000", space_pt=1):
    """side: 'all' | 'top' | 'bottom' | 'left' | 'right' | 'between'."""
    sz = int(round(size_pt * 8))
    sp = int(round(space_pt))
    attrs = {"val": style_name, "sz": sz, "color": color, "space": sp}
    ppr = style.element.get_or_add_pPr()
    bdr = ppr.find(qn("w:pBdr"))
    if bdr is None:
        bdr = OxmlElement("w:pBdr")
        ppr.append(bdr)
    sides = ("top", "left", "bottom", "right") if side == "all" else (side,)
    for s in sides:
        el = bdr.find(qn("w:" + s))
        if el is None:
            el = OxmlElement("w:" + s)
            bdr.append(el)
        for k, v in attrs.items():
            el.set(qn("w:" + k), str(v))


def _set_shading(style, fill, color="auto", val="clear"):
    ppr = style.element.get_or_add_pPr()
    shd = ppr.find(qn("w:shd"))
    if shd is None:
        shd = OxmlElement("w:shd")
        ppr.append(shd)
    shd.set(qn("w:fill"), fill.lstrip("#"))
    shd.set(qn("w:color"), color)
    shd.set(qn("w:val"), val)


def _set_outline_level(style, level):
    ppr = style.element.get_or_add_pPr()
    ol = ppr.find(qn("w:outlineLvl"))
    if ol is None:
        ol = OxmlElement("w:outlineLvl")
        ppr.append(ol)
    ol.set(qn("w:val"), str(int(level)))


def run_blocks(blocks: list[PyBlock], sandbox: dict, verbose: bool = True) -> int:
    """Выполняет все блоки. Возвращает количество ошибок."""
    errors = 0
    for i, b in enumerate(blocks, 1):
        if verbose:
            print(f"n[py #{i}] строка {b.line} ({len(b.code)} симв.)")
        try:
            exec(b.code, sandbox)        # noqa: S102 — локальный инструмент
        except Exception:
            errors += 1
            print(f"!!! Ошибка в блоке #{i} (строка MD {b.line}):")
            traceback.print_exc()
    return errors
Основной скрипт md_to_docx.py
# -*- coding: utf-8 -*-
"""md_to_docx.py — Markdown -> DOCX. Запуск: py -3.13 md_to_docx.py file.md"""

import os
import re
import sys

import mistune
from docx import Document
from docx.oxml.ns import qn
from docx.oxml.shared import OxmlElement
from docx.shared import Cm, Pt
from docx.enum.style import WD_STYLE_TYPE
from py_block import extract as py_extract, make_sandbox, run_blocks

# ============================================================
# СТИЛИ И ПАРАМЕТРЫ
# ============================================================
STYLE_HEADING_PREFIX = "Heading"
STYLE_IMAGE          = "Картинка"
STYLE_FIGURE_CAPTION = "Подпись картинки"
STYLE_TABLE_CAPTION  = "Название таблицы"
STYLE_TABLE          = "Table Grid"
STYLE_NORMAL         = "Normal"

CUSTOM_BULLET_STYLE = "Custom Bullet List"
CUSTOM_NUMBER_STYLE = "Custom Number List"

SEQ_FIGURE     = "Рисунок"
SEQ_TABLE      = "Таблица"
IMAGE_WIDTH_CM = 14

ALIASES = {}
for _i in range(1, 10):
    ALIASES[f"заголовок {_i}"] = f"Heading {_i}"
    ALIASES[f"heading{_i}"] = f"Heading {_i}"
ALIASES.update({
    "обычный": "Normal",
    "сетка таблицы": "Table Grid",
})


def norm(name):
    return " ".join(name.split()).casefold()


def add_word_field(paragraph, instr):
    run = paragraph.add_run()
    begin = OxmlElement("w:fldChar")
    begin.set(qn("w:fldCharType"), "begin")
    run._r.append(begin)
    code = OxmlElement("w:instrText")
    code.set(qn("xml:space"), "preserve")
    code.text = f" {instr} "
    run._r.append(code)
    separate = OxmlElement("w:fldChar")
    separate.set(qn("w:fldCharType"), "separate")
    run._r.append(separate)
    cached = OxmlElement("w:t")
    cached.text = "1"
    run._r.append(cached)
    end = OxmlElement("w:fldChar")
    end.set(qn("w:fldCharType"), "end")
    run._r.append(end)


def close_word_file(filepath):
    if not os.path.exists(filepath):
        return True
    try:
        with open(filepath, "r+b"):
            return True
    except PermissionError:
        pass

    try:
        import win32com.client as win32
        word = win32.GetActiveObject("Word.Application")
        abs_path = os.path.abspath(filepath).lower()
        for doc in word.Documents:
            if doc.FullName.lower() == abs_path:
                doc.Close(SaveChanges=0)
                print(f"  [ОК] Файл закрыт в Word: {os.path.basename(filepath)}")
                return True
        print(f"  [!] Файл занят другим процессом. Закройте его вручную.")
        return False
    except ImportError:
        print(f"  [!] Файл '{os.path.basename(filepath)}' открыт в Word.")
        print(f"      Установите pywin32 (py -3.13 -m pip install pywin32),")
        print(f"      чтобы скрипт закрывал его автоматически.")
        return False
    except Exception as e:
        print(f"  [!] Не удалось закрыть файл через Word: {e}")
        return False


class DocxGenerator:
    def __init__(self, md_path, template_path=None):
        self.md_path = md_path
        self.base_dir = os.path.dirname(os.path.abspath(md_path))

        if template_path and os.path.exists(template_path):
            self.doc = Document(template_path)
            self.clear_document()
        else:
            self.doc = Document()

        self._style_index = {}
        for s in self.doc.styles:
            self._style_index.setdefault(norm(s.name), s)
            self._style_index.setdefault(norm(s.style_id), s)
        self._warned = set()
        self.bookmark_id = 1

        settings = self.doc.settings.element
        upd = settings.find(qn("w:updateFields"))
        if upd is None:
            upd = OxmlElement("w:updateFields")
            settings.append(upd)
        upd.set(qn("w:val"), "true")

    def clear_document(self):
        body = self.doc.element.body
        for child in list(body):
            if child.tag in (qn("w:p"), qn("w:tbl")):
                body.remove(child)

    def _find_style(self, name):
        s = self._style_index.get(norm(name))
        if s is not None: return s
        alias = ALIASES.get(norm(name))
        return self._style_index.get(norm(alias)) if alias else None

    def _warn(self, name):
        if name not in self._warned:
            self._warned.add(name)
            print(f"!!! Стиль '{name}' не найден. Применяется 'Normal'.")

    def apply_style(self, paragraph, name):
        s = self._find_style(name)
        if s is None:
            self._warn(name)
            s = self._find_style(STYLE_NORMAL)
        if s is not None:
            paragraph.style = s

    def _create_bullet_style(self):
        """Создаёт стиль маркированного списка с маркером — (длинное тире)."""
        # Проверяем через norm, что стиль уже есть
        existing = self._find_style(CUSTOM_BULLET_STYLE)
        if existing:
            return existing
        
        # Создаём новый стиль
        style = self.doc.styles.add_style(CUSTOM_BULLET_STYLE, WD_STYLE_TYPE.PARAGRAPH)
        style.base_style = self.doc.styles[STYLE_NORMAL]
        
        # Настраиваем отступы
        style.paragraph_format.left_indent = Cm(1.25)
        style.paragraph_format.first_line_indent = Cm(-0.63)
        
        # Добавляем в индекс
        self._style_index[norm(CUSTOM_BULLET_STYLE)] = style
        
        return style

    def _create_number_style(self):
        """Создаёт стиль нумерованного списка."""
        existing = self._find_style(CUSTOM_NUMBER_STYLE)
        if existing:
            return existing
        
        style = self.doc.styles.add_style(CUSTOM_NUMBER_STYLE, WD_STYLE_TYPE.PARAGRAPH)
        style.base_style = self.doc.styles[STYLE_NORMAL]
        
        style.paragraph_format.left_indent = Cm(1.25)
        style.paragraph_format.first_line_indent = Cm(-0.63)
        
        self._style_index[norm(CUSTOM_NUMBER_STYLE)] = style
        
        return style

    def _get_list_style(self, is_ordered):
        """Ищет стиль списка в шаблоне. Если не находит — создаёт фолбэк."""
        if is_ordered:
            candidates = ["Список маркеров", "List Number", "Нумерованный список"]
        else:
            candidates = ["Список маркеров", "List Bullet", "Маркированный список"]
        
        for name in candidates:
            s = self._find_style(name)
            if s is not None:
                return s, False  # (стиль, использовать_фолбэк)
        
        # Стиль не найден — создаём фолбэк
        if is_ordered:
            return self._create_number_style(), True
        else:
            return self._create_bullet_style(), True

    def _caption(self, style_name, label, seq_name, text):
        p = self.doc.add_paragraph()
        self.apply_style(p, style_name)
        p.add_run(f"{label} ")
        bm_id = str(self.bookmark_id)
        start = OxmlElement("w:bookmarkStart")
        start.set(qn("w:id"), bm_id)
        start.set(qn("w:name"), self.pending_label)
        p._p.append(start)
        add_word_field(p, f"SEQ {seq_name} \* ARABIC")
        end = OxmlElement("w:bookmarkEnd")
        end.set(qn("w:id"), bm_id)
        p._p.append(end)
        self.bookmark_id += 1
        p.add_run(f". {text}")

    def render_figure_caption(self, text, label_id):
        self.pending_label = label_id
        self._caption(STYLE_FIGURE_CAPTION, SEQ_FIGURE, SEQ_FIGURE, text)

    def render_table_caption(self, text, label_id):
        self.pending_label = label_id
        self._caption(STYLE_TABLE_CAPTION, SEQ_TABLE, SEQ_TABLE, text)

    def get_text(self, children):
        out = ""
        for c in children:
            if c["type"] == "text":
                out += c.get("raw", "")
            elif "children" in c:
                out += self.get_text(c["children"])
        return out

    def render_inline(self, children, paragraph, bold=False, italic=False, underline=False):
        for c in children:
            t = c["type"]
            if t == "text":
                self._render_text(c.get("raw", ""), paragraph, bold, italic, underline)
            elif t == "strong":
                self.render_inline(c["children"], paragraph, True, italic, underline)
            elif t == "emphasis":
                self.render_inline(c["children"], paragraph, bold, True, underline)
            elif t == "codespan":
                paragraph.add_run(c.get("raw", "")).font.name = "Courier New"
            elif t == "link":
                self.render_inline(c.get("children", []), paragraph, bold, italic, underline)
            elif t == "image":
                self.render_image(c)

    def _render_text(self, text, paragraph, bold, italic, underline):
        for part in re.split(r'(++[^+]+++)', text):
            if part.startswith('++') and part.endswith('++') and len(part) > 4:
                self._render_text_with_links(part[2:-2], paragraph, bold, italic, True)
            else:
                self._render_text_with_links(part, paragraph, bold, italic, underline)

    def _render_text_with_links(self, text, paragraph, bold, italic, underline):
        for part in re.split(r'(@(?:fig|tbl)-[w-]+)', text):
            if re.fullmatch(r'@(?:fig|tbl)-[w-]+', part):
                add_word_field(paragraph, f"REF {part[1:]} \h")
            elif part:
                r = paragraph.add_run(part)
                r.bold = bold
                r.italic = italic
                r.underline = underline

    def render_image(self, child):
        attrs = child.get("attrs", {})
        src = attrs.get("url", "")
        if not os.path.isabs(src):
            src = os.path.join(self.base_dir, src)
        caption = self.get_text(child.get("children", []))
        m = re.search(r"{#([w-]+)}", caption)
        p = self.doc.add_paragraph()
        self.apply_style(p, STYLE_IMAGE)
        try:
            p.add_run().add_picture(src, width=Cm(IMAGE_WIDTH_CM))
        except Exception as e:
            print(f"!!! Картинка не вставлена ({src}): {e}")
        if m:
            text = caption.replace(m.group(0), "").strip()
            self.render_figure_caption(text, m.group(1))

    def render_table(self, token):
        # Собираем строки как списки AST-ячеек (с детьми), а не как строки
        rows = []
        for section in token.get("children", []):
            children = section.get("children", [])
            if not children:
                continue
            if children[0]["type"] == "table_row":
                for row in children:
                    rows.append(list(row.get("children", [])))
            else:
                rows.append(list(children))
        if not rows:
            return

        cols = max(len(r) for r in rows)
        for r in rows:
            r += [None] * (cols - len(r))

        table = self.doc.add_table(rows=len(rows), cols=cols)
        s = self._find_style(STYLE_TABLE)
        if s is not None:
            table.style = s

        for i, row_cells in enumerate(rows):
            for j, cell_ast in enumerate(row_cells):
                try:
                    cell = table.cell(i, j)
                    is_empty = self._cell_is_empty(cell_ast)

                    # Merge пустых ячеек с предыдущей (как было)
                    if is_empty and j > 0 and not self._cell_is_empty(row_cells[j - 1]):
                        cell.merge(table.cell(i, j - 1))
                        continue

                    # Очищаем дефолтный параграф ячейки
                    for p in list(cell.paragraphs):
                        p_element = p._element
                        p_element.getparent().remove(p_element)

                    # Создаём новый параграф и рендерим инлайн-разметку
                    p = cell.add_paragraph()
                    if cell_ast is not None and "children" in cell_ast:
                        self.render_inline(cell_ast["children"], p)
                except Exception as e:
                    print(f"!!! Ячейка {i},{j}: {e}")

    def _cell_is_empty(self, cell_ast):
        """Проверяет, пуста ли ячейка (для логики merge)."""
        if cell_ast is None:
            return True
        children = cell_ast.get("children", [])
        if not children:
            return not (cell_ast.get("text") or cell_ast.get("raw") or "").strip()
        return not self.get_text(children).strip()
        def _cell_text(self, cell):
            if "children" in cell:
                return self.get_text(cell["children"])
            return cell.get("text", cell.get("raw", ""))

    def render_block(self, token):
        t = token["type"]
        if t == "paragraph":
            content = self.get_text(token.get("children", []))
            if content.startswith(("Таблица: ", "Table: ")):
                text = re.sub(r"^(Таблица: |Table: )", "", content)
                m = re.search(r"{#([w-]+)}", text)
                label = m.group(1) if m else f"tbl-{self.bookmark_id}"
                text = text.replace(m.group(0), "").strip() if m else text
                self.render_table_caption(text, label)
                return
            p = self.doc.add_paragraph()
            self.render_inline(token.get("children", []), p)
        elif t == "heading":
            level = token["attrs"]["level"]
            p = self.doc.add_paragraph()
            self.apply_style(p, f"{STYLE_HEADING_PREFIX} {level}")
            self.render_inline(token.get("children", []), p)
        elif t == "list":
            self.render_list(token, counter=[1])
        elif t == "table":
            self.render_table(token)

    def render_list(self, token, counter=None):
        """Рекурсивная отрисовка списков."""
        if counter is None:
            counter = [1]

        is_ordered = token["attrs"].get("ordered", False)
        style, use_fallback = self._get_list_style(is_ordered)

        items_count = 0
        for item in token.get("children", []):
            for block in item.get("children", []):
                if block["type"] == "paragraph":
                    p = self.doc.add_paragraph()
                    p.style = style
                    
                    # Отступы
                    p.paragraph_format.first_line_indent = Cm(1.25)
                    p.paragraph_format.left_indent = Cm(0)

                    # Только если стиль не найден — рисуем маркер вручную
                    if use_fallback:
                        if is_ordered:
                            marker = f"{counter[0]}. "
                            counter[0] += 1
                        else:
                            marker = "— "
                        r = p.add_run(marker)
                        r.bold = False

                    self.render_inline(block.get("children", []), p)
                    items_count += 1
                elif block["type"] == "list":
                    self.render_list(block, counter=counter)

        fallback_msg = " (фолбэк: маркер рисуется вручную)" if use_fallback else ""
        print(f"  [ОК] Список ({'нумерованный' if is_ordered else 'маркированный'}), элементов: {items_count}{fallback_msg}")

    def render(self, md_text):
        # 1. Вытаскиваем и выполняем Python-блоки
        md_text, py_blocks = py_extract(md_text)
        if py_blocks:
            print(f"nНайдено Python-блоков: {len(py_blocks)}")
            sandbox = make_sandbox(self.doc, self)
            errors = run_blocks(py_blocks, sandbox)
            if errors:
                print(f"!!! Ошибок в Python-блоках: {errors}")

        md_text = md_text.replace("—»", "→").replace("-->", "→").replace("->", "→")
        md_text = re.sub(r'([^n])n([ t]*[-*]|d+.)', r'1nn2', md_text)
        md_text = re.sub(r'^([ t]*)[–—]([ t]+)', r'1-2', md_text, flags=re.MULTILINE)

        md = mistune.create_markdown(renderer=None, plugins=["table", "strikethrough"])
        tokens = list(md(md_text))

        list_count = sum(1 for t in tokens if t["type"] == "list")
        print(f"nНайдено списков в тексте: {list_count}")

        for token in tokens:
            self.render_block(token)

        out = os.path.splitext(self.md_path)[0] + ".docx"

        if not close_word_file(out):
            print("  [!] Сохранение невозможно. Повторите после закрытия файла.")
            sys.exit(1)

        self.doc.save(out)
        print(f"Успешно сохранено: {out}")
        
        # Открываем файл
        try:
            os.startfile(out)
            print(f"  [ОК] Файл открыт: {os.path.basename(out)}")
        except Exception as e:
            print(f"  [!] Не удалось открыть файл: {e}")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Использование: py -3.13 md_to_docx.py input.md")
        sys.exit(1)

    input_file = sys.argv[1]
    template = os.path.join(os.path.dirname(os.path.abspath(input_file)), "template.docx")
    if not os.path.exists(template):
        template = None

    with open(input_file, "r", encoding="utf-8") as f:
        text = f.read()

    DocxGenerator(input_file, template).render(text)
Пример использования
Исходный файл document. md
▼```py
# Настройка стилей
set_font(style("Heading 1"), name="Times New Roman", size=Pt(16), 
         bold=True, color=RGBColor(0x1F, 0x38, 0x64))
set_para(style("Heading 1"), align=ALIGN["center"], 
         space_before=Pt(12), space_after=Pt(6))

for lvl in range(2, 7):
    s = style(f"Heading {lvl}")
    set_font(s, name="Times New Roman", size=Pt(16 - lvl), bold=True)

set_font(style("Normal"), name="Times New Roman", size=Pt(14))
set_para(style("Normal"), align=ALIGN["justify"], 
         first_line_indent=Cm(1.25), line_spacing=1.5, 
         line_spacing_rule=LINE_SPACING["MULTIPLE"])
```

# Введение

Текст документа с автоматической настройкой стилей.

## Архитектура

Описание архитектуры системы.

Выполнение

▼python md_to_docx.py document.md

Результат: document. docx с настроенными стилями.


При открытии документа скорее всего появится модальное окошко:

Автор: Nick_Verdi

Кликаем «Да».

Интеграция с Sublime Text
Build System

В Sublime text необходимо создать новую систему сборки. Для этого идем по меню: Tools➡Build System➡New Build System…:

Автор: Nick_Verdi

Полностью заменяем содержимое файл на следующее, но путь к скрипту md_to_docx.py у каждого будет свой, поэтому пишем нужную версию Пайтона вместо 3.13 и правильный путь вместо f:\\PyScripts\\md_to_docx.py:

▼{
    "shell_cmd": "py -3.13 -X utf8 "f:\PyScripts\md_to_docx.py" "$file"",
    "selector": "text.html.markdown",
    "working_dir": "$file_path",
    "encoding": "utf-8"
}

и сохраняем под именем, например MarkdownToDOCX. sublime-build. Никакие пути сохранения не трогаем, куда редактор по умолчанию предлагает сохранить, там и сохраняем. После этого в меню Tools➡Build System появится новый пункт с названием, например, MarkdownToDOCX, если сохранение было в файл MarkdownToDOCX. sublime-build. Название пункта меню соответствует имени файла. И пройдя в меню Tools➡Build надо по этому пункту кликнуть, чтобы по горячей клавише (хоткею) Ctrl+B (в настройках именно такая, если ничего не менялось) запустился бы на выполнение md_to_docx.py с передачей ему файла в активной вкладке редактора.

Использование
  1. Открыть .md файл в Sublime Text.
  2. Нажать Ctrl+B.
  3. Получить готовый .docx файл.
Результат выполнения скрипта виден в консоли текстового редактора
Автор: Nick_Verdi
Преимущества подхода
Версионирование

Markdown-файлы — текст. Git отслеживает изменения:

▼- set_font(style("Heading 1"), size=Pt(14))
+ set_font(style("Heading 1"), size=Pt(16))

Возможны ветки, слияния, откаты.

Воспроизводимость

Документ собирается из исходников. Результат не зависит от версии Word или настроек среды.

Изоляция изменений

Каждый документ содержит собственное описание стилей. Изменение в одном файле не влияет на другие.

Автоматизация

Доступны все возможности Python:

▼# Циклы
for lvl in range(2, 7):
    set_font(style(f"Heading {lvl}"), size=Pt(16 - lvl))

# Условия
if doc.styles["Heading 1"].font.bold:
    set_font(style("Heading 1"), bold=False)

# Функции
def apply_gost_style(style_name):
    set_font(style(style_name), name="Times New Roman", size=Pt(14))
    set_para(style(style_name), align=ALIGN["justify"])

apply_gost_style("Normal")

Сравнение подходов
Критерий Шаблоны Word Markdown + Python
Версионирование Нет (бинарный формат) Да (текст, Git)
Воспроизводимость Зависит от среды Независима
Изоляция изменений Нет (глобальное состояние) Да (каждый документ)
Автоматизация VBA (ограниченно) Полный Python
Переиспользование Копирование шаблонов Функции, модули
Порог входа Низкий (GUI) Средний (Python)
Гибкость Ограничена GUI Без ограничений
Ограничения

Требуются навыки Python. Пользователь должен знать основы Python для настройки стилей.

Отсутствие визуального редактора стилей. Настройки задаются кодом, а не через диалоговые окна.

Неполная поддержка OOXML. Библиотека python-docx покрывает не все возможности Word. Для сложных случаев требуется прямая работа с XML.

Заключение

Подход Markdown + Python заменяет шаблоны Word на версионируемые, воспроизводимые и автоматизируемые исходники. Стили описываются кодом, хранятся в текстовом формате, управляются через Git.

Читайте также

Новости

Публикации