Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+static/page11_img1.png filter=lfs diff=lfs merge=lfs -text
+static/page16_img1.png filter=lfs diff=lfs merge=lfs -text
+static/page2_img1.png filter=lfs diff=lfs merge=lfs -text
+static/page3_img1.png filter=lfs diff=lfs merge=lfs -text
+static/page4_img1.png filter=lfs diff=lfs merge=lfs -text
+static/page7_img1.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,175 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc
+
+data/
+.DS_Store
+.temp

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,68 @@
 ---
-title: Pdf2html
-emoji: ⚡
-colorFrom: indigo
-colorTo: indigo
+title: pdf2html
+app_file: web_interface.py
 sdk: gradio
 sdk_version: 5.20.1
-app_file: app.py
-pinned: false
 ---
+# pdf2html
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+PDF 파일을 단일 컬럼 HTML로 변환하는 Python 패키지입니다.
+
+## 설치
+
+```bash
+# Poetry를 사용하는 경우
+poetry install
+
+# 또는 pip 사용
+pip install pdf2html
+```
+
+## 필요 라이브러리
+
+```bash
+pip install PyMuPDF beautifulsoup4 langchain gradio gradio-pdf
+```
+
+## 사용법
+
+### 명령줄 인터페이스
+
+```bash
+# 직접 실행
+poerty run python -m pdf2html 경로/파일명.pdf
+poerty run python -m pdf2html 경로/파일명.pdf --output 출력디렉토리
+
+# 설치 후 실행
+pdf2html 경로/파일명.pdf
+pdf2html 경로/파일명.pdf --output 출력디렉토리
+```
+
+### 웹 인터페이스
+
+```bash
+# 직접 실행
+poetry run python -m web_interface
+
+# 설치 후 실행
+pdf2html-web
+```
+
+### Python 코드에서 사용
+
+```python
+from pdf2html import PDFToHTMLConverter
+
+converter = PDFToHTMLConverter("경로/파일명.pdf")
+output_path = converter.convert()
+print(f"변환 완료: {output_path}")
+```
+
+## 주요 기능
+
+- PDF 문서의 텍스트, 이미지, 표 추출
+- 1단 세로 레이아웃으로 재구성
+- 문단 구조 및 서식 유지
+- 이미지 자동 추출 및 포함
+- 표 구조 감지 및 HTML 테이블로 변환
+- Gradio 기반 웹 인터페이스 제공

__init__.py

@@ -0,0 +1,3 @@
+from convert import PDFToHTMLConverter
+
+__version__ = "0.1.0"

cli.py

@@ -0,0 +1,17 @@
+import argparse
+from convert import PDFToHTMLConverter
+
+def main():
+    parser = argparse.ArgumentParser(description="PDF를 HTML로 변환")
+    parser.add_argument("pdf_path", help="변환할 PDF 파일 경로")
+    parser.add_argument("--output", "-o", help="출력 디렉토리 (기본값: PDF와 같은 디렉토리)")
+    
+    args = parser.parse_args()
+    
+    converter = PDFToHTMLConverter(args.pdf_path, args.output)
+    output_path = converter.convert()
+    
+    print(f"변환 완료: {output_path}")
+
+if __name__ == "__main__":
+    main()

convert.py

