skdconv 1.0.2__py3-none-any.whl

skdconv/__init__.py

@@ -0,0 +1,105 @@
+"""skdconv — 한국 공문서를 마크다운으로 변환하는 파서 라이브러리."""
+
+from .types import (
+    IRBlock,
+    IRCell,
+    IRTable,
+    CellContext,
+    ParseResult,
+    ParseSuccess,
+    ParseFailure,
+    ParseOptions,
+    DocumentMetadata,
+    ParseWarning,
+    OutlineItem,
+    ExtractedImage,
+    FileType,
+    InternalParseResult,
+)
+from .utils import KordocError, VERSION
+from .detect import detect_format, detect_zip_format, detect_ole2_format
+
+__version__ = VERSION
+
+
+def parse(data: bytes, options: "ParseOptions | None" = None) -> ParseResult:
+    """포맷 자동 감지 후 파싱 → ParseResult."""
+    from .utils import classify_error
+
+    if not data:
+        return ParseFailure(file_type="unknown", error="입력 데이터가 비어 있습니다", code="EMPTY_INPUT")
+
+    fmt = detect_format(data)
+    # ZIP/OLE2 내부 구조로 세분화
+    if fmt == "hwpx":
+        refined = detect_zip_format(data)
+        if refined in ("xlsx", "docx", "hwpx"):
+            fmt = refined
+    elif fmt == "hwp":
+        refined = detect_ole2_format(data)
+        if refined in ("hwp", "xls"):
+            fmt = refined
+
+    try:
+        result: InternalParseResult
+        if fmt == "hwpx":
+            from .hwpx.parser import parse_hwpx_document
+            result = parse_hwpx_document(data, options)
+        elif fmt == "hwp":
+            from .hwp5.parser import parse_hwp5_document
+            result = parse_hwp5_document(data, options)
+        elif fmt == "hwp3":
+            from .hwp3.parser import parse_hwp3_document
+            result = parse_hwp3_document(data, options)
+        elif fmt == "hwpml":
+            from .hwpml.parser import parse_hwpml_document
+            result = parse_hwpml_document(data, options)
+        elif fmt == "xlsx":
+            from .xlsx.parser import parse_xlsx_document
+            result = parse_xlsx_document(data, options)
+        elif fmt == "xls":
+            from .xls.parser import parse_xls_document
+            result = parse_xls_document(data, options)
+        elif fmt == "docx":
+            from .docx.parser import parse_docx_document
+            result = parse_docx_document(data, options)
+        else:
+            return ParseFailure(file_type=fmt, error=f"지원하지 않는 포맷: {fmt}", code="UNSUPPORTED_FORMAT")
+
+        md = result.metadata
+        return ParseSuccess(
+            file_type=fmt,
+            markdown=result.markdown,
+            blocks=result.blocks,
+            page_count=md.page_count if md else None,
+            metadata=md,
+            outline=result.outline,
+            warnings=result.warnings,
+            images=result.images,
+        )
+    except Exception as e:
+        code = classify_error(e)
+        return ParseFailure(file_type=fmt, error=str(e), code=code)
+
+
+__all__ = [
+    "IRBlock",
+    "IRCell",
+    "IRTable",
+    "CellContext",
+    "ParseResult",
+    "ParseSuccess",
+    "ParseFailure",
+    "ParseOptions",
+    "DocumentMetadata",
+    "ParseWarning",
+    "OutlineItem",
+    "ExtractedImage",
+    "FileType",
+    "KordocError",
+    "VERSION",
+    "detect_format",
+    "detect_zip_format",
+    "detect_ole2_format",
+    "parse",
+]

skdconv/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

skdconv/cli.py

