pdfprep 0.1.0__py3-none-any.whl

pdfprep/__init__.py

@@ -0,0 +1,15 @@
+"""
+pdfprep — PDF 전처리 도구 모음
+
+서브모듈:
+    metadata  : PDF 메타데이터 추출
+    parsing   : 3종 라이브러리(pypdf / pdfplumber / pymupdf)로 텍스트 파싱
+    ocr       : 2종 OCR 엔진(tesseract / paddleocr)으로 이미지 텍스트 추출
+    table     : 3종 라이브러리(camelot / tabula / layoutparser)로 표 추출
+"""
+
+__version__ = "0.1.0"
+
+from . import metadata, parsing, ocr, table
+
+__all__ = ["metadata", "parsing", "ocr", "table", "__version__"]

pdfprep/metadata.py

@@ -0,0 +1,64 @@
+import sys
+from pypdf import PdfReader
+from pathlib import Path
+from datetime import datetime
+
+
+def parse_pdf_date(date_str):
+    if not date_str:
+        return None
+    s = str(date_str)
+    if s.startswith("D:"):
+        s = s[2:]
+    try:
+        return datetime.strptime(s[:14], "%Y%m%d%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
+    except ValueError:
+        return str(date_str)
+
+
+def show_pdf_metadata(pdf_path):
+    path = Path(pdf_path)
+    if not path.exists():
+        print(f"파일을 찾을 수 없습니다: {pdf_path}")
+        return
+
+    reader = PdfReader(str(path))
+    meta = reader.metadata or {}
+
+    print(f"=== PDF 메타데이터: {path.name} ===")
+    print(f"파일 크기      : {path.stat().st_size:,} bytes")
+    print(f"페이지 수      : {len(reader.pages)}")
+    print(f"PDF 버전       : {reader.pdf_header}")
+    print(f"암호화 여부    : {reader.is_encrypted}")
+    print()
+    print("--- Document Info ---")
+    print(f"제목(Title)    : {meta.get('/Title', '')}")
+    print(f"작성자(Author) : {meta.get('/Author', '')}")
+    print(f"주제(Subject)  : {meta.get('/Subject', '')}")
+    print(f"키워드(Keywords): {meta.get('/Keywords', '')}")
+    print(f"생성 도구      : {meta.get('/Creator', '')}")
+    print(f"생성기(Producer): {meta.get('/Producer', '')}")
+    print(f"생성일         : {parse_pdf_date(meta.get('/CreationDate'))}")
+    print(f"수정일         : {parse_pdf_date(meta.get('/ModDate'))}")
+
+    extras = {k: v for k, v in meta.items() if k not in {
+        "/Title", "/Author", "/Subject", "/Keywords",
+        "/Creator", "/Producer", "/CreationDate", "/ModDate",
+    }}
+    if extras:
+        print()
+        print("--- 기타 항목 ---")
+        for k, v in extras.items():
+            print(f"{k}: {v}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("사용법: python3 pdf_metadata.py <PDF 파일 경로> [추가 파일 ...]")
+        print("예시 : python3 pdf_metadata.py pdf_sample.pdf")
+        sys.exit(1)
+
+    for i, pdf_path in enumerate(sys.argv[1:]):
+        if i > 0:
+            print()
+        show_pdf_metadata(pdf_path)

pdfprep/ocr.py

@@ -0,0 +1,196 @@
+import sys
+import io
+from pathlib import Path
+
+OCR_ENGINES = ("tesseract", "paddleocr")
+
+
+def pdf_to_images(pdf_path, dpi=200):
+    """
+    pymupdf로 PDF 각 페이지를 PIL Image로 렌더링.
+    """
+    import fitz
+    from PIL import Image
+
+    images = []
+    with fitz.open(str(pdf_path)) as doc:
+        zoom = dpi / 72
+        mat = fitz.Matrix(zoom, zoom)
+        for page in doc:
+            pix = page.get_pixmap(matrix=mat, alpha=False)
+            img = Image.open(io.BytesIO(pix.tobytes("png"))).convert("RGB")
+            images.append(img)
+    return images
+
+
+def ocr_with_tesseract(pdf_path, lang="kor+eng", dpi=200):
+    """
+    pytesseract — Google Tesseract 래퍼.
+    빠르고 가벼우며, 한국어/영어 traineddata 설치 필요.
+    """
+    import pytesseract
+
+    images = pdf_to_images(pdf_path, dpi=dpi)
+    pages = []
+    confidences = []
+    word_count = 0
+    for img in images:
+        text = pytesseract.image_to_string(img, lang=lang)
+        pages.append(text)
+
+        data = pytesseract.image_to_data(img, lang=lang, output_type=pytesseract.Output.DICT)
+        valid_words = [
+            (w, int(c))
+            for w, c in zip(data.get("text", []), data.get("conf", []))
+            if w.strip() and str(c) not in ("-1", "")
+        ]
+        word_count += len(valid_words)
+        confidences.extend(c for _, c in valid_words)
+
+    avg_conf = sum(confidences) / len(confidences) if confidences else 0
+    features = {
+        "사용 언어": lang,
+        "렌더링 DPI": dpi,
+        "인식 단어 수": word_count,
+        "평균 신뢰도(%)": round(avg_conf, 2),
+        "최저 신뢰도(%)": min(confidences) if confidences else None,
+        "최고 신뢰도(%)": max(confidences) if confidences else None,
+    }
+
+    return {
+        "engine": "tesseract",
+        "page_count": len(pages),
+        "pages": pages,
+        "text": "\n\n".join(pages),
+        "features": features,
+    }
+
+
+def ocr_with_paddleocr(pdf_path, lang="korean", dpi=200):
+    """
+    PaddleOCR — Baidu의 딥러닝 기반 OCR.
+    검출(detection) + 인식(recognition) 단계를 거쳐 박스 + 텍스트 + 신뢰도 반환.
+    """
+    import numpy as np
+    from paddleocr import PaddleOCR
+
+    ocr = PaddleOCR(use_angle_cls=True, lang=lang, show_log=False)
+
+    images = pdf_to_images(pdf_path, dpi=dpi)
+    pages = []
+    box_count = 0
+    confidences = []
+    word_count = 0
+    for img in images:
+        arr = np.array(img)
+        results = ocr.ocr(arr, cls=True)
+        page_lines = []
+        for page_res in results:
+            if not page_res:
+                continue
+            for item in page_res:
+                # item = [box, (text, score)]
+                if not item or len(item) < 2:
+                    continue
+                text_info = item[1]
+                if not text_info:
+                    continue
+                t, s = text_info[0], text_info[1]
+                page_lines.append(t)
+                confidences.append(float(s))
+                word_count += len(t.split())
+                box_count += 1
+        pages.append("\n".join(page_lines))
+
+    avg_conf = sum(confidences) / len(confidences) if confidences else 0
+    features = {
+        "사용 언어": lang,
+        "렌더링 DPI": dpi,
+        "검출된 텍스트 박스 수": box_count,
+        "인식 단어 수": word_count,
+        "평균 신뢰도": round(avg_conf, 4),
+        "최저 신뢰도": round(min(confidences), 4) if confidences else None,
+        "최고 신뢰도": round(max(confidences), 4) if confidences else None,
+    }
+
+    return {
+        "engine": "paddleocr",
+        "page_count": len(pages),
+        "pages": pages,
+        "text": "\n\n".join(pages),
+        "features": features,
+    }
+
+
+ENGINE_MAP = {
+    "tesseract": ocr_with_tesseract,
+    "paddleocr": ocr_with_paddleocr,
+}
+
+HIGHLIGHT_KEYS = {
+    "tesseract": ("인식 단어 수", "평균 신뢰도(%)", "사용 언어"),
+    "paddleocr": ("검출된 텍스트 박스 수", "평균 신뢰도", "사용 언어"),
+}
+
+
+def ocr_pdf(pdf_path, engine="tesseract", **kwargs):
+    if engine not in ENGINE_MAP:
+        raise ValueError(f"지원하지 않는 엔진: {engine}. 사용 가능: {list(ENGINE_MAP)}")
+    path = Path(pdf_path)
+    if not path.exists():
+        raise FileNotFoundError(f"파일을 찾을 수 없습니다: {pdf_path}")
+    return ENGINE_MAP[engine](path, **kwargs)
+
+
+def _format_value(value):
+    if isinstance(value, list):
+        if not value:
+            return "[]"
+        preview = ", ".join(str(v) for v in value[:5])
+        suffix = f", ... (+{len(value) - 5})" if len(value) > 5 else ""
+        return f"[{preview}{suffix}]"
+    return str(value)
+
+
+def print_result(result, preview_chars=300):
+    print(f"=== OCR 엔진: {result['engine']} ===")
+    print(f"페이지 수      : {result.get('page_count', '-')}")
+    text = result.get("text", "")
+    print(f"전체 텍스트 길이: {len(text)}자")
+
+    features = result.get("features", {})
+    if features:
+        print()
+        print(f"--- {result['engine']} 특화 지표 ---")
+        for k, v in features.items():
+            print(f"  {k:<22}: {_format_value(v)}")
+
+    print()
+    print(f"--- OCR 결과 미리보기 (앞 {preview_chars}자) ---")
+    print(text[:preview_chars] + ("..." if len(text) > preview_chars else ""))
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("사용법: python3 ocr_pdf.py <PDF 파일> [엔진]")
+        print(f"  엔진(생략 시 전체): {', '.join(OCR_ENGINES)}")
+        print("예시 : python3 ocr_pdf.py data/pdf_sample.pdf tesseract")
+        print("       python3 ocr_pdf.py data/pdf_sample.pdf")
+        sys.exit(1)
+
+    pdf_path = sys.argv[1]
+    engines = [sys.argv[2]] if len(sys.argv) >= 3 else list(OCR_ENGINES)
+
+    for i, engine in enumerate(engines):
+        if i > 0:
+            print()
+        try:
+            result = ocr_pdf(pdf_path, engine)
+            print_result(result)
+        except Exception as e:
+            print(f"=== OCR 엔진: {engine} ===")
+            print(f"오류: {type(e).__name__}: {e}")
+
+
+if __name__ == "__main__":
+    main()

pdfprep/parsing.py

@@ -0,0 +1,254 @@
+import sys
+from pathlib import Path
+
+ENGINES = ("pypdf", "pdfplumber", "pymupdf")
+
+
+def _count_outline(items):
+    if not items:
+        return 0
+    total = 0
+    for item in items:
+        if isinstance(item, list):
+            total += _count_outline(item)
+        else:
+            total += 1
+    return total
+
+
+def parse_with_pypdf(pdf_path):
+    """
+    pypdf 강점: 문서 구조 메타정보 (목차, 폼 필드, 주석, 암호화)
+    """
+    from pypdf import PdfReader
+    reader = PdfReader(str(pdf_path))
+
+    pages_text = []
+    annotation_count = 0
+    image_count = 0
+    rotations = []
+    for page in reader.pages:
+        pages_text.append(page.extract_text() or "")
+        annots = page.get("/Annots")
+        if annots:
+            try:
+                annotation_count += len(annots)
+            except TypeError:
+                pass
+        try:
+            image_count += len(page.images)
+        except Exception:
+            pass
+        rotations.append(page.get("/Rotate", 0) or 0)
+
+    try:
+        form_fields = reader.get_form_text_fields() or {}
+    except Exception:
+        form_fields = {}
+
+    features = {
+        "목차(outline) 항목 수": _count_outline(reader.outline),
+        "폼 필드 수": len(form_fields),
+        "주석 수": annotation_count,
+        "이미지 수": image_count,
+        "암호화 여부": reader.is_encrypted,
+        "PDF 버전": reader.pdf_header,
+        "페이지 회전각": rotations,
+    }
+
+    return {
+        "engine": "pypdf",
+        "page_count": len(pages_text),
+        "pages": pages_text,
+        "text": "\n\n".join(pages_text),
+        "features": features,
+    }
+
+
+def parse_with_pdfplumber(pdf_path):
+    """
+    pdfplumber 강점: 표 추출, 문자/단어 단위 위치 정보, 도형(선/사각형)
+    """
+    import pdfplumber
+
+    pages_text = []
+    tables_per_page = []
+    char_count = 0
+    word_count = 0
+    line_count = 0
+    rect_count = 0
+    fontnames = set()
+
+    with pdfplumber.open(str(pdf_path)) as pdf:
+        for page in pdf.pages:
+            pages_text.append(page.extract_text() or "")
+            page_tables = page.extract_tables() or []
+            if page_tables:
+                tables_per_page.append({"page": page.page_number, "tables": page_tables})
+            char_count += len(page.chars or [])
+            word_count += len(page.extract_words() or [])
+            line_count += len(page.lines or [])
+            rect_count += len(page.rects or [])
+            for ch in page.chars or []:
+                fn = ch.get("fontname")
+                if fn:
+                    fontnames.add(fn)
+
+    total_tables = sum(len(entry["tables"]) for entry in tables_per_page)
+    features = {
+        "표 개수": total_tables,
+        "표가 있는 페이지": [entry["page"] for entry in tables_per_page],
+        "문자(char) 수": char_count,
+        "단어 수": word_count,
+        "선(line) 수": line_count,
+        "사각형(rect) 수": rect_count,
+        "사용 폰트 수": len(fontnames),
+        "폰트 목록": sorted(fontnames),
+    }
+
+    return {
+        "engine": "pdfplumber",
+        "page_count": len(pages_text),
+        "pages": pages_text,
+        "text": "\n\n".join(pages_text),
+        "tables": tables_per_page,
+        "features": features,
+    }
+
+
+def parse_with_pymupdf(pdf_path):
+    """
+    pymupdf 강점: 블록 구조, 이미지/링크 메타, 폰트 색·크기, 렌더링
+    """
+    import fitz
+
+    pages_text = []
+    block_count = 0
+    image_count = 0
+    link_count = 0
+    drawing_count = 0
+    font_set = set()
+    size_set = set()
+    color_set = set()
+
+    with fitz.open(str(pdf_path)) as doc:
+        toc = doc.get_toc() or []
+        metadata = doc.metadata or {}
+
+        for page in doc:
+            pages_text.append(page.get_text())
+
+            d = page.get_text("dict")
+            for block in d.get("blocks", []):
+                block_count += 1
+                for line in block.get("lines", []):
+                    for span in line.get("spans", []):
+                        font_set.add(span.get("font", ""))
+                        size_set.add(round(span.get("size", 0), 1))
+                        color_set.add(span.get("color", 0))
+
+            image_count += len(page.get_images() or [])
+            link_count += len(page.get_links() or [])
+            try:
+                drawing_count += len(page.get_drawings() or [])
+            except Exception:
+                pass
+
+    features = {
+        "블록(block) 수": block_count,
+        "이미지 수": image_count,
+        "링크 수": link_count,
+        "드로잉(도형) 수": drawing_count,
+        "사용 폰트 수": len(font_set),
+        "폰트 목록": sorted(f for f in font_set if f),
+        "사용 글자 크기": sorted(size_set),
+        "사용 색상 수": len(color_set),
+        "목차(TOC) 항목 수": len(toc),
+        "PDF Producer": metadata.get("producer", ""),
+    }
+
+    return {
+        "engine": "pymupdf",
+        "page_count": len(pages_text),
+        "pages": pages_text,
+        "text": "\n\n".join(pages_text),
+        "features": features,
+    }
+
+
+ENGINE_MAP = {
+    "pypdf": parse_with_pypdf,
+    "pdfplumber": parse_with_pdfplumber,
+    "pymupdf": parse_with_pymupdf,
+}
+
+
+# 요약 테이블에 강조해서 보여줄 "엔진별 시그니처 지표"
+HIGHLIGHT_KEYS = {
+    "pypdf":      ("목차(outline) 항목 수", "폼 필드 수", "주석 수"),
+    "pdfplumber": ("표 개수", "단어 수", "사용 폰트 수"),
+    "pymupdf":    ("블록(block) 수", "이미지 수", "사용 폰트 수"),
+}
+
+
+def parse_pdf(pdf_path, engine="pypdf"):
+    if engine not in ENGINE_MAP:
+        raise ValueError(f"지원하지 않는 엔진: {engine}. 사용 가능: {list(ENGINE_MAP)}")
+    path = Path(pdf_path)
+    if not path.exists():
+        raise FileNotFoundError(f"파일을 찾을 수 없습니다: {pdf_path}")
+    return ENGINE_MAP[engine](path)
+
+
+def _format_value(value):
+    if isinstance(value, list):
+        if not value:
+            return "[]"
+        preview = ", ".join(str(v) for v in value[:5])
+        suffix = f", ... (+{len(value) - 5})" if len(value) > 5 else ""
+        return f"[{preview}{suffix}]"
+    return str(value)
+
+
+def print_result(result, preview_chars=300):
+    print(f"=== 엔진: {result['engine']} ===")
+    print(f"페이지 수      : {result.get('page_count', '-')}")
+    text = result.get("text", "")
+    print(f"전체 텍스트 길이: {len(text)}자")
+
+    features = result.get("features", {})
+    if features:
+        print()
+        print(f"--- {result['engine']} 특화 지표 ---")
+        for k, v in features.items():
+            print(f"  {k:<22}: {_format_value(v)}")
+
+    print()
+    print(f"--- 텍스트 미리보기 (앞 {preview_chars}자) ---")
+    print(text[:preview_chars] + ("..." if len(text) > preview_chars else ""))
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("사용법: python3 parsing_pdf.py <PDF 파일> [엔진]")
+        print(f"  엔진(생략 시 전체): {', '.join(ENGINES)}")
+        print("예시 : python3 parsing_pdf.py data/pdf_sample.pdf pypdf")
+        print("       python3 parsing_pdf.py data/pdf_sample.pdf")
+        sys.exit(1)
+
+    pdf_path = sys.argv[1]
+    engines = [sys.argv[2]] if len(sys.argv) >= 3 else list(ENGINES)
+
+    for i, engine in enumerate(engines):
+        if i > 0:
+            print()
+        try:
+            result = parse_pdf(pdf_path, engine)
+            print_result(result)
+        except Exception as e:
+            print(f"=== 엔진: {engine} ===")
+            print(f"오류: {type(e).__name__}: {e}")
+
+
+if __name__ == "__main__":
+    main()

pdfprep/table.py

@@ -0,0 +1,289 @@
+import sys
+import io
+from pathlib import Path
+
+ENGINES = ("camelot", "tabula", "layoutparser")
+
+
+def _df_shape(df):
+    try:
+        return f"{df.shape[0]}행 × {df.shape[1]}열"
+    except Exception:
+        return "?"
+
+
+def _df_preview(df, max_rows=3, max_cols=4):
+    try:
+        sub = df.iloc[:max_rows, :max_cols]
+        return sub.to_string(index=False)
+    except Exception:
+        return str(df)[:200]
+
+
+def extract_with_camelot(pdf_path, flavor="lattice", pages="all"):
+    """
+    Camelot — PDF 표 추출 전용.
+    flavor="lattice"  → 선이 명확한 표 (ghostscript 필요)
+    flavor="stream"   → 선 없는 표 (좌표 기반)
+    """
+    import camelot
+
+    tables = camelot.read_pdf(str(pdf_path), flavor=flavor, pages=pages)
+    items = []
+    accuracies = []
+    whitespaces = []
+    total_rows = 0
+    total_cols = 0
+    for t in tables:
+        df = t.df
+        rows, cols = df.shape
+        total_rows += rows
+        total_cols = max(total_cols, cols)
+        report = getattr(t, "parsing_report", {}) or {}
+        if "accuracy" in report:
+            accuracies.append(float(report["accuracy"]))
+        if "whitespace" in report:
+            whitespaces.append(float(report["whitespace"]))
+        items.append({
+            "page": report.get("page"),
+            "shape": (rows, cols),
+            "accuracy": report.get("accuracy"),
+            "whitespace": report.get("whitespace"),
+            "df": df,
+        })
+
+    features = {
+        "표 개수": len(tables),
+        "flavor": flavor,
+        "각 표 모양": [t["shape"] for t in items],
+        "각 표 페이지": [t["page"] for t in items],
+        "평균 정확도(accuracy)": round(sum(accuracies) / len(accuracies), 2) if accuracies else None,
+        "평균 여백률(whitespace)": round(sum(whitespaces) / len(whitespaces), 2) if whitespaces else None,
+        "최대 열 수": total_cols,
+        "총 행 수(합)": total_rows,
+    }
+    return {
+        "engine": "camelot",
+        "table_count": len(tables),
+        "tables": items,
+        "features": features,
+    }
+
+
+def extract_with_tabula(pdf_path, pages="all"):
+    """
+    Tabula — Java 기반 tabula-java 래퍼.
+    pandas.DataFrame 리스트 반환.
+    """
+    import tabula
+
+    dfs = tabula.read_pdf(str(pdf_path), pages=pages, multiple_tables=True, lattice=True)
+    items = []
+    total_rows = 0
+    total_cols = 0
+    for i, df in enumerate(dfs, start=1):
+        rows, cols = df.shape
+        total_rows += rows
+        total_cols = max(total_cols, cols)
+        items.append({
+            "index": i,
+            "shape": (rows, cols),
+            "columns": list(df.columns),
+            "df": df,
+        })
+
+    features = {
+        "표 개수": len(dfs),
+        "각 표 모양": [t["shape"] for t in items],
+        "각 표 헤더(첫 표)": items[0]["columns"][:6] if items else [],
+        "최대 열 수": total_cols,
+        "총 행 수(합)": total_rows,
+        "추출 모드": "lattice (선 기반)",
+    }
+    return {
+        "engine": "tabula",
+        "table_count": len(dfs),
+        "tables": items,
+        "features": features,
+    }
+
+
+def extract_with_layoutparser(pdf_path, dpi=200, model_name=None):
+    """
+    LayoutParser — 페이지 이미지에서 'Table' 영역의 bbox를 탐지.
+    셀 내용 추출이 아니라 '어디에 표가 있는가'를 찾는 용도.
+    Detectron2 / PaddleDetection / EfficientDet 등 백엔드 모델 필요.
+    """
+    import fitz
+    from PIL import Image
+    import numpy as np
+
+    # Pillow 10+ 에서 PIL.Image.LINEAR 가 제거됨 → Detectron2 0.6 호환을 위해 사전 패치
+    if not hasattr(Image, "LINEAR"):
+        Image.LINEAR = Image.BILINEAR
+    if not hasattr(Image, "CUBIC"):
+        Image.CUBIC = Image.BICUBIC
+
+    import layoutparser as lp
+
+    # PaddleDetection 백엔드 + TableBank 모델 (표 전용 학습)
+    try:
+        model = lp.PaddleDetectionLayoutModel(
+            "lp://TableBank/ppyolov2_r50vd_dcn_365e/config",
+            label_map={0: "Table"},
+            enforce_cpu=True,
+        )
+        backend = "PaddleDetection (TableBank)"
+    except Exception as e_pd:
+        try:
+            model = lp.Detectron2LayoutModel(
+                "lp://PubLayNet/mask_rcnn_X_101_32x8d_FPN_3x/config",
+                extra_config=["MODEL.ROI_HEADS.SCORE_THRESH_TEST", 0.6],
+                label_map={0: "Text", 1: "Title", 2: "List", 3: "Table", 4: "Figure"},
+            )
+            backend = "Detectron2"
+        except Exception as e_d2:
+            raise ImportError(
+                "layoutparser 모델 백엔드를 사용할 수 없습니다.\n"
+                "  - PaddleDetection (paddlepaddle 필요): "
+                f"{e_pd.__class__.__name__}: {str(e_pd)[:100]}\n"
+                "  - Detectron2 (모델 다운로드 URL 일부 비활성화 상태): "
+                f"{e_d2.__class__.__name__}: {str(e_d2)[:100]}"
+            ) from e_pd
+
+    table_regions = []
+    page_results = []
+    with fitz.open(str(pdf_path)) as doc:
+        zoom = dpi / 72
+        mat = fitz.Matrix(zoom, zoom)
+        for page_idx, page in enumerate(doc, start=1):
+            pix = page.get_pixmap(matrix=mat, alpha=False)
+            img = np.array(Image.open(io.BytesIO(pix.tobytes("png"))).convert("RGB"))
+            layout = model.detect(img)
+            tables_on_page = [b for b in layout if b.type == "Table"]
+            for tb in tables_on_page:
+                box = tb.block
+                # 픽셀 좌표 → PDF 좌표 (PDF 포인트, 72dpi 기준)
+                pdf_rect = fitz.Rect(
+                    box.x_1 / zoom, box.y_1 / zoom,
+                    box.x_2 / zoom, box.y_2 / zoom,
+                )
+                # bbox 영역 내부 텍스트 추출 (디지털 PDF 한정 — 스캔 PDF면 빈 문자열)
+                region_text = page.get_text(clip=pdf_rect).strip()
+                table_regions.append({
+                    "page": page_idx,
+                    "score": round(float(tb.score), 4) if tb.score is not None else None,
+                    "bbox": (round(box.x_1, 1), round(box.y_1, 1),
+                             round(box.x_2, 1), round(box.y_2, 1)),
+                    "text": region_text,
+                })
+            page_results.append({
+                "page": page_idx,
+                "table_regions": tables_on_page,
+                "all_layout_count": len(layout),
+            })
+
+    features = {
+        "사용 백엔드": backend,
+        "렌더링 DPI": dpi,
+        "검출된 표 영역 수": len(table_regions),
+        "표 영역 상세": [
+            f"p{r['page']} {r['bbox']} (score={r['score']})"
+            for r in table_regions
+        ],
+        "페이지별 전체 레이아웃 요소 수": [
+            p["all_layout_count"] for p in page_results
+        ],
+    }
+    return {
+        "engine": "layoutparser",
+        "table_count": len(table_regions),
+        "tables": table_regions,
+        "features": features,
+    }
+
+
+ENGINE_MAP = {
+    "camelot": extract_with_camelot,
+    "tabula": extract_with_tabula,
+    "layoutparser": extract_with_layoutparser,
+}
+
+HIGHLIGHT_KEYS = {
+    "camelot":      ("표 개수", "평균 정확도(accuracy)", "각 표 모양"),
+    "tabula":       ("표 개수", "각 표 모양", "각 표 헤더(첫 표)"),
+    "layoutparser": ("검출된 표 영역 수", "사용 백엔드", "표 영역 상세"),
+}
+
+
+def extract_tables(pdf_path, engine="camelot", **kwargs):
+    if engine not in ENGINE_MAP:
+        raise ValueError(f"지원하지 않는 엔진: {engine}. 사용 가능: {list(ENGINE_MAP)}")
+    path = Path(pdf_path)
+    if not path.exists():
+        raise FileNotFoundError(f"파일을 찾을 수 없습니다: {pdf_path}")
+    return ENGINE_MAP[engine](path, **kwargs)
+
+
+def _format_value(value):
+    if isinstance(value, list):
+        if not value:
+            return "[]"
+        preview = ", ".join(str(v) for v in value[:5])
+        suffix = f", ... (+{len(value) - 5})" if len(value) > 5 else ""
+        return f"[{preview}{suffix}]"
+    return str(value)
+
+
+def print_result(result, preview_rows=3):
+    print(f"=== 표 추출 엔진: {result['engine']} ===")
+    print(f"검출된 표 수    : {result.get('table_count', 0)}")
+
+    features = result.get("features", {})
+    if features:
+        print()
+        print(f"--- {result['engine']} 특화 지표 ---")
+        for k, v in features.items():
+            print(f"  {k:<22}: {_format_value(v)}")
+
+    tables = result.get("tables", [])
+    if not tables:
+        return
+    print()
+    print(f"--- 표 미리보기 (앞 {preview_rows}행) ---")
+    for i, t in enumerate(tables[:5], start=1):
+        df = t.get("df")
+        if df is not None:
+            print(f"\n[표 {i}] {_df_shape(df)}")
+            print(_df_preview(df, max_rows=preview_rows))
+        else:
+            page = t.get("page", "?")
+            bbox = t.get("bbox", "?")
+            score = t.get("score", "?")
+            print(f"  [표 {i}] page={page}, bbox={bbox}, score={score}")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("사용법: python3 table_pdf.py <PDF 파일> [엔진]")
+        print(f"  엔진(생략 시 전체): {', '.join(ENGINES)}")
+        print("예시 : python3 table_pdf.py data/table_sample.pdf camelot")
+        print("       python3 table_pdf.py data/table_sample.pdf")
+        sys.exit(1)
+
+    pdf_path = sys.argv[1]
+    engines = [sys.argv[2]] if len(sys.argv) >= 3 else list(ENGINES)
+
+    for i, engine in enumerate(engines):
+        if i > 0:
+            print()
+        try:
+            result = extract_tables(pdf_path, engine)
+            print_result(result)
+        except Exception as e:
+            print(f"=== 표 추출 엔진: {engine} ===")
+            print(f"오류: {type(e).__name__}: {e}")
+
+
+if __name__ == "__main__":
+    main()

pdfprep-0.1.0.dist-info/METADATA

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: pdfprep
+Version: 0.1.0
+Summary: PDF 전처리 통합 도구 — 메타데이터, 텍스트 파싱, OCR, 표 추출
+Author-email: uwpark <uwpark@simplatform.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/pdfprep/
+Keywords: pdf,ocr,table-extraction,preprocessing,parsing,metadata
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Natural Language :: Korean
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pypdf<6.0,>=4.0
+Requires-Dist: pdfplumber>=0.11.0
+Requires-Dist: pymupdf>=1.27.0
+Requires-Dist: pillow>=10.0
+Requires-Dist: numpy<2
+Requires-Dist: setuptools>=65
+Provides-Extra: ocr
+Requires-Dist: pytesseract>=0.3.13; extra == "ocr"
+Requires-Dist: paddleocr==2.7.3; extra == "ocr"
+Requires-Dist: paddlepaddle==2.6.2; extra == "ocr"
+Provides-Extra: table
+Requires-Dist: camelot-py[base]==1.0.9; extra == "table"
+Requires-Dist: tabula-py>=2.10; extra == "table"
+Requires-Dist: jpype1>=1.5; extra == "table"
+Requires-Dist: layoutparser>=0.3.4; extra == "table"
+Provides-Extra: all
+Requires-Dist: pytesseract>=0.3.13; extra == "all"
+Requires-Dist: paddleocr==2.7.3; extra == "all"
+Requires-Dist: paddlepaddle==2.6.2; extra == "all"
+Requires-Dist: camelot-py[base]==1.0.9; extra == "all"
+Requires-Dist: tabula-py>=2.10; extra == "all"
+Requires-Dist: jpype1>=1.5; extra == "all"
+Requires-Dist: layoutparser>=0.3.4; extra == "all"
+
+# PDF 메타데이터 / 파싱 / OCR / 표 추출 도구
+
+PDF 파일의 메타데이터를 확인하고, 3가지 라이브러리(`pypdf` / `pdfplumber` / `pymupdf`)로 텍스트를 파싱하며, 2가지 OCR 엔진(`tesseract` / `paddleocr`)으로 이미지 기반 텍스트를 추출하고, 3가지 표 추출 라이브러리(`camelot` / `tabula` / `layoutparser`)로 표를 검출·추출하는 Python 스크립트 모음입니다.
+
+## 구성
+
+| 파일 | 설명 |
+| --- | --- |
+| `pdf_metadata.py` | PDF 메타데이터 추출/출력 모듈. CLI로 직접 실행 가능 |
+| `test_pdf_metadata.py` | `pdf_metadata`를 불러와 동작을 검증하는 테스트 스크립트 |
+| `parsing_pdf.py` | 3종 라이브러리로 PDF 텍스트를 파싱하는 통합 모듈 |
+| `test_parsing_pdf.py` | 각 파싱 엔진별 결과를 비교·검증하는 테스트 스크립트 |
+| `ocr_pdf.py` | 2종 OCR 엔진(tesseract / paddleocr)으로 PDF를 OCR하는 통합 모듈 |
+| `test_ocr_pdf.py` | OCR 엔진별 결과(텍스트, 신뢰도, 박스 수 등)를 비교 검증 |
+| `table_pdf.py` | 3종 라이브러리(camelot / tabula / layoutparser)로 표 추출하는 통합 모듈 |
+| `test_table_pdf.py` | 표 추출 엔진별 결과(표 개수, 행/열, 정확도 등)를 비교 검증 |
+| `requirements.txt` | 의존성 목록 |
+| `data/` | 테스트용 PDF 파일을 두는 폴더 |
+
+## 설치
+
+```bash
+pip install -r requirements.txt
+```
+
+PEP 668 환경(Ubuntu 등 시스템 Python)에서는 가상환경 사용을 권장합니다.
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+### Tesseract 시스템 패키지
+
+`pytesseract`는 시스템에 설치된 `tesseract` 바이너리를 호출하므로 별도 설치가 필요합니다.
+
+```bash
+# Ubuntu/Debian — 한국어 + 영어 traineddata 포함
+sudo apt install tesseract-ocr tesseract-ocr-kor tesseract-ocr-eng
+
+# 설치 확인
+tesseract --version
+tesseract --list-langs   # kor, eng 출력되어야 함
+```
+
+### PaddleOCR 버전 주의
+
+`paddleocr 2.7.3` + `paddlepaddle 2.6.2` + `numpy<2` 조합으로 고정되어 있습니다. PaddleOCR 3.x / paddlepaddle 3.x 조합에서는 CPU 환경에서 PIR + oneDNN 호환 문제가 발생할 수 있어 LTS 조합을 사용합니다. 최초 실행 시 모델 파일이 자동으로 다운로드됩니다(~수십 MB).
+
+> **Python 3.12+ 사용자**: `paddlepaddle 2.6.2`는 표준 라이브러리에서 제거된 `distutils`를 호출하므로 `setuptools`가 반드시 설치돼 있어야 합니다(requirements.txt에 포함). 누락 시 `No module named 'setuptools'`가 발생하면 `pip install setuptools`로 해결하세요.
+
+### 표 추출 시스템 패키지
+
+- **camelot** → `ghostscript` 필요 (`sudo apt install ghostscript`)
+- **tabula** → JRE 필요 (`sudo apt install default-jre`)
+- **layoutparser** → PaddleDetection 백엔드 + **TableBank** 모델 사용 (표 전용 학습)
+  - OCR 섹션에서 설치한 `paddlepaddle` 만으로 동작
+  - 최초 실행 시 모델(약 221MB) 자동 다운로드 (Baidu CDN)
+  - 별도 `paddledet` 또는 `detectron2` 설치 불필요
+
+## 사용법
+
+### 1. PDF 메타데이터 출력 (`pdf_metadata.py`)
+
+```bash
+python3 pdf_metadata.py data/pdf_sample.pdf
+python3 pdf_metadata.py a.pdf b.pdf c.pdf
+```
+
+출력 항목
+- 파일 크기, 페이지 수, PDF 버전, 암호화 여부
+- Document Info: Title, Author, Subject, Keywords, Creator, Producer
+- 생성일/수정일 (`D:YYYYMMDDHHMMSS` → `YYYY-MM-DD HH:MM:SS` 변환)
+- 기타 메타데이터 키(`/Trapped` 등)
+
+### 2. 메타데이터 테스트 (`test_pdf_metadata.py`)
+
+```bash
+python3 test_pdf_metadata.py                     # 기본 data/ 폴더
+python3 test_pdf_metadata.py data/pdf_sample.pdf # 단일 파일
+python3 test_pdf_metadata.py a.pdf b.pdf data/   # 혼합 지정
+```
+
+### 3. PDF 텍스트 파싱 (`parsing_pdf.py`)
+
+```bash
+# 전체 엔진으로 한 번에 비교
+python3 parsing_pdf.py data/parsing_sample.pdf
+
+# 특정 엔진만 사용
+python3 parsing_pdf.py data/parsing_sample.pdf pypdf
+python3 parsing_pdf.py data/parsing_sample.pdf pdfplumber
+python3 parsing_pdf.py data/parsing_sample.pdf pymupdf
+```
+
+엔진별 특징
+- **pypdf** — 가벼움. 목차/폼/주석 등 문서 구조 메타에 강점
+- **pdfplumber** — 표(테이블) 추출, 단어/문자 단위 bbox에 강점
+- **pymupdf** (`fitz`) — 빠르고 강력. 블록·이미지·폰트·색상 등 풍부한 메타
+
+### 4. 파싱 테스트 (`test_parsing_pdf.py`)
+
+```bash
+python3 test_parsing_pdf.py                       # 기본 data/ 폴더
+python3 test_parsing_pdf.py data/pdf_sample.pdf   # 단일 파일
+python3 test_parsing_pdf.py /다른/경로/             # 다른 폴더
+```
+
+출력
+- 엔진 × 파일 시간/페이지/텍스트길이 매트릭스
+- 엔진별 특화 지표 (예: pdfplumber → 표 개수, pymupdf → 블록·이미지·폰트 수)
+
+### 5. OCR 실행 (`ocr_pdf.py`)
+
+```bash
+# 전체 엔진으로 비교 (tesseract → paddleocr 순)
+python3 ocr_pdf.py data/pdf_sample.pdf
+
+# 특정 엔진만 사용
+python3 ocr_pdf.py data/pdf_sample.pdf tesseract
+python3 ocr_pdf.py data/pdf_sample.pdf paddleocr
+```
+
+처리 흐름
+1. `pymupdf`로 PDF 각 페이지를 PNG로 렌더링(기본 200 DPI)
+2. 이미지를 OCR 엔진에 전달
+3. 텍스트 + 신뢰도 + 박스/단어 통계 반환
+
+엔진별 특징
+- **tesseract** — 가벼움/빠름. `kor+eng` 등 다국어 동시 인식. 단어 단위 신뢰도 제공
+- **paddleocr** — 딥러닝 기반. 검출(detection) + 인식(recognition) 2단계로 라인별 박스 + 신뢰도 반환
+
+### 6. OCR 테스트 (`test_ocr_pdf.py`)
+
+```bash
+python3 test_ocr_pdf.py                              # 기본 파일 + 전체 엔진
+python3 test_ocr_pdf.py data/pdf_sample.pdf          # 지정 파일 + 전체 엔진
+python3 test_ocr_pdf.py /다른/경로/                    # 지정 폴더 + 전체 엔진
+
+# 엔진 단독 실행 (마지막 인자가 엔진 이름이면 그것만 실행)
+python3 test_ocr_pdf.py data/pdf_sample.pdf tesseract
+python3 test_ocr_pdf.py data/pdf_sample.pdf paddleocr
+python3 test_ocr_pdf.py paddleocr                    # 엔진만 지정 → 기본 파일 사용
+```
+
+출력
+- 엔진 × 파일 시간/페이지/텍스트길이 매트릭스
+- 엔진별 특화 지표
+  - **tesseract**: 인식 단어 수, 평균 신뢰도(%), 사용 언어
+  - **paddleocr**: 검출 텍스트 박스 수, 평균 신뢰도, 사용 언어
+
+라이브러리 미설치 시 해당 엔진은 자동으로 `SKIP` 처리됩니다.
+
+### 7. 표 추출 (`table_pdf.py`)
+
+```bash
+# 전체 엔진으로 비교
+python3 table_pdf.py data/table_sample.pdf
+
+# 특정 엔진만 사용
+python3 table_pdf.py data/table_sample.pdf camelot
+python3 table_pdf.py data/table_sample.pdf tabula
+python3 table_pdf.py data/table_sample.pdf layoutparser
+```
+
+엔진별 특징
+- **camelot** — PDF 표 추출 전용. `lattice`(선 기반) / `stream`(좌표 기반) 두 모드. 정확도(accuracy)·여백률(whitespace) 등 품질 지표 제공. Ghostscript 필요
+- **tabula** — `tabula-java` 래퍼. pandas DataFrame 리스트 반환. JRE 필요
+- **layoutparser** — 페이지를 이미지로 렌더링 후 'Table' 영역의 bbox를 탐지하는 레이아웃 검출기. 셀 내용 추출이 아닌 '표 위치' 검출용. PaddleDetection 백엔드 + TableBank 모델 (영문 PubLayNet 대신 표 전용 학습)
+
+### 8. 표 추출 테스트 (`test_table_pdf.py`)
+
+```bash
+python3 test_table_pdf.py                            # 기본 파일 + 전체 엔진
+python3 test_table_pdf.py data/table_sample.pdf      # 지정 파일 + 전체 엔진
+python3 test_table_pdf.py /다른/경로/                   # 지정 폴더 + 전체 엔진
+
+# 엔진 단독 실행
+python3 test_table_pdf.py data/table_sample.pdf camelot
+python3 test_table_pdf.py data/table_sample.pdf tabula
+python3 test_table_pdf.py data/table_sample.pdf layoutparser
+python3 test_table_pdf.py camelot                    # 엔진만 지정 → 기본 파일 사용
+```
+
+기본 파일은 `data/table_sample.pdf`입니다. 출력에는 표 개수, 각 표의 행/열 크기, 첫 표 미리보기, 엔진별 특화 지표(camelot 정확도, tabula 헤더, layoutparser bbox)가 포함됩니다.
+
+## 폴더 구조
+
+```
+code/
+├── README.md
+├── requirements.txt
+├── pdf_metadata.py
+├── test_pdf_metadata.py
+├── parsing_pdf.py
+├── test_parsing_pdf.py
+├── ocr_pdf.py
+├── test_ocr_pdf.py
+├── table_pdf.py
+├── test_table_pdf.py
+└── data/
+    ├── pdf_sample.pdf
+    ├── parsing_sample.pdf
+    └── table_sample.pdf
+```
+
+`data/`에 PDF를 추가하면 인자 없이 테스트를 실행해도 자동으로 같이 검증됩니다.

pdfprep-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pdfprep/__init__.py,sha256=zV8ch6JxnS0t0uUOcOKHe2Dau2jFtcRV8OzNhZLQKFc,499
+pdfprep/metadata.py,sha256=f6fwBzMj-0tCoksF9MZmv8j5wn-PGKfBbA7-4Ku0eks,2141
+pdfprep/ocr.py,sha256=PP18FqWuplEmTPF-qOCvUeTn9Mzh3qNNq-vqwsOLIfk,6146
+pdfprep/parsing.py,sha256=3-YFbluMobtg_Arzb7kmC-6M5sOiDjvWW_GKOcdNb4w,7670
+pdfprep/table.py,sha256=2nye4eitoGgVgNho_GJI1PyWlGLAflKx_1VfX0WFLZk,9856
+pdfprep-0.1.0.dist-info/METADATA,sha256=FLkeDZ8AzoGS1qHzLpESS6zjcOJRBYczqebdXen_t7k,10430
+pdfprep-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pdfprep-0.1.0.dist-info/entry_points.txt,sha256=5q-s_E2hA_XNLIUJJX96iH9bNbAHlrrZvPcU2DxyBqQ,162
+pdfprep-0.1.0.dist-info/top_level.txt,sha256=dGL0EYAoTAQmGS_WIGJrhPRhAFVKs0fMwLQKEgM4-sk,8
+pdfprep-0.1.0.dist-info/RECORD,,

pdfprep-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pdfprep-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pdfprep-metadata = pdfprep.metadata:main
+pdfprep-ocr = pdfprep.ocr:main
+pdfprep-parse = pdfprep.parsing:main
+pdfprep-table = pdfprep.table:main

pdfprep-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pdfprep