@@ -0,0 +1,420 @@
+import os
+from pathlib import Path
+import fitz  # PyMuPDF
+import base64
+import re
+import shutil
+
+class PDFToHTMLConverter:
+    def __init__(self, pdf_path, output_dir=None):
+        """
+        PDF를 HTML로 변환하는 클래스 초기화
+        
+        Args:
+            pdf_path (str): PDF 파일 경로
+            output_dir (str, optional): 출력 디렉토리. 기본값은 PDF와 같은 디렉토리.
+        """
+        self.pdf_path = pdf_path
+        self.pdf_name = Path(pdf_path).stem
+        
+        # 프로젝트 루트 디렉토리에 .temp 폴더 생성
+        current_dir = Path.cwd()
+        self.temp_dir = current_dir / ".temp"
+        
+        # 입력 PDF 저장 디렉토리
+        self.pdf_dir = self.temp_dir / "temp_input_pdf"
+        
+        # 출력 HTML 저장 디렉토리
+        self.output_dir = self.temp_dir / "temp_output_html"
+        
+        # 이미지 저장 디렉토리
+        self.img_dir = self.output_dir / "images"
+        
+        # 필요한 디렉토리 생성
+        self.temp_dir.mkdir(exist_ok=True)
+        self.pdf_dir.mkdir(exist_ok=True)
+        self.output_dir.mkdir(exist_ok=True)
+        self.img_dir.mkdir(exist_ok=True)
+        
+        # 고정된 파일 이름 설정
+        self.fixed_pdf_path = self.pdf_dir / "current.pdf"
+        
+        # 파일 경로가 문자열인 경우 Path 객체로 변환
+        if isinstance(pdf_path, str):
+            pdf_path = Path(pdf_path)
+            
+        # 원본 PDF 파일이 고정 경로와 다른 경우에만 복사
+        if pdf_path != self.fixed_pdf_path:
+            shutil.copy2(str(pdf_path), str(self.fixed_pdf_path))
+            print(f"PDF 파일 복사됨: {pdf_path} -> {self.fixed_pdf_path}")
+        else:
+            print(f"PDF 파일이 이미 올바른 위치에 있습니다: {self.fixed_pdf_path}")
+        
+        # PyMuPDF 문서 객체 열기
+        self.doc = fitz.open(self.fixed_pdf_path)
+        
+        # 결과 HTML
+        self.html_content = ""
+        self.text_html_content = ""
+        self.media_html_content = ""
+    
+    def _extract_text_with_structure(self, page):
+        """
+        페이지에서 텍스트를 추출하고 기본 구조를 유지
+        
+        Args:
+            page (fitz.Page): PDF 페이지 객체
+            
+        Returns:
+            str: 구조화된 HTML 텍스트
+        """
+        blocks = page.get_text("dict")["blocks"]
+        html_text = []
+        
+        for block in blocks:
+            if block["type"] == 0:  # 텍스트 블록
+                text_lines = []
+                for line in block["lines"]:
+                    line_text = ""
+                    for span in line["spans"]:
+                        # 폰트 크기와 스타일 분석
+                        font_size = span["size"]
+                        is_bold = "bold" in span["font"].lower() or span.get("flags", 0) & 16 != 0
+                        is_italic = "italic" in span["font"].lower() or span.get("flags", 0) & 1 != 0
+                        
+                        text = span["text"]
+                        
+                        # 폰트 크기에 따라 제목 또는 일반 텍스트로 분류
+                        if font_size > 14:  # 큰 폰트는 제목일 가능성이 높음
+                            if is_bold:
+                                text = f"<h1>{text}</h1>"
+                            else:
+                                text = f"<h2>{text}</h2>"
+                        elif font_size > 12:
+                            if is_bold:
+                                text = f"<h3>{text}</h3>"
+                            else:
+                                text = f"<h4>{text}</h4>"
+                        else:
+                            if is_bold:
+                                text = f"<strong>{text}</strong>"
+                            if is_italic:
+                                text = f"<em>{text}</em>"
+                        
+                        line_text += text
+                    
+                    text_lines.append(line_text)
+                
+                # 텍스트 라인을 단락으로 결합
+                if text_lines:
+                    paragraph = " ".join(text_lines)
+                    html_text.append(f"<p>{paragraph}</p>")
+        
+        return "\n".join(html_text)
+    
+    def _extract_images(self, page, page_num):
+        """
+        페이지에서 이미지 추출
+        
+        Args:
+            page (fitz.Page): PDF 페이지 객체
+            page_num (int): 페이지 번호
+            
+        Returns:
+            list: 이미지 HTML 태그 목록
+        """
+        image_tags = []
+        image_list = page.get_images(full=True)
+        
+        for img_idx, img_info in enumerate(image_list):
+            try:
+                xref = img_info[0]
+                base_img = self.doc.extract_image(xref)
+                image_bytes = base_img["image"]
+                
+                # 이미지 포맷 확인 (기본값은 png)
+                image_ext = base_img["ext"]
+                if image_ext.lower() not in ["jpeg", "jpg", "png"]:
+                    image_ext = "png"
+                    
+                # 고정된 경로에 이미지 저장
+                image_filename = f"page{page_num+1}_img{img_idx+1}.{image_ext}"
+                image_path = self.img_dir / image_filename
+                
+                # 이미지 디렉토리 확인
+                if not self.img_dir.exists():
+                    self.img_dir.mkdir(parents=True, exist_ok=True)
+                    
+                with open(image_path, "wb") as img_file:
+                    img_file.write(image_bytes)
+                    
+                # 디버깅을 위한 코드
+                print(f"이미지 저장: {image_path} (크기: {len(image_bytes)} 바이트)")
+                    
+                # 이미지 태그 생성 (상대 경로 사용)
+                # 경로가 HTML 파일에서 올바르게 참조될 수 있도록 합니다
+                rel_img_path = f"images/{image_filename}"
+                img_tag = f'<div class="image-container"><img src="{rel_img_path}" alt="Page {page_num+1} Image {img_idx+1}" style="max-width:100%; height:auto;"/></div>'
+                image_tags.append(img_tag)
+                
+            except Exception as e:
+                print(f"이미지 추출 중 오류: {str(e)}")
+        
+        return image_tags
+    
+    def _extract_tables(self, page):
+        """
+        페이지에서 표 추출 시도
+        
+        Args:
+            page (fitz.Page): PDF 페이지 객체
+            
+        Returns:
+            list: 표 HTML 태그 목록
+        """
+        # 표 감지 및 추출은 복잡한 작업입니다.
+        # 이 간단한 예시에서는 테이블로 보이는 구조를 감지하는 기본적인 접근 방식을 사용합니다.
+        tables = []
+        
+        # 페이지의 텍스트 블록을 분석
+        blocks = page.get_text("dict")["blocks"]
+        
+        # 높이가 비슷한 텍스트 블록이 가로로 정렬된 경우 테이블 행일 가능성이 있음
+        table_candidates = []
+        
+        for i, block in enumerate(blocks):
+            if block["type"] == 0:  # 텍스트 블록
+                # 텍스트 블록의 위치 정보
+                x0, y0, x1, y1 = block["bbox"]
+                
+                # 같은 행에 있는 다른 텍스트 블록 찾기
+                same_row_blocks = []
+                
+                for j, other_block in enumerate(blocks):
+                    if i != j and other_block["type"] == 0:
+                        ox0, oy0, ox1, oy1 = other_block["bbox"]
+                        
+                        # y 좌표가 비슷하면 같은 행일 가능성이 있음
+                        if abs(y0 - oy0) < 5 and abs(y1 - oy1) < 5:
+                            same_row_blocks.append(j)
+                
+                # 같은 행에 여러 텍스트 블록이 있으면 테이블 행일 가능성이 높음
+                if len(same_row_blocks) >= 2:
+                    table_candidates.append((i, same_row_blocks))
+        
+        # 테이블 후보가 있으면 HTML 테이블로 변환
+        if table_candidates:
+            table_html = "<table border='1'>\n"
+            
+            for row_idx, row_blocks in table_candidates:
+                table_html += "<tr>\n"
+                
+                # 현재 블록 추가
+                block_text = ""
+                for line in blocks[row_idx]["lines"]:
+                    for span in line["spans"]:
+                        block_text += span["text"] + " "
+                
+                table_html += f"<td>{block_text.strip()}</td>\n"
+                
+                # 같은 행의 다른 블록 추가
+                for block_idx in row_blocks:
+                    block_text = ""
+                    for line in blocks[block_idx]["lines"]:
+                        for span in line["spans"]:
+                            block_text += span["text"] + " "
+                    
+                    table_html += f"<td>{block_text.strip()}</td>\n"
+                
+                table_html += "</tr>\n"
+            
+            table_html += "</table>"
+            tables.append(table_html)
+        
+        return tables
+    
+    def _create_html_template(self, title, content, css_additional=""):
+        """
+        HTML 템플릿 생성 - 다크 테마 적용
+        
+        Args:
+            title (str): HTML 제목
+            content (str): HTML 본문 내용
+            css_additional (str): 추가 CSS 스타일
+            
+        Returns:
+            str: 완성된 HTML 문자열
+        """
+        return f"""<!DOCTYPE html>
+    <html lang="ko">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{title}</title>
+        <style>
+            body {{
+                font-family: Arial, sans-serif;
+                line-height: 1.6;
+                margin: 0;
+                padding: 0;
+                height: 100vh;
+                overflow-y: auto;
+                background-color: #2a2a2a;
+                color: #ffffff;
+            }}
+            .page-title {{
+                padding: 10px 20px;
+                margin: 0;
+                background-color: #333;
+                color: white;
+                position: sticky;
+                top: 0;
+                z-index: 10;
+            }}
+            .content-container {{
+                padding: 20px;
+            }}
+            .image-container {{
+                text-align: center;
+                margin: 20px 0;
+            }}
+            img {{
+                max-width: 100%;
+                height: auto;
+                border: 1px solid #444;
+            }}
+            table {{
+                border-collapse: collapse;
+                width: 100%;
+                margin: 20px 0;
+                background-color: #333;
+            }}
+            td, th {{
+                border: 1px solid #555;
+                padding: 8px;
+                color: #fff;
+            }}
+            h1, h2, h3, h4, p, span, div {{
+                color: #fff;
+            }}
+            .media-item {{
+                margin-bottom: 30px;
+                padding-bottom: 20px;
+                border-bottom: 1px solid #444;
+            }}
+            .media-item-heading {{
+                background-color: #444;
+                padding: 5px 10px;
+                margin-bottom: 10px;
+                font-weight: bold;
+                border-left: 3px solid #E67E22;
+                color: #fff;
+            }}
+            .page-text {{
+                margin-bottom: 30px;
+                border-bottom: 1px solid #444;
+                padding-bottom: 20px;
+            }}
+            /* 스크롤바 스타일 */
+            ::-webkit-scrollbar {{
+                width: 8px;
+            }}
+            ::-webkit-scrollbar-track {{
+                background: #333;
+            }}
+            ::-webkit-scrollbar-thumb {{
+                background: #666;
+                border-radius: 4px;
+            }}
+            ::-webkit-scrollbar-thumb:hover {{
+                background: #777;
+            }}
+            /* 링크 스타일 */
+            a {{
+                color: #3498db;
+                text-decoration: none;
+            }}
+            a:hover {{
+                text-decoration: underline;
+            }}
+            {css_additional}
+        </style>
+    </head>
+    <body>
+        <h1 class="page-title">{title}</h1>
+        <div class="content-container">
+            {content}
+        </div>
+    </body>
+    </html>"""
+
+    def convert(self):
+        """
+        PDF를 텍스트 HTML과 미디어 HTML로 분리하여 변환
+        
+        Returns:
+            tuple: 텍스트 HTML 경로, 미디어 HTML 경로
+        """
+        # 텍스트 컬럼과 미디어 컬럼을 위한 컨텐츠 준비
+        text_content = []
+        media_content = []
+        media_order = 0  # 미디어 아이템 순서
+        
+        # 각 페이지 처리
+        for page_num, page in enumerate(self.doc):
+            # 텍스트 추출
+            text_html = self._extract_text_with_structure(page)
+            text_content.append(f"\n<div class='page-text' id='page-text-{page_num+1}'>\n")
+            text_content.append(f"<h3>페이지 {page_num+1}</h3>")
+            text_content.append(text_html)
+            text_content.append("\n</div>\n")
+            
+            # 표 추출
+            tables = self._extract_tables(page)
+            for table_idx, table in enumerate(tables):
+                media_order += 1
+                media_content.append(f"""
+                <div class="media-item" id="table-{page_num+1}-{table_idx+1}" data-page="{page_num+1}">
+                    <div class="media-item-heading">표 {media_order} - 페이지 {page_num+1}</div>
+                    {table}
+                </div>
+                """)
+            
+            # 이미지 추출
+            images = self._extract_images(page, page_num)
+            for img_idx, img_tag in enumerate(images):
+                media_order += 1
+                media_content.append(f"""
+                <div class="media-item" id="image-{page_num+1}-{img_idx+1}" data-page="{page_num+1}">
+                    <div class="media-item-heading">이미지 {media_order} - 페이지 {page_num+1}</div>
+                    {img_tag}
+                </div>
+                """)
+        
+        # 텍스트 HTML 생성
+        text_html_content = self._create_html_template(
+            f"{self.pdf_name} - 텍스트", 
+            "\n".join(text_content)
+        )
+        
+        # 미디어 HTML 생성
+        media_html_content = self._create_html_template(
+            f"{self.pdf_name} - 표 및 이미지", 
+            "\n".join(media_content)
+        )
+        
+        # 텍스트 HTML 파일 저장
+        text_output_path = self.output_dir / "text.html"
+        with open(text_output_path, "w", encoding="utf-8") as html_file:
+            html_file.write(text_html_content)
+        
+        # 미디어 HTML 파일 저장
+        media_output_path = self.output_dir / "media.html"
+        with open(media_output_path, "w", encoding="utf-8") as html_file:
+            html_file.write(media_html_content)
+        
+        # 결과 저장
+        self.text_html_content = text_html_content
+        self.media_html_content = media_html_content
+        
+        return str(text_output_path), str(media_output_path)

pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "pdf2html"
+version = "0.1.0"
+description = ""
+authors = ["jrpark <jrpark@petobio.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.13"
+pymupdf = "^1.25.3"
+beautifulsoup4 = "^4.13.3"
+langchain = "^0.3.20"
+gradio = "^5.20.1"
+gradio-pdf = "^0.0.22"
+
+
+[tool.poetry.group.dev.dependencies]
+ipykernel = "^6.29.5"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,5 @@
+PyMuPDF==1.25.3
+beautifulsoup4==4.13.3
+langchain==0.3.20
+gradio==5.20.1
+gradio-pdf==0.0.22

test.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```mermaid\n",
+    "graph TD\n",
+    "    A[LLM in Veterinary] --> B[프롬프트 엔지니어링]\n",
+    "    A --> C[파인튜닝]\n",
+    "    A --> D[평가 방법]\n",
+    "    A --> E[실증 사례]\n",
+    "    A --> F[멀티모달]\n",
+    "    \n",
+    "    B --> B1(Structured Prompt)\n",
+    "    B --> B2(Contextual Guidance)\n",
+    "    B --> B3(Chain-of-Thought)\n",
+    "    \n",
+    "    C --> C1(Alpaca-7B)\n",
+    "    C --> C2(Data-efficient)\n",
+    "    C --> C3(SNOMED-CT)\n",
+    "    \n",
+    "    D --> D1(MM-Vet)\n",
+    "    D --> D2(Stratified F1)\n",
+    "    D --> D3(Exact Match)\n",
+    "    \n",
+    "    E --> E1(Diagnosis Coding)\n",
+    "    E --> E2(Educational GPT)\n",
+    "    E --> E3(Epidemiological Modeling)\n",
+    "    \n",
+    "    F --> F1(VLMs)\n",
+    "    F --> F2(PyMuPDF4LLM)\n",
+    "    F --> F3(Medical Imaging)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```mermaid\n",
+    "mindmap\n",
+    "  root((수의학 분야\n",
+    "  LLM 연구))\n",
+    "    임상 진단 지원\n",
+    "      증상 기반 질병 예측\n",
+    "        고양이 행동 분석\n",
+    "        개 피부 질환 진단\n",
+    "      의료 영상 분석\n",
+    "        방사선 영상 해석\n",
+    "        피부 병변 인식\n",
+    "      자동화된 진단 시스템\n",
+    "        다중 증상 통합 분석\n",
+    "    의료 데이터 분석\n",
+    "      전자 의무 기록 분석\n",
+    "        치료 패턴 발견\n",
+    "        치료 효과 예측\n",
+    "      역학 데이터 마이닝\n",
+    "        질병 발생 패턴\n",
+    "        지역 유행 예측\n",
+    "      생체신호 해석\n",
+    "        지속적 모니터링 시스템\n",
+    "    맞춤형 치료 계획\n",
+    "      약물 처방 최적화\n",
+    "        종 특이적 용량 조절\n",
+    "        약물 상호작용 예측\n",
+    "      수술 계획 지원\n",
+    "        3D 모델링 통합\n",
+    "      재활 프로그램 설계\n",
+    "        동물 맞춤형 운동 계획\n",
+    "    교육 및 훈련\n",
+    "      수의학 학생 교육\n",
+    "        가상 사례 시뮬레이션\n",
+    "        대화형 학습 시스템\n",
+    "      수의사 지속 교육\n",
+    "        최신 연구 요약 생성\n",
+    "        진단 지침 업데이트\n",
+    "    프롬프트 엔지니어링\n",
+    "      수의학 특화 프롬프트\n",
+    "        해부학적 정확성 향상\n",
+    "        종 특이적 지식 통합\n",
+    "      다단계 추론 프롬프트\n",
+    "        복잡한 질병 진단\n",
+    "    모델 평가 및 검증\n",
+    "      임상 정확도 평가\n",
+    "        전문가 검증 방법론\n",
+    "        환자 결과 추적 연구\n",
+    "      윤리적 고려사항\n",
+    "        의사결정 투명성\n",
+    "        오진 위험 관리\n",
+    "    멀티모달 응용\n",
+    "      이미지-텍스트 통합 분석\n",
+    "        방사선 영상 + 임상 기록\n",
+    "        현미경 영상 + 혈액 검사\n",
+    "      오디오 기반 진단\n",
+    "        심장 및 폐 소리 분석\n",
+    "        동물 발성 해석\n",
+    "    학제간 연구\n",
+    "      원헬스 접근법\n",
+    "        인수공통 질병 감시\n",
+    "        환경-동물-인간 상호작용\n",
+    "      야생동물 보전 응용\n",
+    "        표본 모니터링 자동화\n",
+    "        멸종위기종 보호 전략\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.13.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

web_interface.py

@@ -0,0 +1,424 @@
+import os
+import gradio as gr
+from pathlib import Path
+import base64
+
+# PDF to HTML 변환기 클래스 임포트 - 수정된 버전 사용
+from convert import PDFToHTMLConverter
+
+
+def convert_pdf_to_html(pdf_file):
+    """PDF 파일을 HTML로 변환하고 결과 반환"""
+    try:
+        # 현재 작업 디렉토리 확인
+        current_dir = Path.cwd()
+        temp_dir = current_dir / ".temp"
+
+        # PDF 데이터 준비
+        if hasattr(pdf_file, "name"):  # Gradio 파일 객체인 경우
+            with open(pdf_file.name, "rb") as f:
+                pdf_data = f.read()
+        else:  # 이미 바이너리 데이터인 경우
+            pdf_data = pdf_file
+
+        # 고정 경로에 PDF 저장
+        pdf_input_dir = temp_dir / "temp_input_pdf"
+        pdf_input_dir.mkdir(exist_ok=True, parents=True)
+        pdf_path = pdf_input_dir / "current.pdf"
+
+        # PDF 저장
+        with open(pdf_path, "wb") as f:
+            f.write(pdf_data)
+
+        print(f"PDF 저장 완료: {pdf_path}")
+
+        # PDF 변환 - 텍스트 HTML과 미디어 HTML로 분리
+        converter = PDFToHTMLConverter(str(pdf_path))
+        text_html_path, media_html_path = converter.convert()
+
+        print(f"HTML 변환 완료: {text_html_path}, {media_html_path}")
+
+        # HTML 파일 읽기
+        with open(text_html_path, "r", encoding="utf-8") as f:
+            text_html_content = f.read()
+
+        with open(media_html_path, "r", encoding="utf-8") as f:
+            media_html_content = f.read()
+
+        # 이미지를 Base64로 인코딩하여 HTML에 직접 포함
+        img_dir_path = temp_dir / "temp_output_html" / "images"
+        if img_dir_path.exists():
+            print(f"이미지 디렉토리 확인: {img_dir_path}")
+            for img_file in img_dir_path.glob("*.*"):
+                try:
+                    rel_path = f"images/{img_file.name}"
+                    print(f"이미지 처리 중: {img_file}")
+
+                    # 이미지 파일 읽기
+                    with open(img_file, "rb") as f:
+                        encoded_string = base64.b64encode(f.read()).decode("utf-8")
+
+                    # 이미지 타입에 따라 MIME 타입 설정
+                    ext = img_file.suffix.lower()[1:]  # .png -> png
+                    mime_type = {
+                        "png": "image/png",
+                        "jpg": "image/jpeg",
+                        "jpeg": "image/jpeg",
+                        "gif": "image/gif",
+                        "svg": "image/svg+xml",
+                    }.get(ext, "image/png")
+
+                    # Base64 이미지 URL 생성
+                    data_url = f"data:{mime_type};base64,{encoded_string}"
+
+                    # 미디어 HTML 내용에서 이미지 경로 교체
+                    original_pattern = f'src="{rel_path}"'
+                    replacement = f'src="{data_url}"'
+
+                    if original_pattern in media_html_content:
+                        media_html_content = media_html_content.replace(
+                            original_pattern, replacement
+                        )
+                        print(f"이미지 {img_file.name} Base64 인코딩 완료")
+                    else:
+                        print(
+                            f"경고: 이미지 경로 '{rel_path}'를 HTML에서 찾을 수 없습니다"
+                        )
+
+                except Exception as e:
+                    print(f"이미지 {img_file.name} 처리 중 오류: {str(e)}")
+        else:
+            print(f"이미지 디렉토리가 존재하지 않음: {img_dir_path}")
+
+        # 스크롤 가능한 컨테이너로 HTML 컨텐츠 래핑
+        text_html_with_style = f"""
+        <div style="width: 100%; height: 800px; overflow-y: auto; border: 1px solid #444; background-color: #2a2a2a;">
+            {text_html_content}
+        </div>
+        """
+
+        media_html_with_style = f"""
+        <div style="width: 100%; height: 800px; overflow-y: auto; border: 1px solid #444; background-color: #2a2a2a;">
+            {media_html_content}
+        </div>
+        """
+
+        print("HTML 내용 준비 완료")
+
+        # 텍스트 HTML과 미디어 HTML 반환
+        return text_html_with_style, media_html_with_style
+
+    except Exception as e:
+        import traceback
+
+        error_details = traceback.format_exc()
+        print(f"오류 발생: {str(e)}\n{error_details}")
+        error_html = f"<h1>오류 발생</h1><p>{str(e)}</p><pre>{error_details}</pre>"
+        return error_html, error_html
+
+
+def launch_web_interface():
+    """Gradio 웹 인터페이스 실행"""
+    # CSS 스타일
+    css = """
+    /* 전체 레이아웃 */
+    body, .gradio-container {
+        margin: 0 !important;
+        padding: 0 !important;
+        width: 100% !important;
+        max-width: none !important;
+        background-color: #1f1f1f;
+    }
+
+    /* 헤더 영역 */
+    .header-area {
+        background-color: #2a2a2a;
+        padding: 1rem;
+        border-bottom: 1px solid #444;
+        margin-bottom: 1rem;
+    }
+
+    /* 업로드 영역 */
+    .upload-area {
+        background-color: #2a2a2a;
+        padding: 1rem;
+        border-radius: 5px;
+        margin-bottom: 1rem;
+    }
+
+    /* HTML 뷰어 컨테이너 */
+    .html-columns {
+        display: flex;
+        gap: 20px;
+    }
+
+    .html-column {
+        flex: 1;
+        min-width: 0;
+    }
+
+    /* HTML 뷰어 */
+    .html-display {
+        min-height: 800px !important;
+        width: 100% !important;
+        background-color: #2a2a2a !important;
+    }
+
+    /* HTML 내용의 텍스트 색상 */
+    .html-display * {
+        color: #ffffff !important;
+    }
+
+    /* HTML 내의 표 스타일 */
+    .html-display table {
+        background-color: #333 !important;
+        border: 1px solid #555 !important;
+    }
+
+    .html-display td, 
+    .html-display th {
+        border: 1px solid #555 !important;
+        color: #fff !important;
+    }
+
+    /* 버튼 스타일 */
+    .convert-button {
+        background-color: #E67E22 !important;
+        border: none !important;
+    }
+
+    /* 타이틀 텍스트 */
+    .title-text {
+        color: white !important;
+        margin: 0 !important;
+        padding: 0 !important;
+    }
+
+    /* 설명 텍스트 */
+    .description-text {
+        color: #aaa !important;
+        margin-top: 0.5rem !important;
+    }
+
+    /* 컬럼 제목 */
+    .column-title {
+        color: white !important;
+        margin-bottom: 0.5rem !important;
+    }
+
+    /* 푸터 */
+    .footer-area {
+        margin-top: 2rem;
+        text-align: center;
+        color: #888;
+        padding: 1rem;
+    }
+    """
+
+    # Gradio 인터페이스
+    with gr.Blocks(css=css, theme=gr.themes.Default()) as demo:
+        # 헤더 섹션
+        with gr.Column(elem_classes="header-area"):
+            gr.Markdown("# PDF to HTML 변환기", elem_classes="title-text")
+            gr.Markdown(
+                "PDF 파일을 업로드하여 텍스트와 미디어로 분리된 HTML을 생성합니다.",
+                elem_classes="description-text",
+            )
+
+        # 업로드 섹션
+        with gr.Column(elem_classes="upload-area"):
+            # 파일 업로드 및 변환 버튼
+            with gr.Row():
+                pdf_input = gr.File(
+                    label="PDF 파일 업로드", type="binary", elem_id="pdf-upload"
+                )
+                convert_btn = gr.Button(
+                    "변환하기", variant="primary", elem_classes="convert-button"
+                )
+
+            # 상태 표시
+            status_output = gr.Textbox(
+                label="상태", value="대기 중...", interactive=False
+            )
+
+        # HTML 뷰어 영역 (두 열로 구성)
+        with gr.Column(visible=False) as html_output_area:
+            with gr.Row(elem_classes="html-columns"):
+                # 왼쪽 열 - 텍스트 HTML
+                with gr.Column(elem_classes="html-column"):
+                    gr.Markdown("### 텍스트 내용", elem_classes="column-title")
+                    text_html_viewer = gr.HTML(
+                        label="텍스트 HTML",
+                        elem_id="text-html-viewer",
+                        elem_classes="html-display",
+                    )
+
+                # 오른쪽 열 - 미디어 HTML
+                with gr.Column(elem_classes="html-column"):
+                    gr.Markdown("### 표 및 이미지", elem_classes="column-title")
+                    media_html_viewer = gr.HTML(
+                        label="미디어 HTML",
+                        elem_id="media-html-viewer",
+                        elem_classes="html-display",
+                    )
+
+        # 푸터
+        with gr.Column(elem_classes="footer-area"):
+            gr.Markdown("© 2025 pdf2html")
+
+        # 변환 처리 함수
+        def process_conversion(pdf_file):
+            if pdf_file is None:
+                return (
+                    gr.update(visible=False),
+                    "<h1 style='color:white;'>PDF 파일을 업로드해주세요</h1>",
+                    "<h1 style='color:white;'>PDF 파일을 업로드해주세요</h1>",
+                    "PDF 파일이 업로드되지 않았습니다.",
+                )
+
+            try:
+                # 변환 함수 호출
+                text_html, media_html = convert_pdf_to_html(pdf_file)
+
+                # HTML 내용 디버깅
+                print(f"텍스트 HTML 길이: {len(text_html)} 바이트")
+                print(f"미디어 HTML 길이: {len(media_html)} 바이트")
+
+                # HTML 표시 영역 보이기 및 내용 업데이트
+                return gr.update(visible=True), text_html, media_html, "변환 완료!"
+            except Exception as e:
+                import traceback
+
+                error_details = traceback.format_exc()
+                print(f"처리 중 오류: {str(e)}\n{error_details}")
+                error_html = f"<h1 style='color:red;'>오류 발생</h1><p style='color:red;'>{str(e)}</p>"
+                return (
+                    gr.update(visible=False),
+                    error_html,
+                    error_html,
+                    f"오류: {str(e)}",
+                )
+
+        # 변환 버튼 클릭 이벤트
+        convert_btn.click(
+            fn=process_conversion,
+            inputs=pdf_input,
+            outputs=[
+                html_output_area,
+                text_html_viewer,
+                media_html_viewer,
+                status_output,
+            ],
+        )
+
+        # 레이아웃 문제 해결을 위한 JavaScript
+        demo.load(
+            js="""
+        function fixLayout() {
+            // HTML 뷰어 컨테이너 확인
+            const htmlColumns = document.querySelector('.html-columns');
+            if (htmlColumns) {
+                // 컨테이너의 너비 균등하게 맞추기
+                const columns = htmlColumns.querySelectorAll('.html-column');
+                columns.forEach(column => {
+                    column.style.flex = '1';
+                    column.style.minWidth = '0';
+                });
+            }
+            
+            // 텍스트 색상 강제 설정
+            const textViewer = document.getElementById('text-html-viewer');
+            const mediaViewer = document.getElementById('media-html-viewer');
+            
+            function forceTextColor(element) {
+                if (!element) return;
+                
+                // iframe 내부 문서에 접근
+                try {
+                    const iframes = element.querySelectorAll('iframe');
+                    iframes.forEach(iframe => {
+                        if (iframe.contentDocument) {
+                            const allElements = iframe.contentDocument.querySelectorAll('*');
+                            allElements.forEach(el => {
+                                if (el.tagName !== 'IMG') {
+                                    el.style.color = '#ffffff';
+                                }
+                            });
+                            
+                            // 배경색 설정
+                            const body = iframe.contentDocument.body;
+                            if (body) {
+                                body.style.backgroundColor = '#2a2a2a';
+                            }
+                        }
+                    });
+                } catch (e) {
+                    console.error('iframe 접근 중 오류:', e);
+                }
+                
+                // 직접 문서 내 요소에 색상 설정
+                const allTextElements = element.querySelectorAll('p, h1, h2, h3, h4, h5, h6, span, div, a, li, td, th');
+                allTextElements.forEach(el => {
+                    el.style.color = '#ffffff';
+                });
+            }
+            
+            forceTextColor(textViewer);
+            forceTextColor(mediaViewer);
+            
+            // 이미지 표시 확인
+            if (mediaViewer) {
+                const images = mediaViewer.querySelectorAll('img');
+                console.log(`미디어 뷰어에서 이미지 ${images.length}개 발견`);
+                
+                images.forEach((img, index) => {
+                    // 이미지 로드 상태 확인
+                    console.log(`이미지 ${index + 1} 로드 상태: ${img.complete ? '완료' : '로딩 중'}`);
+                    if (img.complete && img.naturalWidth === 0) {
+                        console.log(`이미지 ${index + 1} 로드 실패`);
+                    }
+                });
+            }
+        }
+
+        // 페이지 로드 시 레이아웃 조정
+        window.addEventListener('load', function() {
+            setTimeout(fixLayout, 1000);
+            setTimeout(fixLayout, 3000);
+            setTimeout(fixLayout, 5000); // 더 긴 시간 후에도 한 번 더 실행
+        });
+
+        // MutationObserver로 DOM 변경 감지
+        const observer = new MutationObserver(mutations => {
+            setTimeout(fixLayout, 500);
+        });
+
+        // 페이지 로드 후 Observer 시작
+        window.addEventListener('load', () => {
+            observer.observe(document.body, { 
+                childList: true, 
+                subtree: true,
+                attributes: true
+            });
+            
+            // 스타일 요소 직접 추가
+            const style = document.createElement('style');
+            style.textContent = `
+                .html-display * {
+                    color: #ffffff !important;
+                }
+                .html-display {
+                    background-color: #2a2a2a !important;
+                }
+            `;
+            document.head.appendChild(style);
+        });
+        """
+        )
+
+    # 인터페이스 실행
+    demo.launch(share=False, inbrowser=True, show_api=False)
+
+
+if __name__ == "__main__":
+    launch_web_interface()