@@ -0,0 +1,152 @@
+"""skdconv CLI — 문서를 마크다운으로 변환."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .utils import VERSION
+
+
+def _parse_fields(fields_str: str) -> dict[str, str]:
+    """'key=value,key2=value2' 또는 JSON 문자열 → dict."""
+    s = fields_str.strip()
+    if s.startswith("{"):
+        return json.loads(s)
+    result: dict[str, str] = {}
+    # 쉼표+한글/영문+= 패턴으로 분리
+    import re
+    pairs = re.split(r",(?=[가-힣A-Za-z])", s)
+    for pair in pairs:
+        idx = pair.find("=")
+        if idx > 0:
+            result[pair[:idx].strip()] = pair[idx + 1:].strip()
+    return result
+
+
+def _cmd_parse(args: argparse.Namespace) -> int:
+    from . import parse
+    from .detect import detect_format
+    from .types import ParseOptions
+
+    valid_formats = {"markdown", "json"}
+    if args.format not in valid_formats:
+        sys.stderr.write(f"[skdconv] 지원하지 않는 형식: {args.format} (markdown 또는 json)\n")
+        return 1
+
+    exit_code = 0
+    files = args.files
+    for fi, file_path in enumerate(files):
+        abs_path = os.path.realpath(file_path)
+        file_name = os.path.basename(abs_path)
+        file_prefix = f"[{fi + 1}/{len(files)}] " if len(files) > 1 else ""
+
+        try:
+            file_size = os.path.getsize(abs_path)
+            if file_size > 500 * 1024 * 1024:
+                sys.stderr.write(
+                    f"\n[skdconv] SKIP: {file_name} — 파일이 너무 큽니다 "
+                    f"({file_size / 1024 / 1024:.1f}MB)\n"
+                )
+                exit_code = 1
+                continue
+
+            with open(abs_path, "rb") as f:
+                data = f.read()
+
+            fmt = detect_format(data)
+            if not args.silent:
+                sys.stderr.write(f"[skdconv] {file_prefix}{file_name} ({fmt}) ...")
+
+            opts = ParseOptions(file_path=abs_path)
+            if args.pages:
+                opts.pages = args.pages
+            if args.no_header_footer:
+                opts.remove_header_footer = True
+
+            result = parse(data, opts)
+
+            if not result.success:
+                sys.stderr.write(" FAIL\n")
+                sys.stderr.write(f"  → {result.error}\n")
+                exit_code = 1
+                continue
+
+            if not args.silent:
+                sys.stderr.write(" OK\n")
+
+            if args.format == "json":
+                output = json.dumps(
+                    {
+                        "file_type": result.file_type,
+                        "markdown": result.markdown,
+                        "page_count": result.page_count,
+                        "warnings": [
+                            {"message": w.message, "code": w.code, "page": w.page}
+                            for w in (result.warnings or [])
+                        ],
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            else:
+                output = result.markdown
+
+            if args.output and len(files) == 1:
+                Path(args.output).write_text(output, encoding="utf-8")
+                if not args.silent:
+                    sys.stderr.write(f"  → {args.output}\n")
+            elif args.out_dir:
+                os.makedirs(args.out_dir, exist_ok=True)
+                ext = ".json" if args.format == "json" else ".md"
+                stem = os.path.splitext(file_name)[0]
+                out_path = os.path.join(args.out_dir, stem + ext)
+                Path(out_path).write_text(output, encoding="utf-8")
+                if not args.silent:
+                    sys.stderr.write(f"  → {out_path}\n")
+            else:
+                sys.stdout.write(output + "\n")
+
+        except Exception as err:
+            sys.stderr.write(f"\n[skdconv] ERROR: {file_name} — {err}\n")
+            exit_code = 1
+
+    return exit_code
+
+
+def main(argv: Optional[list[str]] = None) -> None:
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        prog="skdconv",
+        description="모두 파싱해버리겠다 - HWP, HWPX, XLSX, XLS, DOCX -> Markdown",
+    )
+    parser.add_argument("--version", action="version", version=f"skdconv {VERSION}")
+    parser.add_argument("files", nargs="*", metavar="FILE", help="변환할 파일 경로")
+    parser.add_argument("-o", "--output", metavar="PATH", help="출력 파일 경로 (단일 파일 시)")
+    parser.add_argument("-d", "--out-dir", metavar="DIR", help="출력 디렉토리 (다중 파일 시)")
+    parser.add_argument("-p", "--pages", metavar="RANGE", help="페이지/섹션 범위 (예: 1-3, 1,3,5)")
+    parser.add_argument(
+        "--format", choices=["markdown", "json"], default="markdown", help="출력 형식"
+    )
+    parser.add_argument(
+        "--no-header-footer", action="store_true", help="PDF 머리글/바닥글 자동 제거"
+    )
+    parser.add_argument("--silent", action="store_true", help="진행 메시지 숨기기")
+
+    args = parser.parse_args(argv)
+
+    if args.files:
+        sys.exit(_cmd_parse(args))
+    else:
+        parser.print_help()
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

skdconv/detect.py

@@ -0,0 +1,96 @@
+"""매직 바이트 기반 파일 포맷 감지"""
+
+from __future__ import annotations
+
+import io
+import zipfile
+from typing import Literal
+
+from .types import FileType
+
+_HWP3_PREFIX = b"HWP Document File V3.00"
+
+
+def is_zip_file(data: bytes) -> bool:
+    return len(data) >= 4 and data[:4] == b"PK\x03\x04"
+
+
+def is_hwpx_file(data: bytes) -> bool:
+    return is_zip_file(data)
+
+
+def is_old_hwp_file(data: bytes) -> bool:
+    return len(data) >= 4 and data[:4] == b"\xd0\xcf\x11\xe0"
+
+
+def is_hwp3_file(data: bytes) -> bool:
+    return len(data) >= len(_HWP3_PREFIX) and data[: len(_HWP3_PREFIX)] == _HWP3_PREFIX
+
+
+def is_pdf_file(data: bytes) -> bool:
+    return len(data) >= 4 and data[:4] == b"%PDF"
+
+
+def is_hwpml_file(data: bytes) -> bool:
+    head = data[:512].decode("utf-8", errors="replace").lstrip("")
+    return head.lstrip().startswith("<?xml") and "<HWPML" in head
+
+
+def detect_format(data: bytes) -> FileType:
+    """동기 포맷 감지 — ZIP은 모두 'hwpx'로 반환 (세분화는 detect_zip_format 사용)."""
+    if len(data) < 4:
+        return "unknown"
+    if is_hwp3_file(data):
+        return "hwp3"
+    if is_zip_file(data):
+        return "hwpx"
+    if is_old_hwp_file(data):
+        return "hwp"
+    if is_pdf_file(data):
+        return "pdf"
+    if is_hwpml_file(data):
+        return "hwpml"
+    return "unknown"
+
+
+def detect_ole2_format(data: bytes) -> Literal["hwp", "xls", "unknown"]:
+    """OLE2 컨테이너 내부 스트림 기반 포맷 세분화.
+
+    HWP 5.x, XLS 모두 OLE2이므로 스트림 이름으로 구분.
+    """
+    try:
+        import olefile  # type: ignore
+
+        with olefile.OleFileIO(io.BytesIO(data)) as ole:
+            entries = {e[0] for e in ole.listdir()}
+            if "Workbook" in entries or "Book" in entries:
+                return "xls"
+            if "FileHeader" in entries:
+                return "hwp"
+            if any(e == "DocInfo" or e.startswith("Section") for e in entries):
+                return "hwp"
+        return "unknown"
+    except Exception:
+        return "unknown"
+
+
+def detect_zip_format(data: bytes) -> Literal["hwpx", "xlsx", "docx", "unknown"]:
+    """ZIP 내부 구조 기반 포맷 세분화.
+
+    HWPX, XLSX, DOCX 모두 ZIP이므로 내부 파일로 구분.
+    """
+    try:
+        with zipfile.ZipFile(io.BytesIO(data)) as zf:
+            names = zf.namelist()
+            name_set = set(names)
+            if "xl/workbook.xml" in name_set:
+                return "xlsx"
+            if "word/document.xml" in name_set:
+                return "docx"
+            if "Contents/content.hpf" in name_set or "mimetype" in name_set:
+                return "hwpx"
+            if any(n.startswith("Contents/") for n in names):
+                return "hwpx"
+        return "unknown"
+    except Exception:
+        return "unknown"

skdconv/docx/equation.py

@@ -0,0 +1,119 @@
+"""DOCX OMML (Office Math ML) → LaTeX 변환 — 간략 구현."""
+
+from __future__ import annotations
+
+import lxml.etree as ET
+
+
+def _tag(el: ET._Element) -> str:
+    t = el.tag
+    return t.split("}", 1)[1] if "}" in t else t
+
+
+def _kids(parent: ET._Element, name: str) -> list[ET._Element]:
+    return [child for child in parent if _tag(child) == name]
+
+
+def _first_kid(parent: ET._Element, name: str) -> ET._Element | None:
+    for child in parent:
+        if _tag(child) == name:
+            return child
+    return None
+
+
+def _run_to_latex(r: ET._Element) -> str:
+    return "".join(t.text or "" for t in _kids(r, "t"))
+
+
+_FUNC_NAMES = {
+    "sin", "cos", "tan", "cot", "sec", "csc",
+    "sinh", "cosh", "tanh", "coth",
+    "arcsin", "arccos", "arctan",
+    "log", "ln", "lg", "exp",
+    "det", "dim", "gcd", "inf", "sup", "lim", "max", "min",
+    "Pr", "arg",
+}
+
+
+def _el_to_latex(el: ET._Element) -> str:
+    tag = _tag(el)
+
+    if tag in ("oMath", "oMathPara"):
+        return "".join(_el_to_latex(c) for c in el)
+
+    if tag == "r":
+        return _run_to_latex(el)
+
+    if tag == "f":  # 분수
+        num = _first_kid(el, "num")
+        den = _first_kid(el, "den")
+        n = "".join(_el_to_latex(c) for c in num) if num is not None else ""
+        d = "".join(_el_to_latex(c) for c in den) if den is not None else ""
+        return f"\\frac{{{n}}}{{{d}}}"
+
+    if tag == "rad":  # 근호
+        deg = _first_kid(el, "deg")
+        e = _first_kid(el, "e")
+        body = "".join(_el_to_latex(c) for c in e) if e is not None else ""
+        if deg is not None:
+            d = "".join(_el_to_latex(c) for c in deg)
+            if d:
+                return f"\\sqrt[{d}]{{{body}}}"
+        return f"\\sqrt{{{body}}}"
+
+    if tag == "sSup":  # 위첨자
+        e = _first_kid(el, "e")
+        sup = _first_kid(el, "sup")
+        base = "".join(_el_to_latex(c) for c in e) if e is not None else ""
+        exp = "".join(_el_to_latex(c) for c in sup) if sup is not None else ""
+        return f"{{{base}}}^{{{exp}}}"
+
+    if tag == "sSub":  # 아래첨자
+        e = _first_kid(el, "e")
+        sub = _first_kid(el, "sub")
+        base = "".join(_el_to_latex(c) for c in e) if e is not None else ""
+        s = "".join(_el_to_latex(c) for c in sub) if sub is not None else ""
+        return f"{{{base}}}_{{{s}}}"
+
+    if tag == "sSubSup":  # 위아래첨자
+        e = _first_kid(el, "e")
+        sub = _first_kid(el, "sub")
+        sup = _first_kid(el, "sup")
+        base = "".join(_el_to_latex(c) for c in e) if e is not None else ""
+        s = "".join(_el_to_latex(c) for c in sub) if sub is not None else ""
+        p = "".join(_el_to_latex(c) for c in sup) if sup is not None else ""
+        return f"{{{base}}}_{{{s}}}^{{{p}}}"
+
+    if tag == "nary":  # 연산자 (∑, ∏, ∫ 등)
+        e = _first_kid(el, "e")
+        body = "".join(_el_to_latex(c) for c in e) if e is not None else ""
+        return f"\\sum {body}"
+
+    if tag == "d":  # 괄호
+        e_els = _kids(el, "e")
+        content = " ".join("".join(_el_to_latex(c) for c in e) for e in e_els)
+        return f"\\left({content}\\right)"
+
+    if tag == "m":  # 행렬
+        mr_els = _kids(el, "mr")
+        rows = []
+        for mr in mr_els:
+            e_els = _kids(mr, "e")
+            rows.append(" & ".join("".join(_el_to_latex(c) for c in e) for e in e_els))
+        return "\\begin{matrix}" + " \\\\ ".join(rows) + "\\end{matrix}"
+
+    # 기타 — 자식 재귀
+    return "".join(_el_to_latex(c) for c in el)
+
+
+def omml_element_to_latex(el: ET._Element) -> str:
+    """<m:oMath> 또는 <m:oMathPara> 엘리먼트를 LaTeX 문자열로 변환."""
+    try:
+        return _el_to_latex(el).strip()
+    except Exception:
+        return ""
+
+
+def is_display_math(el: ET._Element) -> bool:
+    """oMathPara이면 display math ($$...$$)."""
+    return _tag(el) == "oMathPara"