Igor20264
1353 lines
43 KiB
Python
1353 lines
43 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
"""UNO post-process worker - run with LibreOffice/OpenOffice program/python.exe."""
|
|
|
|
from __future__ import print_function, unicode_literals
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
import time
|
|
|
|
from uno_helpers import (
|
|
PASS_SAFETY_CAP,
|
|
continuation_pass_limit,
|
|
CaptionInfo,
|
|
as_unicode,
|
|
caption_style_name,
|
|
continuation_label,
|
|
docx_filter_candidates,
|
|
docx_save_filter_specs,
|
|
BREAK_NONE,
|
|
BREAK_PAGE_BEFORE,
|
|
CONTROL_PARAGRAPH_BREAK,
|
|
find_page_break_row,
|
|
locate_break_row,
|
|
resume_page_before_cut,
|
|
is_caption_orphaned,
|
|
is_orphan_header_break,
|
|
parse_caption_text,
|
|
path_to_file_url,
|
|
uno_call as _uno_call,
|
|
uno_error_text,
|
|
)
|
|
|
|
|
|
def _document_text(doc):
|
|
return _uno_call(doc, "Text", default=None)
|
|
|
|
|
|
def _document_controller(doc):
|
|
return _uno_call(doc, "CurrentController", default=None)
|
|
|
|
|
|
def _text_tables(doc):
|
|
return _uno_call(doc, "TextTables")
|
|
|
|
|
|
def _format_exc(exc):
|
|
name = type(exc).__name__
|
|
try:
|
|
if getattr(exc, "args", None):
|
|
text = as_unicode(exc.args[0])
|
|
else:
|
|
text = as_unicode(exc)
|
|
except Exception:
|
|
text = as_unicode(repr(exc))
|
|
if text:
|
|
return "{0}: {1}".format(name, text)
|
|
return name
|
|
|
|
|
|
def _fs_path(value):
|
|
"""Normalize argv path to unicode on Python 2.7 (Cyrillic paths on Windows)."""
|
|
if sys.version_info[0] >= 3:
|
|
return value
|
|
try:
|
|
text_type = unicode
|
|
except NameError:
|
|
return value
|
|
if isinstance(value, text_type):
|
|
return value
|
|
for encoding in (sys.getfilesystemencoding(), "utf-8", "mbcs"):
|
|
if not encoding:
|
|
continue
|
|
try:
|
|
return value.decode(encoding)
|
|
except (UnicodeDecodeError, LookupError):
|
|
continue
|
|
return value.decode("utf-8", "replace")
|
|
|
|
|
|
def _emit_result(result):
|
|
if sys.version_info[0] < 3:
|
|
result = _unicode_result(result)
|
|
payload = json.dumps(result, ensure_ascii=False)
|
|
if sys.version_info[0] < 3:
|
|
try:
|
|
if isinstance(payload, unicode):
|
|
payload = payload.encode("utf-8")
|
|
except NameError:
|
|
pass
|
|
if sys.version_info[0] >= 3:
|
|
sys.stdout.write(payload + "\n")
|
|
else:
|
|
sys.stdout.write(payload)
|
|
if not payload.endswith(b"\n"):
|
|
sys.stdout.write(b"\n")
|
|
sys.stdout.flush()
|
|
|
|
|
|
def _unicode_result(value):
|
|
if isinstance(value, dict):
|
|
return dict((as_unicode(k), _unicode_result(v)) for k, v in value.items())
|
|
if isinstance(value, list):
|
|
return [_unicode_result(item) for item in value]
|
|
if isinstance(value, tuple):
|
|
return tuple(_unicode_result(item) for item in value)
|
|
if isinstance(value, (int, float, bool)) or value is None:
|
|
return value
|
|
return as_unicode(value)
|
|
|
|
|
|
def _connect(port):
|
|
import uno
|
|
|
|
local_ctx = uno.getComponentContext()
|
|
resolver = local_ctx.ServiceManager.createInstanceWithContext(
|
|
"com.sun.star.bridge.UnoUrlResolver", local_ctx
|
|
)
|
|
last_exc = None
|
|
for _ in range(int(45 / 0.2)):
|
|
try:
|
|
ctx = resolver.resolve(
|
|
"uno:socket,host=127.0.0.1,port={0};urp;StarOffice.ComponentContext".format(
|
|
port
|
|
)
|
|
)
|
|
return uno, ctx
|
|
except Exception as exc:
|
|
last_exc = exc
|
|
time.sleep(0.2)
|
|
raise RuntimeError(
|
|
"cannot connect to soffice on port {0}: {1}".format(port, last_exc)
|
|
)
|
|
|
|
|
|
def _property(name, value):
|
|
from com.sun.star.beans import PropertyValue
|
|
|
|
return PropertyValue(name, 0, value, 0)
|
|
|
|
|
|
def _is_writer_document(doc):
|
|
return _document_text(doc) is not None
|
|
|
|
|
|
def _load_document(uno, ctx, path, engine):
|
|
smgr = ctx.ServiceManager
|
|
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
|
|
file_url = path_to_file_url(uno, path)
|
|
ext = os.path.splitext(path)[1].lower()
|
|
if ext == ".docx":
|
|
filter_names = docx_filter_candidates(engine) + (None,)
|
|
else:
|
|
filter_names = (None,)
|
|
|
|
errors = []
|
|
for filter_name in filter_names:
|
|
props = [
|
|
_property("Hidden", True),
|
|
_property("ReadOnly", False),
|
|
_property("MacroExecutionMode", 4),
|
|
]
|
|
if filter_name:
|
|
props.append(_property("FilterName", filter_name))
|
|
label = filter_name or "auto"
|
|
try:
|
|
doc = desktop.loadComponentFromURL(file_url, "_blank", 0, tuple(props))
|
|
except Exception as exc:
|
|
errors.append("{0}: {1}".format(label, exc))
|
|
continue
|
|
if doc is None:
|
|
errors.append("{0}: loadComponentFromURL returned None".format(label))
|
|
continue
|
|
if not _is_writer_document(doc):
|
|
errors.append("{0}: not a Writer document".format(label))
|
|
try:
|
|
doc.close(True)
|
|
except Exception:
|
|
pass
|
|
continue
|
|
return doc
|
|
|
|
detail = "; ".join(errors) if errors else "unknown error"
|
|
raise RuntimeError("cannot open document: {0} ({1})".format(path, detail))
|
|
|
|
|
|
def _reload_document(uno, ctx, doc, path, engine):
|
|
"""Save and reopen so LO refreshes row page numbers after SplitTable."""
|
|
_save_document(uno, doc, path, engine)
|
|
try:
|
|
doc.close(True)
|
|
except Exception:
|
|
pass
|
|
return _load_document(uno, ctx, path, engine)
|
|
|
|
|
|
def _save_odt_temp(uno, doc):
|
|
"""Save to an ASCII-only temp ODT; host converts to DOCX (Py2 + Cyrillic paths)."""
|
|
import tempfile
|
|
|
|
fd, odt_path = tempfile.mkstemp(prefix="md2gost-", suffix=".odt")
|
|
os.close(fd)
|
|
odt_url = path_to_file_url(uno, odt_path)
|
|
doc.storeToURL(odt_url, (_property("Overwrite", True),))
|
|
if not os.path.isfile(odt_path):
|
|
raise RuntimeError("temp ODT not created: {0}".format(odt_path))
|
|
return odt_path
|
|
|
|
|
|
def _save_document(uno, doc, path, engine):
|
|
"""Save document. Returns temp ODT path when host must export DOCX."""
|
|
ext = os.path.splitext(path)[1].lower()
|
|
if ext != ".docx":
|
|
doc.store()
|
|
return None
|
|
if engine == "openoffice":
|
|
return _save_odt_temp(uno, doc)
|
|
|
|
file_url = path_to_file_url(uno, path)
|
|
errors = []
|
|
for filter_name in docx_save_filter_specs(engine) + (None,):
|
|
props = [_property("Overwrite", True)]
|
|
if filter_name:
|
|
props.append(_property("FilterName", filter_name))
|
|
try:
|
|
doc.storeToURL(file_url, tuple(props))
|
|
return None
|
|
except Exception as exc:
|
|
errors.append(
|
|
"{0}: {1}".format(filter_name or "auto", uno_error_text(exc))
|
|
)
|
|
try:
|
|
doc.store()
|
|
return None
|
|
except Exception as exc:
|
|
errors.append("store: {0}".format(uno_error_text(exc)))
|
|
detail = "; ".join(errors) if errors else "unknown error"
|
|
raise RuntimeError("cannot save document: {0} ({1})".format(path, detail))
|
|
|
|
|
|
def _dispatch(uno, ctx, doc, command, args=()):
|
|
smgr = ctx.ServiceManager
|
|
dispatcher = smgr.createInstanceWithContext(
|
|
"com.sun.star.frame.DispatchHelper", ctx
|
|
)
|
|
controller = _document_controller(doc)
|
|
if controller is None:
|
|
raise RuntimeError("no document controller")
|
|
frame = _uno_call(controller, "Frame")
|
|
dispatcher.executeDispatch(frame, command, "", 0, args)
|
|
|
|
|
|
def _repaginate(uno, ctx, doc):
|
|
for command in (".uno:UpdateAll", ".uno:Repaginate"):
|
|
try:
|
|
_dispatch(uno, ctx, doc, command)
|
|
return
|
|
except Exception:
|
|
continue
|
|
try:
|
|
controller = _document_controller(doc)
|
|
if controller is not None:
|
|
view = _uno_call(controller, "View", default=None)
|
|
if view is not None:
|
|
view.Invalidate()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _page_at_range(doc, text_range):
|
|
try:
|
|
controller = _document_controller(doc)
|
|
if controller is None:
|
|
return None
|
|
view_cursor = _uno_call(controller, "ViewCursor")
|
|
view_cursor.gotoRange(text_range, False)
|
|
page = _view_cursor_page(view_cursor)
|
|
if page is None:
|
|
return None
|
|
return int(page)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _view_cursor_page(view_cursor):
|
|
try:
|
|
import uno
|
|
|
|
from com.sun.star.text import XPageCursor
|
|
|
|
page_cursor = uno.queryInterface(XPageCursor, view_cursor)
|
|
if page_cursor is not None:
|
|
return int(page_cursor.getPage())
|
|
except Exception:
|
|
pass
|
|
try:
|
|
return int(_uno_call(view_cursor, "Page"))
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _ensure_pagination(uno, ctx, doc):
|
|
for command in (".uno:UpdateAll", ".uno:Repaginate", ".uno:ZoomPageWidth"):
|
|
try:
|
|
_dispatch(uno, ctx, doc, command)
|
|
except Exception:
|
|
continue
|
|
try:
|
|
_uno_call(doc, "PageCount")
|
|
except Exception:
|
|
pass
|
|
time.sleep(0.3)
|
|
|
|
|
|
def _diagnose_pagination(doc, details):
|
|
try:
|
|
collection = _text_tables(doc)
|
|
count = int(_uno_call(collection, "Count"))
|
|
details.append("diag: tables={0}".format(count))
|
|
for idx in range(min(count, 4)):
|
|
table = collection.getByIndex(idx)
|
|
caption = _caption_before_table(doc, table)
|
|
pages = _row_page_numbers(doc, table)
|
|
prev = _paragraph_text_before_table(doc, table)
|
|
if caption:
|
|
label = "{0} {1}".format(caption.kind, caption.number)
|
|
else:
|
|
preview = prev[:48] + ("..." if len(prev) > 48 else "")
|
|
label = "no-caption prev={0!r}".format(preview)
|
|
if pages:
|
|
page_info = "{0}-{1} (n={2})".format(
|
|
min(pages), max(pages), len(pages)
|
|
)
|
|
else:
|
|
page_info = "none"
|
|
details.append(
|
|
"diag: table[{0}] {1} pages={2}".format(idx, label, page_info)
|
|
)
|
|
except Exception as exc:
|
|
details.append("diag: {0}".format(uno_error_text(exc)))
|
|
|
|
|
|
def _supports_service(obj, name):
|
|
try:
|
|
return bool(obj.supportsService(name))
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _element_text(elem):
|
|
try:
|
|
return (_uno_call(elem, "String", default="") or "").replace("\r", "").strip()
|
|
except Exception:
|
|
return ""
|
|
|
|
|
|
def _same_text_table(a, b):
|
|
try:
|
|
if a == b:
|
|
return True
|
|
except Exception:
|
|
pass
|
|
try:
|
|
return _uno_call(a, "Anchor") == _uno_call(b, "Anchor")
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _is_target_table(elem, table):
|
|
try:
|
|
if elem == table:
|
|
return True
|
|
except Exception:
|
|
pass
|
|
return _same_text_table(elem, table)
|
|
|
|
|
|
def _body_tables(doc):
|
|
"""All body tables in document order (LO ``getByIndex`` can alias split fragments)."""
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return []
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return []
|
|
tables = []
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
tables.append(elem)
|
|
return tables
|
|
|
|
|
|
def _next_table_in_body(doc, table):
|
|
"""Return the next body table after *table* (LO ``getByIndex(i+1)`` can alias)."""
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return None
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return None
|
|
|
|
seen = False
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if not _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
continue
|
|
if not seen:
|
|
if _is_target_table(elem, table):
|
|
seen = True
|
|
continue
|
|
return elem
|
|
return None
|
|
|
|
|
|
def _paragraphs_before_table(doc, table, max_scan=6):
|
|
"""Walk body content in order; LO/OO table anchors are not navigable."""
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return []
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return []
|
|
recent = []
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
if _is_target_table(elem, table):
|
|
return recent[-max_scan:]
|
|
recent = []
|
|
continue
|
|
if _supports_service(elem, "com.sun.star.text.Paragraph"):
|
|
para_text = _element_text(elem)
|
|
if para_text:
|
|
recent.append(para_text)
|
|
return []
|
|
|
|
|
|
def _paragraph_text_before_table(doc, table):
|
|
paras = _paragraphs_before_table(doc, table, max_scan=1)
|
|
return paras[-1] if paras else ""
|
|
|
|
|
|
def _prev_body_element_before_table(doc, table):
|
|
"""Body element immediately before *table* (paragraph or table)."""
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return None
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return None
|
|
prev_elem = None
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable") and _is_target_table(
|
|
elem, table
|
|
):
|
|
return prev_elem
|
|
prev_elem = elem
|
|
return None
|
|
|
|
|
|
def _caption_before_table(doc, table):
|
|
for para_text in reversed(_paragraphs_before_table(doc, table, max_scan=6)):
|
|
caption = parse_caption_text(para_text)
|
|
if caption is not None:
|
|
return caption
|
|
return None
|
|
|
|
|
|
def _caption_for_split(doc, table):
|
|
"""Caption for split decisions, including orphan continuation fragments."""
|
|
caption = _caption_before_table(doc, table)
|
|
if caption is not None:
|
|
return caption
|
|
prev_table = _first_table_fragment_before(doc, table)
|
|
if prev_table is None:
|
|
return None
|
|
upstream = _caption_before_table(doc, prev_table)
|
|
if upstream is None:
|
|
return None
|
|
return CaptionInfo(
|
|
kind=upstream.kind,
|
|
number=upstream.number,
|
|
is_continuation=True,
|
|
)
|
|
|
|
|
|
def _count_split_targets(doc, tables, listings):
|
|
"""Captioned tables and listings this pass is allowed to split."""
|
|
found = 0
|
|
for table in _body_tables(doc):
|
|
caption = _caption_before_table(doc, table)
|
|
if caption is None:
|
|
continue
|
|
if caption.kind == "table" and tables:
|
|
found += 1
|
|
elif caption.kind == "listing" and listings:
|
|
found += 1
|
|
return found
|
|
|
|
|
|
def _caption_page_before_table(doc, table):
|
|
try:
|
|
anchor = _uno_call(table, "Anchor")
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return None
|
|
cursor = text.createTextCursorByRange(anchor)
|
|
if not cursor.goLeft(1, False):
|
|
return None
|
|
cursor.gotoRange(anchor, False)
|
|
cursor.goLeft(1, False)
|
|
cursor.gotoStartOfParagraph(False)
|
|
return _page_at_range(doc, cursor)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _page_at_row(doc, table, row_1based):
|
|
"""Page number of one row, or None. Rows are 1-based, UNO cells are 0-based."""
|
|
row = int(row_1based) - 1
|
|
if row < 0:
|
|
return None
|
|
try:
|
|
ncols = int(table.getColumns().getCount())
|
|
except Exception:
|
|
ncols = 1
|
|
for col in range(max(1, ncols)):
|
|
try:
|
|
cell = table.getCellByPosition(col, row)
|
|
page = _page_at_range(doc, _uno_call(cell, "Start"))
|
|
if page is not None:
|
|
return int(page)
|
|
except Exception:
|
|
continue
|
|
return None
|
|
|
|
|
|
def _row_page_numbers(doc, table):
|
|
pages = []
|
|
try:
|
|
nrows = int(table.getRows().getCount())
|
|
except Exception:
|
|
return pages
|
|
for row in range(nrows):
|
|
page = None
|
|
for col in range(max(1, int(table.getColumns().getCount()))):
|
|
try:
|
|
cell = table.getCellByPosition(col, row)
|
|
page = _page_at_range(doc, _uno_call(cell, "Start"))
|
|
if page is not None:
|
|
break
|
|
except Exception:
|
|
continue
|
|
if page is None:
|
|
page = pages[-1] if pages else 1
|
|
pages.append(page)
|
|
return pages
|
|
|
|
|
|
def _table_has_header_row(table):
|
|
try:
|
|
if bool(table.getPropertyValue("RepeatHeadline")):
|
|
return True
|
|
except Exception:
|
|
pass
|
|
try:
|
|
row = table.getRows().getByIndex(0)
|
|
return bool(row.getPropertyValue("IsRepeatHeading"))
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _page_break_before_table_caption(doc, table):
|
|
try:
|
|
anchor = _uno_call(table, "Anchor")
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return False
|
|
cursor = text.createTextCursorByRange(anchor)
|
|
if not cursor.goLeft(1, False):
|
|
return False
|
|
cursor.gotoRange(anchor, False)
|
|
cursor.goLeft(1, False)
|
|
cursor.gotoStartOfParagraph(False)
|
|
info = parse_caption_text((_uno_call(cursor, "String", default="") or "").strip())
|
|
if info is None or info.is_continuation:
|
|
return False
|
|
cursor.setPropertyValue("BreakType", BREAK_PAGE_BEFORE)
|
|
cursor.setPropertyValue("ParaKeepTogether", True)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _cursor_after_element(text, elem, cursor):
|
|
"""Move *cursor* to the end of a body-text element (paragraph or table)."""
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
try:
|
|
nrows = int(elem.getRows().getCount())
|
|
ncols = int(elem.getColumns().getCount())
|
|
if nrows > 0 and ncols > 0:
|
|
cell = elem.getCellByPosition(ncols - 1, nrows - 1)
|
|
cursor.gotoRange(_uno_call(cell, "End"), False)
|
|
return True
|
|
except Exception:
|
|
pass
|
|
try:
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
cursor.gotoRange(_uno_call(elem, "Anchor"), False)
|
|
else:
|
|
cursor.gotoRange(elem, False)
|
|
cursor.collapseToEnd()
|
|
return True
|
|
except Exception:
|
|
pass
|
|
try:
|
|
cursor.gotoRange(_uno_call(elem, "Anchor"), False)
|
|
cursor.gotoEndOfParagraph(False)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _apply_caption_style(cursor, caption):
|
|
style_name = caption_style_name(caption.kind)
|
|
for name in (style_name, "Caption Table", "Caption"):
|
|
try:
|
|
cursor.setPropertyValue("ParaStyleName", name)
|
|
break
|
|
except Exception:
|
|
continue
|
|
try:
|
|
cursor.setPropertyValue("BreakType", BREAK_NONE)
|
|
cursor.setPropertyValue("ParaKeepTogether", True)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _first_table_fragment_before(doc, table):
|
|
"""Return the first table fragment before *table* (skip empty paragraphs)."""
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return None
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return None
|
|
|
|
seen = []
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable") and _is_target_table(
|
|
elem, table
|
|
):
|
|
for prev in reversed(seen):
|
|
if _supports_service(prev, "com.sun.star.text.TextTable"):
|
|
return prev
|
|
if _supports_service(prev, "com.sun.star.text.Paragraph"):
|
|
para_text = _element_text(prev)
|
|
if not para_text:
|
|
continue
|
|
info = parse_caption_text(para_text)
|
|
if info is not None and not info.is_continuation:
|
|
return None
|
|
return None
|
|
seen.append(elem)
|
|
return None
|
|
|
|
|
|
def _write_continuation_paragraph(text, paragraph, label, caption):
|
|
"""Fill or replace a body paragraph with a continuation caption."""
|
|
start = _uno_call(paragraph, "Start")
|
|
end = _uno_call(paragraph, "End")
|
|
cursor = text.createTextCursorByRange(start)
|
|
cursor.gotoRange(end, True)
|
|
cursor.setString(label)
|
|
_apply_caption_style(cursor, caption)
|
|
|
|
|
|
def _insert_paragraph_before_table(uno, ctx, doc, table, label, caption):
|
|
"""Insert a caption paragraph before *table* via dispatch (anchor range is often invalid)."""
|
|
try:
|
|
cell = table.getCellByPosition(0, 0)
|
|
start = _uno_call(cell, "Start")
|
|
except Exception as exc:
|
|
raise RuntimeError("cannot reach continuation table cell: {0}".format(exc))
|
|
|
|
controller = _document_controller(doc)
|
|
if controller is None:
|
|
raise RuntimeError("no document controller")
|
|
view_cursor = _uno_call(controller, "ViewCursor")
|
|
view_cursor.gotoRange(start, False)
|
|
_dispatch(uno, ctx, doc, ".uno:InsertPara", ())
|
|
try:
|
|
view_cursor.goLeft(1, False)
|
|
except Exception:
|
|
pass
|
|
view_cursor.setString(label)
|
|
_apply_caption_style(view_cursor, caption)
|
|
|
|
|
|
def _insert_continuation_at(doc, prev_elem, cont_table, label, caption, uno=None, ctx=None):
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
raise RuntimeError("no document text")
|
|
if prev_elem is None:
|
|
raise RuntimeError("continuation table at document start")
|
|
|
|
if _supports_service(prev_elem, "com.sun.star.text.Paragraph"):
|
|
prev_text = _element_text(prev_elem)
|
|
if prev_text.strip():
|
|
info = parse_caption_text(prev_text)
|
|
if info is not None and info.is_continuation:
|
|
return
|
|
raise RuntimeError("non-empty paragraph before continuation table")
|
|
_write_continuation_paragraph(text, prev_elem, label, caption)
|
|
return
|
|
if _supports_service(prev_elem, "com.sun.star.text.TextTable"):
|
|
if uno is None or ctx is None:
|
|
raise RuntimeError("dispatch insert requires UNO context")
|
|
_insert_paragraph_before_table(uno, ctx, doc, cont_table, label, caption)
|
|
return
|
|
raise RuntimeError("unsupported block before continuation table")
|
|
|
|
|
|
def _insert_continuation_after_fragment(doc, first_table, caption, uno=None, ctx=None):
|
|
"""Insert «Продолжение…» before the table fragment that follows *first_table*."""
|
|
label = continuation_label(caption.kind, caption.number)
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
raise RuntimeError("no document text")
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception as exc:
|
|
raise RuntimeError("cannot enumerate body text: {0}".format(exc))
|
|
|
|
prev_elem = None
|
|
seen_first = False
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
if seen_first:
|
|
return _insert_continuation_at(
|
|
doc, prev_elem, elem, label, caption, uno, ctx
|
|
)
|
|
if _is_target_table(elem, first_table):
|
|
seen_first = True
|
|
prev_elem = elem
|
|
continue
|
|
prev_elem = elem
|
|
raise RuntimeError("continuation fragment not found after split")
|
|
|
|
|
|
def _insert_continuation_before(doc, table, caption, uno=None, ctx=None):
|
|
"""Insert «Продолжение…» before an already-split continuation fragment."""
|
|
label = continuation_label(caption.kind, caption.number)
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
raise RuntimeError("no document text")
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception as exc:
|
|
raise RuntimeError("cannot enumerate body text: {0}".format(exc))
|
|
|
|
prev_elem = None
|
|
match = None
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
if elem == table:
|
|
match = (prev_elem, elem)
|
|
elif match is None and _same_text_table(elem, table):
|
|
match = (prev_elem, elem)
|
|
prev_elem = elem
|
|
continue
|
|
prev_elem = elem
|
|
if match is None:
|
|
raise RuntimeError("continuation table not found in body text")
|
|
prev_elem, cont_table = match
|
|
if not _needs_continuation_caption(doc, cont_table):
|
|
return
|
|
return _insert_continuation_at(
|
|
doc, prev_elem, cont_table, label, caption, uno, ctx
|
|
)
|
|
|
|
|
|
def _needs_continuation_caption(doc, cont_table):
|
|
prev_elem = _prev_body_element_before_table(doc, cont_table)
|
|
if prev_elem is None:
|
|
return False
|
|
if _supports_service(prev_elem, "com.sun.star.text.TextTable"):
|
|
return True
|
|
if _supports_service(prev_elem, "com.sun.star.text.Paragraph"):
|
|
prev_text = _element_text(prev_elem)
|
|
if not prev_text.strip():
|
|
return True
|
|
info = parse_caption_text(prev_text)
|
|
return info is None or not info.is_continuation
|
|
return True
|
|
|
|
|
|
def _has_continuation_before_table(doc, cont_table):
|
|
return not _needs_continuation_caption(doc, cont_table)
|
|
|
|
|
|
def _repair_split_table_borders(doc, tables, listings, details):
|
|
"""Clear bottom borders on first fragments of already-split tables."""
|
|
if not tables:
|
|
return 0
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return 0
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return 0
|
|
|
|
fixed = 0
|
|
last_table = None
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
if last_table is not None and _has_continuation_before_table(doc, elem):
|
|
caption = _caption_for_split(doc, elem) or _caption_before_table(
|
|
doc, last_table
|
|
)
|
|
if caption is not None and caption.kind == "table":
|
|
try:
|
|
_clear_table_bottom_border(last_table)
|
|
fixed += 1
|
|
details.append(
|
|
"repair: clear bottom border table {0}".format(
|
|
caption.number
|
|
)
|
|
)
|
|
except Exception as exc:
|
|
details.append(
|
|
"skip: repair bottom border table {0}: {1}".format(
|
|
caption.number, exc
|
|
)
|
|
)
|
|
last_table = elem
|
|
continue
|
|
|
|
if _supports_service(elem, "com.sun.star.text.Paragraph"):
|
|
para_text = _element_text(elem)
|
|
if not para_text:
|
|
continue
|
|
info = parse_caption_text(para_text)
|
|
if info is not None and not info.is_continuation:
|
|
last_table = None
|
|
return fixed
|
|
|
|
|
|
def _repair_missing_continuations(doc, uno, ctx, tables, listings, details):
|
|
"""Insert captions between already-split table pairs (re-run after failed insert)."""
|
|
text = _document_text(doc)
|
|
if text is None:
|
|
return 0
|
|
try:
|
|
enum = text.createEnumeration()
|
|
except Exception:
|
|
return 0
|
|
|
|
repaired = 0
|
|
last_table = None
|
|
while enum.hasMoreElements():
|
|
elem = enum.nextElement()
|
|
if _supports_service(elem, "com.sun.star.text.TextTable"):
|
|
if last_table is not None and _needs_continuation_caption(doc, elem):
|
|
caption = _caption_for_split(doc, elem)
|
|
if caption is not None:
|
|
if caption.kind == "table" and not tables:
|
|
caption = None
|
|
elif caption.kind == "listing" and not listings:
|
|
caption = None
|
|
if caption is not None:
|
|
try:
|
|
_insert_continuation_before(doc, elem, caption, uno, ctx)
|
|
repaired += 1
|
|
details.append(
|
|
"repair: {0} {1} continuation caption".format(
|
|
caption.kind, caption.number
|
|
)
|
|
)
|
|
except Exception as exc:
|
|
details.append(
|
|
"skip: repair continuation {0} {1}: {2}".format(
|
|
caption.kind, caption.number, exc
|
|
)
|
|
)
|
|
last_table = elem
|
|
continue
|
|
|
|
if _supports_service(elem, "com.sun.star.text.Paragraph"):
|
|
para_text = _element_text(elem)
|
|
if not para_text:
|
|
continue
|
|
info = parse_caption_text(para_text)
|
|
if info is not None and not info.is_continuation:
|
|
last_table = None
|
|
return repaired
|
|
|
|
|
|
def _refresh_table_layout(doc, table):
|
|
"""Touch each row so LO recalculates page numbers after SplitTable."""
|
|
controller = _document_controller(doc)
|
|
if controller is None:
|
|
return
|
|
try:
|
|
view_cursor = _uno_call(controller, "ViewCursor")
|
|
except Exception:
|
|
return
|
|
try:
|
|
nrows = int(table.getRows().getCount())
|
|
ncols = max(1, int(table.getColumns().getCount()))
|
|
except Exception:
|
|
return
|
|
for row in range(nrows):
|
|
try:
|
|
cell = table.getCellByPosition(0, row)
|
|
view_cursor.gotoRange(_uno_call(cell, "Start"), False)
|
|
_view_cursor_page(view_cursor)
|
|
except Exception:
|
|
continue
|
|
|
|
|
|
def _split_table_at_row(uno, ctx, doc, table, break_at_1based):
|
|
from com.sun.star.beans import PropertyValue
|
|
|
|
# Match Word ``SplitBeforeRow``: split before 1-based *break_at_1based*.
|
|
row_0based = break_at_1based - 1
|
|
if row_0based < 1:
|
|
return False
|
|
try:
|
|
cell = table.getCellByPosition(0, row_0based)
|
|
except Exception:
|
|
return False
|
|
controller = _document_controller(doc)
|
|
if controller is None:
|
|
return False
|
|
view_cursor = _uno_call(controller, "ViewCursor")
|
|
view_cursor.gotoRange(_uno_call(cell, "Start"), False)
|
|
arg = PropertyValue("Type", 0, 3, 0)
|
|
_dispatch(uno, ctx, doc, ".uno:SplitTable", (arg,))
|
|
return True
|
|
|
|
|
|
def _border_line_style_none():
|
|
try:
|
|
from com.sun.star.table import BorderLineStyle
|
|
|
|
return BorderLineStyle.NONE
|
|
except Exception:
|
|
return 32767
|
|
|
|
|
|
def _none_border_line():
|
|
"""BorderLine2 with LineStyle NONE (matches Word wdLineStyleNone for DOCX export)."""
|
|
try:
|
|
from com.sun.star.table import BorderLine2
|
|
|
|
border = BorderLine2()
|
|
except Exception:
|
|
import uno
|
|
|
|
border = uno.createUnoStruct("com.sun.star.table.BorderLine2")
|
|
border.LineStyle = _border_line_style_none()
|
|
border.LineWidth = 0
|
|
border.OuterLineWidth = 0
|
|
border.InnerLineWidth = 0
|
|
border.LineDistance = 0
|
|
return border
|
|
|
|
|
|
def _clear_border_line(border):
|
|
try:
|
|
border.LineStyle = _border_line_style_none()
|
|
except Exception:
|
|
pass
|
|
border.LineWidth = 0
|
|
border.OuterLineWidth = 0
|
|
border.InnerLineWidth = 0
|
|
border.LineDistance = 0
|
|
return border
|
|
|
|
|
|
def _clear_table_bottom_border(table):
|
|
"""Remove the visible bottom edge of a table fragment (LO keeps it on last-row cells)."""
|
|
touched = False
|
|
|
|
try:
|
|
nrows = int(table.getRows().getCount())
|
|
ncols = int(table.getColumns().getCount())
|
|
except Exception:
|
|
nrows = 0
|
|
ncols = 0
|
|
|
|
if nrows > 0 and ncols > 0:
|
|
last_row = nrows - 1
|
|
try:
|
|
row = table.getRows().getByIndex(last_row)
|
|
row.setPropertyValue("BottomBorder", _none_border_line())
|
|
touched = True
|
|
except Exception:
|
|
pass
|
|
for col in range(ncols):
|
|
try:
|
|
cell = table.getCellByPosition(col, last_row)
|
|
cell.setPropertyValue("BottomBorder", _none_border_line())
|
|
touched = True
|
|
except Exception:
|
|
continue
|
|
|
|
for prop in ("BottomBorder",):
|
|
try:
|
|
border = table.getPropertyValue(prop)
|
|
table.setPropertyValue(prop, _clear_border_line(border))
|
|
touched = True
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
table_border = table.getPropertyValue("TableBorder")
|
|
table_border.BottomLine = _clear_border_line(table_border.BottomLine)
|
|
table.setPropertyValue("TableBorder", table_border)
|
|
touched = True
|
|
except Exception:
|
|
pass
|
|
|
|
if not touched:
|
|
raise RuntimeError("no bottom border property accessible")
|
|
|
|
|
|
def _apply_listing_box_borders(table):
|
|
for edge in ("TopBorder", "BottomBorder", "LeftBorder", "RightBorder"):
|
|
try:
|
|
border = table.getPropertyValue(edge)
|
|
border.LineWidth = 1
|
|
table.setPropertyValue(edge, border)
|
|
except Exception:
|
|
pass
|
|
for edge in ("HBorder", "VBorder"):
|
|
try:
|
|
border = table.getPropertyValue(edge)
|
|
border.LineWidth = 0
|
|
table.setPropertyValue(edge, border)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _copy_header_to_continuation(first_table, cont_table):
|
|
try:
|
|
src_row = first_table.getRows().getByIndex(0)
|
|
rows = cont_table.getRows()
|
|
if int(rows.getCount()) < 1:
|
|
return
|
|
try:
|
|
if bool(rows.getByIndex(0).getPropertyValue("IsRepeatHeading")):
|
|
return
|
|
except Exception:
|
|
pass
|
|
rows.insertByIndex(0, 1)
|
|
new_row = rows.getByIndex(0)
|
|
ncols = int(cont_table.getColumns().getCount())
|
|
for col in range(ncols):
|
|
try:
|
|
src_cell = src_row.getCellByPosition(col)
|
|
dst_cell = new_row.getCellByPosition(col)
|
|
dst_cell.setString((src_cell.getString() or "").strip())
|
|
except Exception:
|
|
continue
|
|
try:
|
|
new_row.setPropertyValue("IsRepeatHeading", True)
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _fix_pass(uno, ctx, doc, tables, listings, repeat_header, details, start_page=1):
|
|
"""Split the first crossing table. Returns (made, cut_page)."""
|
|
made = 0
|
|
cut_page = None
|
|
try:
|
|
start_page = int(start_page)
|
|
except (TypeError, ValueError):
|
|
start_page = 1
|
|
body_tables = _body_tables(doc)
|
|
for table in body_tables:
|
|
caption = _caption_for_split(doc, table)
|
|
if caption is None:
|
|
continue
|
|
if caption.kind == "table" and not tables:
|
|
continue
|
|
if caption.kind == "listing" and not listings:
|
|
continue
|
|
|
|
try:
|
|
row_count = int(table.getRows().getCount())
|
|
except Exception:
|
|
continue
|
|
if start_page > 1 and row_count > 0:
|
|
last_page = _page_at_row(doc, table, row_count)
|
|
if last_page is not None and last_page < start_page:
|
|
continue
|
|
|
|
first_page = _page_at_row(doc, table, 1) if row_count else None
|
|
if caption.kind == "table" and first_page is not None and not caption.is_continuation:
|
|
if is_caption_orphaned(_caption_page_before_table(doc, table), first_page):
|
|
try:
|
|
if _page_break_before_table_caption(doc, table):
|
|
details.append(
|
|
"orphan-caption: {0} {1} -> page break before caption".format(
|
|
caption.kind, caption.number
|
|
)
|
|
)
|
|
_repaginate(uno, ctx, doc)
|
|
else:
|
|
details.append(
|
|
"skip: orphan-caption {0} {1}: no caption para".format(
|
|
caption.kind, caption.number
|
|
)
|
|
)
|
|
except Exception as exc:
|
|
details.append("skip: orphan-caption page break: {0}".format(exc))
|
|
continue
|
|
|
|
break_at, cut_page = locate_break_row(
|
|
row_count,
|
|
lambda row, current=table: _page_at_row(doc, current, row),
|
|
start_page,
|
|
)
|
|
if break_at is None:
|
|
continue
|
|
if break_at > row_count:
|
|
continue
|
|
|
|
had_header = _table_has_header_row(table)
|
|
if is_orphan_header_break(break_at, had_header):
|
|
try:
|
|
if _page_break_before_table_caption(doc, table):
|
|
details.append(
|
|
"orphan-header: {0} {1} -> page break before caption".format(
|
|
caption.kind, caption.number
|
|
)
|
|
)
|
|
_repaginate(uno, ctx, doc)
|
|
else:
|
|
details.append(
|
|
"skip: orphan-header {0} {1}: no caption para".format(
|
|
caption.kind, caption.number
|
|
)
|
|
)
|
|
except Exception as exc:
|
|
details.append("skip: orphan-header page break: {0}".format(exc))
|
|
continue
|
|
|
|
try:
|
|
if not _split_table_at_row(uno, ctx, doc, table, break_at):
|
|
details.append(
|
|
"skip: split {0} {1} row {2}: dispatch failed".format(
|
|
caption.kind, caption.number, break_at
|
|
)
|
|
)
|
|
continue
|
|
except Exception as exc:
|
|
details.append(
|
|
"skip: split {0} {1} row {2}: {3}".format(
|
|
caption.kind, caption.number, break_at, exc
|
|
)
|
|
)
|
|
continue
|
|
|
|
first_table = table
|
|
cont_table = _next_table_in_body(doc, first_table)
|
|
if cont_table is None:
|
|
details.append(
|
|
"skip: after split {0} {1}: no continuation fragment".format(
|
|
caption.kind, caption.number
|
|
)
|
|
)
|
|
made += 1
|
|
continue
|
|
|
|
try:
|
|
_insert_continuation_after_fragment(
|
|
doc, first_table, caption, uno, ctx
|
|
)
|
|
except Exception as exc:
|
|
details.append("skip: insert caption after split: {0}".format(exc))
|
|
|
|
if caption.kind == "table":
|
|
try:
|
|
_clear_table_bottom_border(first_table)
|
|
except Exception as exc:
|
|
details.append("skip: clear bottom border: {0}".format(exc))
|
|
|
|
if caption.kind == "listing":
|
|
try:
|
|
_apply_listing_box_borders(first_table)
|
|
_apply_listing_box_borders(cont_table)
|
|
except Exception as exc:
|
|
details.append("skip: listing borders: {0}".format(exc))
|
|
|
|
if repeat_header and had_header and caption.kind == "table":
|
|
try:
|
|
_copy_header_to_continuation(first_table, cont_table)
|
|
except Exception as exc:
|
|
details.append("skip: header copy: {0}".format(exc))
|
|
|
|
_refresh_table_layout(doc, first_table)
|
|
_refresh_table_layout(doc, cont_table)
|
|
_repaginate(uno, ctx, doc)
|
|
_ensure_pagination(uno, ctx, doc)
|
|
made += 1
|
|
details.append(
|
|
"split: {0} {1} @row {2}".format(caption.kind, caption.number, break_at)
|
|
)
|
|
return made, cut_page
|
|
|
|
return made, cut_page
|
|
|
|
|
|
def run_worker(port, path, engine, tables, listings, repeat_header):
|
|
label = "LibreOffice" if engine == "libre" else "OpenOffice"
|
|
uno, ctx = _connect(port)
|
|
doc = _load_document(uno, ctx, path, engine)
|
|
splits = 0
|
|
details = []
|
|
odt_temp = None
|
|
try:
|
|
_ensure_pagination(uno, ctx, doc)
|
|
repaired = _repair_missing_continuations(
|
|
doc, uno, ctx, tables, listings, details
|
|
)
|
|
_repair_split_table_borders(doc, tables, listings, details)
|
|
targets = _count_split_targets(doc, tables, listings)
|
|
passes_done = 0
|
|
start_page = 1
|
|
while passes_done < continuation_pass_limit(targets, splits):
|
|
if passes_done >= PASS_SAFETY_CAP:
|
|
details.append("skip: pass safety cap")
|
|
break
|
|
_ensure_pagination(uno, ctx, doc)
|
|
made, cut_page = _fix_pass(
|
|
uno, ctx, doc, tables, listings, repeat_header, details, start_page
|
|
)
|
|
passes_done += 1
|
|
if made == 0:
|
|
if start_page > 1:
|
|
start_page = 1
|
|
details.append("recheck: from page 1")
|
|
continue
|
|
break
|
|
splits += made
|
|
if cut_page:
|
|
start_page = resume_page_before_cut(cut_page)
|
|
details.append(
|
|
"resume: page {0} after cut at {1}".format(start_page, cut_page)
|
|
)
|
|
doc = _reload_document(uno, ctx, doc, path, engine)
|
|
_ensure_pagination(uno, ctx, doc)
|
|
repaired += _repair_missing_continuations(
|
|
doc, uno, ctx, tables, listings, details
|
|
)
|
|
if splits == 0 and repaired == 0:
|
|
_diagnose_pagination(doc, details)
|
|
elif repaired:
|
|
_ensure_pagination(uno, ctx, doc)
|
|
odt_temp = _save_document(uno, doc, path, engine)
|
|
finally:
|
|
try:
|
|
doc.close(True)
|
|
except Exception:
|
|
pass
|
|
try:
|
|
smgr = ctx.ServiceManager
|
|
desktop = smgr.createInstanceWithContext(
|
|
"com.sun.star.frame.Desktop", ctx
|
|
)
|
|
desktop.terminate()
|
|
except Exception:
|
|
pass
|
|
|
|
skipped = sum(1 for line in details if line.startswith("skip:"))
|
|
repaired = sum(1 for line in details if line.startswith("repair:"))
|
|
msg = "Пост-разрыв {0}: разрезов {1}".format(label, splits)
|
|
if repaired:
|
|
msg += ", подписей {0}".format(repaired)
|
|
if skipped:
|
|
msg += ", пропусков {0}".format(skipped)
|
|
msg += "."
|
|
result = {
|
|
"ok": True,
|
|
"splits": splits,
|
|
"skipped": skipped,
|
|
"message": msg,
|
|
"details": details,
|
|
}
|
|
if odt_temp:
|
|
result["odt_temp"] = odt_temp
|
|
return result
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="md2gost UNO table split worker")
|
|
parser.add_argument("--port", type=int, required=True)
|
|
parser.add_argument("--path", required=True)
|
|
parser.add_argument("--engine", choices=("libre", "openoffice"), default="libre")
|
|
parser.add_argument("--tables", choices=("0", "1"), default="1")
|
|
parser.add_argument("--listings", choices=("0", "1"), default="1")
|
|
parser.add_argument("--repeat-header", choices=("0", "1"), default="0")
|
|
args = parser.parse_args()
|
|
doc_path = _fs_path(args.path)
|
|
try:
|
|
result = run_worker(
|
|
args.port,
|
|
doc_path,
|
|
args.engine,
|
|
args.tables == "1",
|
|
args.listings == "1",
|
|
args.repeat_header == "1",
|
|
)
|
|
_emit_result(result)
|
|
return 0
|
|
except Exception as exc:
|
|
label = "LibreOffice" if args.engine == "libre" else "OpenOffice"
|
|
_emit_result(
|
|
{
|
|
"ok": False,
|
|
"splits": 0,
|
|
"skipped": 0,
|
|
"message": "Пост-разрыв ({0}) не удался: {1}".format(
|
|
label, _format_exc(exc)
|
|
),
|
|
"details": [],
|
|
}
|
|
)
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|