xgen-doc2chunk 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

xgen_doc2chunk/core/processor/excel_helper/excel_table_xlsx.py

@@ -0,0 +1,361 @@
+"""
+Excel XLSX 테이블 변환 모듈
+
+XLSX 시트를 Markdown 또는 HTML 테이블로 변환합니다.
+병합셀이 있으면 HTML, 없으면 Markdown을 사용합니다.
+layout_detect_range를 통해 실제 데이터 영역만 추출합니다.
+object_detect를 통해 개별 객체(테이블)별로 청킹할 수 있습니다.
+"""
+
+import logging
+from typing import Optional, List
+from xgen_doc2chunk.core.processor.excel_helper.excel_layout_detector import layout_detect_range_xlsx, object_detect_xlsx, LayoutRange
+
+logger = logging.getLogger("document-processor")
+
+
+def has_merged_cells_xlsx(ws, layout: Optional[LayoutRange] = None) -> bool:
+    """
+    XLSX 워크시트에 병합셀이 존재하는지 확인합니다.
+    layout이 주어지면 해당 영역 내의 병합셀만 확인합니다.
+
+    Args:
+        ws: openpyxl Worksheet 객체
+        layout: 검사할 레이아웃 범위 (None이면 전체 시트)
+
+    Returns:
+        병합셀이 존재하면 True
+    """
+    try:
+        if len(ws.merged_cells.ranges) == 0:
+            return False
+        
+        # layout이 없으면 전체 시트에 병합셀 존재 여부만 확인
+        if layout is None:
+            return True
+        
+        # layout 영역 내에 병합셀이 있는지 확인
+        for merged_range in ws.merged_cells.ranges:
+            # 병합 영역이 layout 영역과 겹치는지 확인
+            if (merged_range.min_row <= layout.max_row and
+                merged_range.max_row >= layout.min_row and
+                merged_range.min_col <= layout.max_col and
+                merged_range.max_col >= layout.min_col):
+                return True
+        
+        return False
+    except Exception:
+        return False
+
+
+def convert_xlsx_sheet_to_table(ws, layout: Optional[LayoutRange] = None) -> str:
+    """
+    XLSX 워크시트를 테이블로 변환합니다.
+    병합셀이 없으면 Markdown, 있으면 HTML로 변환합니다.
+    layout이 None이면 자동으로 감지합니다.
+
+    Args:
+        ws: openpyxl Worksheet 객체
+        layout: 변환할 레이아웃 범위 (None이면 자동 감지)
+
+    Returns:
+        변환된 테이블 문자열
+    """
+    # layout이 없으면 자동 감지
+    if layout is None:
+        layout = layout_detect_range_xlsx(ws)
+        if layout is None:
+            logger.debug("No data found in worksheet")
+            return ""
+    
+    if has_merged_cells_xlsx(ws, layout):
+        logger.debug("Merged cells detected in XLSX, using HTML format")
+        return convert_xlsx_sheet_to_html(ws, layout)
+    else:
+        logger.debug("No merged cells in XLSX, using Markdown format")
+        return convert_xlsx_sheet_to_markdown(ws, layout)
+
+
+def convert_xlsx_sheet_to_markdown(ws, layout: Optional[LayoutRange] = None) -> str:
+    """
+    XLSX 워크시트를 Markdown 테이블로 변환합니다.
+    layout_detect_range를 통해 실제 데이터 영역만 추출합니다.
+
+    Args:
+        ws: openpyxl Worksheet 객체
+        layout: 변환할 레이아웃 범위 (None이면 자동 감지)
+
+    Returns:
+        Markdown 테이블 문자열
+    """
+    try:
+        # layout이 없으면 자동 감지
+        if layout is None:
+            layout = layout_detect_range_xlsx(ws)
+            if layout is None:
+                return ""
+
+        # 병합 셀의 시작점이 layout 밖에 있는 경우, layout 내 첫 번째 셀에 값을 표시
+        merged_value_override = {}  # (row, col) -> value
+        for merged_range in ws.merged_cells.ranges:
+            mr_min_row, mr_min_col = merged_range.min_row, merged_range.min_col
+            mr_max_row, mr_max_col = merged_range.max_row, merged_range.max_col
+            
+            # layout 영역과 겹치는지 확인
+            if (mr_min_row <= layout.max_row and
+                mr_max_row >= layout.min_row and
+                mr_min_col <= layout.max_col and
+                mr_max_col >= layout.min_col):
+                
+                # 병합 셀의 시작점이 layout 밖에 있는 경우
+                start_in_layout = (layout.min_row <= mr_min_row <= layout.max_row and
+                                   layout.min_col <= mr_min_col <= layout.max_col)
+                
+                if not start_in_layout:
+                    merged_value = ws.cell(row=mr_min_row, column=mr_min_col).value
+                    if merged_value is not None:
+                        first_row_in_layout = max(mr_min_row, layout.min_row)
+                        first_col_in_layout = max(mr_min_col, layout.min_col)
+                        merged_value_override[(first_row_in_layout, first_col_in_layout)] = merged_value
+
+        md_parts = []
+        row_count = 0
+
+        for row_idx in range(layout.min_row, layout.max_row + 1):
+            cells = []
+            row_has_content = False
+
+            for col_idx in range(layout.min_col, layout.max_col + 1):
+                cell = ws.cell(row=row_idx, column=col_idx)
+                cell_value = ""
+
+                # 병합 셀 override 확인
+                if (row_idx, col_idx) in merged_value_override:
+                    cell_value = str(merged_value_override[(row_idx, col_idx)]).strip()
+                    if cell_value:
+                        row_has_content = True
+                elif cell.value is not None:
+                    cell_value = str(cell.value).strip()
+                    if cell_value:
+                        row_has_content = True
+
+                # Markdown 테이블에서 파이프는 이스케이프 필요
+                cell_value = cell_value.replace("|", "\\|")
+                cell_value = cell_value.replace("\n", " ")
+                cells.append(cell_value)
+
+            if not row_has_content:
+                continue
+
+            row_str = "| " + " | ".join(cells) + " |"
+            md_parts.append(row_str)
+            row_count += 1
+
+            # 첫 번째 데이터 행 다음에 구분선 추가
+            if row_count == 1:
+                separator = "| " + " | ".join(["---"] * len(cells)) + " |"
+                md_parts.append(separator)
+
+        return "\n".join(md_parts) if md_parts else ""
+
+    except Exception as e:
+        logger.warning(f"Error converting sheet to Markdown: {e}")
+        return ""
+
+
+def convert_xlsx_sheet_to_html(ws, layout: Optional[LayoutRange] = None) -> str:
+    """
+    XLSX 워크시트를 HTML 테이블로 변환합니다.
+    셀 병합(rowspan/colspan)을 지원합니다.
+    layout_detect_range를 통해 실제 데이터 영역만 추출합니다.
+    
+    병합셀이 있는 경우 빈 행도 테이블 구조의 일부이므로 포함합니다.
+
+    Args:
+        ws: openpyxl Worksheet 객체
+        layout: 변환할 레이아웃 범위 (None이면 자동 감지)
+
+    Returns:
+        HTML 테이블 문자열
+    """
+    try:
+        # layout이 없으면 자동 감지
+        if layout is None:
+            layout = layout_detect_range_xlsx(ws)
+            if layout is None:
+                return ""
+
+        # 병합된 셀 정보 수집 (layout 영역 내만)
+        merged_cells_info = {}  # (row, col) -> (rowspan, colspan)
+        skip_cells = set()  # 건너뛸 셀 (병합된 영역의 일부)
+        # 병합 셀의 시작점이 layout 밖에 있는 경우, layout 내 첫 번째 셀에 값을 표시
+        merged_value_override = {}  # (row, col) -> value
+
+        for merged_range in ws.merged_cells.ranges:
+            mr_min_row, mr_min_col = merged_range.min_row, merged_range.min_col
+            mr_max_row, mr_max_col = merged_range.max_row, merged_range.max_col
+            
+            # layout 영역과 겹치는 병합 셀만 처리
+            if (mr_min_row <= layout.max_row and
+                mr_max_row >= layout.min_row and
+                mr_min_col <= layout.max_col and
+                mr_max_col >= layout.min_col):
+                
+                # 병합 셀의 시작점이 layout 안에 있는지 확인
+                start_in_layout = (layout.min_row <= mr_min_row <= layout.max_row and
+                                   layout.min_col <= mr_min_col <= layout.max_col)
+                
+                if start_in_layout:
+                    # 일반적인 경우: 병합 정보 저장
+                    rowspan = mr_max_row - mr_min_row + 1
+                    colspan = mr_max_col - mr_min_col + 1
+                    merged_cells_info[(mr_min_row, mr_min_col)] = (rowspan, colspan)
+                    
+                    # 병합된 영역의 나머지 셀들은 건너뛰기
+                    for r in range(mr_min_row, mr_max_row + 1):
+                        for c in range(mr_min_col, mr_max_col + 1):
+                            if r != mr_min_row or c != mr_min_col:
+                                skip_cells.add((r, c))
+                else:
+                    # 병합 셀의 시작점이 layout 밖에 있는 경우
+                    # layout 내 첫 번째 셀에 병합 셀의 값을 표시
+                    merged_value = ws.cell(row=mr_min_row, column=mr_min_col).value
+                    if merged_value is not None:
+                        # layout 내에서 병합 영역의 첫 번째 셀 찾기
+                        first_row_in_layout = max(mr_min_row, layout.min_row)
+                        first_col_in_layout = max(mr_min_col, layout.min_col)
+                        merged_value_override[(first_row_in_layout, first_col_in_layout)] = merged_value
+                    
+                    # layout 내의 병합 영역 나머지 셀들은 건너뛰기
+                    for r in range(max(mr_min_row, layout.min_row), min(mr_max_row, layout.max_row) + 1):
+                        for c in range(max(mr_min_col, layout.min_col), min(mr_max_col, layout.max_col) + 1):
+                            # 값을 표시할 첫 번째 셀은 skip하지 않음
+                            if (r, c) in merged_value_override:
+                                continue
+                            skip_cells.add((r, c))
+
+        # HTML 생성
+        html_parts = ["<table border='1'>"]
+        has_data = False
+
+        for row_idx in range(layout.min_row, layout.max_row + 1):
+            row_parts = ["<tr>"]
+
+            for col_idx in range(layout.min_col, layout.max_col + 1):
+                # 건너뛸 셀 확인 (병합된 영역의 일부)
+                if (row_idx, col_idx) in skip_cells:
+                    continue
+
+                cell = ws.cell(row=row_idx, column=col_idx)
+
+                # 셀 값 추출 (병합 셀 override 확인)
+                cell_value = ""
+                if (row_idx, col_idx) in merged_value_override:
+                    cell_value = str(merged_value_override[(row_idx, col_idx)]).strip()
+                    if cell_value:
+                        has_data = True
+                elif cell.value is not None:
+                    cell_value = str(cell.value).strip()
+                    if cell_value:
+                        has_data = True
+
+                # HTML 이스케이프
+                cell_value = _escape_html(cell_value)
+
+                # 첫 번째 행은 헤더로 처리
+                tag = "th" if row_idx == layout.min_row else "td"
+
+                # 병합 속성
+                attrs = []
+                if (row_idx, col_idx) in merged_cells_info:
+                    rowspan, colspan = merged_cells_info[(row_idx, col_idx)]
+                    if rowspan > 1:
+                        attrs.append(f"rowspan='{rowspan}'")
+                    if colspan > 1:
+                        attrs.append(f"colspan='{colspan}'")
+
+                attr_str = " " + " ".join(attrs) if attrs else ""
+                row_parts.append(f"<{tag}{attr_str}>{cell_value}</{tag}>")
+
+            row_parts.append("</tr>")
+            
+            # 모든 행을 추가 (빈 행도 테이블 구조의 일부)
+            html_parts.append("".join(row_parts))
+
+        html_parts.append("</table>")
+
+        if has_data:
+            return "\n".join(html_parts)
+        return ""
+
+    except Exception as e:
+        logger.warning(f"Error converting sheet to HTML: {e}")
+        return ""
+
+
+def _escape_html(text: str) -> str:
+    """
+    HTML 특수 문자를 이스케이프합니다.
+    
+    Args:
+        text: 원본 텍스트
+        
+    Returns:
+        이스케이프된 텍스트
+    """
+    if not text:
+        return ""
+    
+    text = text.replace("&", "&amp;")
+    text = text.replace("<", "&lt;")
+    text = text.replace(">", "&gt;")
+    text = text.replace("\n", "<br>")
+    
+    return text
+
+
+def convert_xlsx_objects_to_tables(ws, layout: Optional[LayoutRange] = None) -> List[str]:
+    """
+    XLSX 워크시트에서 개별 객체(테이블)를 감지하고 각각을 테이블 문자열로 변환합니다.
+    
+    알고리즘:
+    1. 테두리가 있는 영역을 먼저 개별 개체로 인식
+    2. 테두리가 없는 값 영역을 감지
+    3. 완전히 인접한 개체들을 병합
+    4. 각 객체를 테이블로 변환
+    
+    Args:
+        ws: openpyxl Worksheet 객체
+        layout: 탐색할 레이아웃 범위 (None이면 자동 감지)
+    
+    Returns:
+        개별 객체 테이블 문자열 목록 (위→아래, 왼쪽→오른쪽 순서)
+    """
+    objects = object_detect_xlsx(ws, layout)
+    
+    if not objects:
+        return []
+    
+    tables = []
+    for obj_layout in objects:
+        table_str = convert_xlsx_sheet_to_table(ws, obj_layout)
+        # 빈 테이블 필터링 (공백, 줄바꿈, 테이블 기호만 있는 경우 제외)
+        if table_str and table_str.strip():
+            # Markdown 테이블에서 실제 데이터가 있는지 확인
+            # 헤더 구분선(---)만 있고 데이터가 없는 경우 제외
+            lines = [line.strip() for line in table_str.strip().split('\n') if line.strip()]
+            has_data = False
+            for line in lines:
+                # 구분선이 아닌 행에서 | 사이에 실제 값이 있는지 확인
+                if '---' not in line:
+                    # | col1 | col2 | 형태에서 값 추출
+                    parts = [p.strip() for p in line.split('|') if p.strip()]
+                    if parts:
+                        has_data = True
+                        break
+            
+            if has_data:
+                tables.append(table_str)
+    
+    logger.debug(f"Converted {len(tables)} objects to tables (XLSX)")
+    return tables

xgen_doc2chunk/core/processor/excel_helper/excel_textbox.py

@@ -0,0 +1,266 @@
+"""
+XLSX 텍스트박스 추출 모듈
+
+XLSX 파일의 DrawingML에서 텍스트박스 내용을 추출합니다.
+텍스트박스는 xl/drawings/drawing*.xml에 <xdr:sp> 요소로 저장됩니다.
+"""
+
+import os
+import zipfile
+import logging
+import xml.etree.ElementTree as ET
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# DrawingML 네임스페이스
+NAMESPACES = {
+    'xdr': 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing',
+    'a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
+    'r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    'pkg': 'http://schemas.openxmlformats.org/package/2006/relationships',
+    'ss': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+}
+
+# 네임스페이스 URI 상수
+NS_XDR = '{http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing}'
+NS_A = '{http://schemas.openxmlformats.org/drawingml/2006/main}'
+NS_R = '{http://schemas.openxmlformats.org/officeDocument/2006/relationships}'
+NS_PKG = '{http://schemas.openxmlformats.org/package/2006/relationships}'
+NS_SS = '{http://schemas.openxmlformats.org/spreadsheetml/2006/main}'
+
+
+def extract_textboxes_from_xlsx(file_path: str) -> Dict[str, List[str]]:
+    """
+    XLSX 파일에서 텍스트박스를 추출합니다.
+
+    XLSX의 텍스트박스는 xl/drawings/drawing*.xml 파일에 저장됩니다.
+    DrawingML 형식으로 <xdr:sp> (shape) 요소 내 <xdr:txBody>에 텍스트가 포함됩니다.
+
+    Args:
+        file_path: XLSX 파일 경로
+
+    Returns:
+        {시트명: [텍스트박스 내용 리스트]} 형태의 딕셔너리
+    """
+    textboxes_by_sheet: Dict[str, List[str]] = {}
+
+    try:
+        with zipfile.ZipFile(file_path, 'r') as zf:
+            # 시트와 drawing 관계 매핑 구축
+            sheet_drawing_map = _get_sheet_drawing_mapping(zf)
+            logger.debug(f"Sheet-Drawing mapping: {sheet_drawing_map}")
+
+            # 모든 drawing 파일 처리
+            for name in zf.namelist():
+                if name.startswith('xl/drawings/drawing') and name.endswith('.xml'):
+                    try:
+                        drawing_xml = zf.read(name)
+                        textboxes = _parse_drawing_textboxes(drawing_xml)
+
+                        if textboxes:
+                            # drawing 파일에 해당하는 시트 찾기
+                            drawing_name = os.path.basename(name)
+                            sheet_name = sheet_drawing_map.get(drawing_name, f"Sheet ({drawing_name})")
+
+                            if sheet_name not in textboxes_by_sheet:
+                                textboxes_by_sheet[sheet_name] = []
+                            textboxes_by_sheet[sheet_name].extend(textboxes)
+
+                            logger.info(f"Extracted {len(textboxes)} textboxes from {name} -> {sheet_name}")
+
+                    except Exception as e:
+                        logger.warning(f"Error parsing textboxes from {name}: {e}")
+
+        total_textboxes = sum(len(tb) for tb in textboxes_by_sheet.values())
+        if total_textboxes > 0:
+            logger.info(f"Total extracted {total_textboxes} textboxes from XLSX")
+
+    except Exception as e:
+        logger.warning(f"Error extracting textboxes from XLSX: {e}")
+
+    return textboxes_by_sheet
+
+
+def _get_sheet_drawing_mapping(zf: zipfile.ZipFile) -> Dict[str, str]:
+    """
+    XLSX 내부 관계를 파싱하여 drawing 파일과 시트 이름의 매핑을 구축합니다.
+
+    Args:
+        zf: ZipFile 객체
+
+    Returns:
+        {drawing 파일명: 시트명} 매핑
+    """
+    drawing_to_sheet: Dict[str, str] = {}
+    sheet_rid_map: Dict[str, str] = {}  # rId -> sheet_name
+    rid_to_sheet_file: Dict[str, str] = {}  # rId -> sheet파일경로
+
+    try:
+        # 1. workbook.xml에서 시트 정보 추출 (rId -> sheet_name)
+        if 'xl/workbook.xml' in zf.namelist():
+            workbook_xml = zf.read('xl/workbook.xml')
+            wb_root = ET.fromstring(workbook_xml)
+
+            for sheet_elem in wb_root.findall(f'.//{NS_SS}sheet'):
+                sheet_name = sheet_elem.get('name', '')
+                r_id = sheet_elem.get(f'{NS_R}id', '')
+                if sheet_name and r_id:
+                    sheet_rid_map[r_id] = sheet_name
+
+        # 2. workbook.xml.rels에서 rId -> sheet*.xml 매핑
+        if 'xl/_rels/workbook.xml.rels' in zf.namelist():
+            rels_xml = zf.read('xl/_rels/workbook.xml.rels')
+            rels_root = ET.fromstring(rels_xml)
+
+            for rel_elem in rels_root.findall(f'.//{NS_PKG}Relationship'):
+                r_id = rel_elem.get('Id', '')
+                target = rel_elem.get('Target', '')
+                if 'worksheets/sheet' in target:
+                    rid_to_sheet_file[r_id] = target
+
+        # 3. sheet파일 -> sheet_name 매핑
+        sheet_file_to_name: Dict[str, str] = {}
+        for r_id, sheet_name in sheet_rid_map.items():
+            if r_id in rid_to_sheet_file:
+                sheet_file = rid_to_sheet_file[r_id]
+                # worksheets/sheet1.xml -> sheet1.xml
+                sheet_file_base = os.path.basename(sheet_file)
+                sheet_file_to_name[sheet_file_base] = sheet_name
+
+        # 4. 각 sheet*.xml.rels에서 drawing 관계 찾기
+        for name in zf.namelist():
+            if name.startswith('xl/worksheets/_rels/sheet') and name.endswith('.xml.rels'):
+                try:
+                    rels_xml = zf.read(name)
+                    rels_root = ET.fromstring(rels_xml)
+
+                    # sheet*.xml.rels -> sheet*.xml
+                    sheet_file = os.path.basename(name).replace('.rels', '')
+                    sheet_name = sheet_file_to_name.get(sheet_file, sheet_file)
+
+                    for rel_elem in rels_root.findall(f'.//{NS_PKG}Relationship'):
+                        target = rel_elem.get('Target', '')
+                        if 'drawings/drawing' in target:
+                            # ../drawings/drawing1.xml -> drawing1.xml
+                            drawing_file = os.path.basename(target)
+                            drawing_to_sheet[drawing_file] = sheet_name
+                            logger.debug(f"Mapped {drawing_file} -> {sheet_name}")
+
+                except Exception as e:
+                    logger.debug(f"Error parsing sheet rels {name}: {e}")
+
+    except Exception as e:
+        logger.debug(f"Error building sheet-drawing mapping: {e}")
+
+    return drawing_to_sheet
+
+
+def _parse_drawing_textboxes(drawing_xml: bytes) -> List[str]:
+    """
+    DrawingML XML에서 텍스트박스 내용을 추출합니다.
+
+    Args:
+        drawing_xml: drawing XML 바이트
+
+    Returns:
+        텍스트박스 내용 리스트
+    """
+    textboxes: List[str] = []
+
+    try:
+        # XML 파싱
+        try:
+            root = ET.fromstring(drawing_xml)
+        except ET.ParseError:
+            # BOM 제거 후 재시도
+            drawing_str = drawing_xml.decode('utf-8-sig', errors='ignore')
+            root = ET.fromstring(drawing_str)
+
+        # 모든 shape 요소 직접 찾기 (<xdr:sp>)
+        # 전체 문서에서 모든 sp 요소 탐색
+        sp_elems = root.findall(f'.//{NS_XDR}sp')
+        logger.debug(f"Found {len(sp_elems)} shape elements in drawing")
+
+        for sp in sp_elems:
+            textbox_content = _extract_textbox_content(sp)
+            if textbox_content:
+                textboxes.append(textbox_content)
+                logger.debug(f"Extracted textbox: {textbox_content[:50]}...")
+
+    except Exception as e:
+        logger.warning(f"Error parsing drawing textboxes: {e}")
+
+    return textboxes
+
+
+def _extract_textbox_content(sp_elem) -> Optional[str]:
+    """
+    Shape 요소에서 텍스트박스 내용을 추출합니다.
+
+    XLSX의 텍스트박스 구조:
+    <xdr:sp>
+        <xdr:nvSpPr>...</xdr:nvSpPr>
+        <xdr:spPr>...</xdr:spPr>
+        <xdr:txBody>  <-- 직접 자식! (.//가 아님)
+            <a:p>
+                <a:r>
+                    <a:t>텍스트</a:t>
+                </a:r>
+            </a:p>
+        </xdr:txBody>
+    </xdr:sp>
+
+    Args:
+        sp_elem: shape XML 요소
+
+    Returns:
+        텍스트박스 내용 (없으면 None)
+    """
+    try:
+        # txBody 요소 찾기 - xdr 네임스페이스의 직접 자식으로 찾기
+        txBody = sp_elem.find(f'{NS_XDR}txBody')
+
+        if txBody is None:
+            return None
+
+        # 모든 텍스트 추출
+        text_parts: List[str] = []
+
+        # 각 paragraph (a:p) 처리
+        paragraphs = txBody.findall(f'.//{NS_A}p')
+
+        for p_elem in paragraphs:
+            para_texts: List[str] = []
+
+            # 각 run (a:r) 내의 텍스트 (a:t) 찾기
+            runs = p_elem.findall(f'.//{NS_A}r')
+
+            for r_elem in runs:
+                # a:t는 a:r의 직접 자식
+                t_elem = r_elem.find(f'{NS_A}t')
+
+                if t_elem is not None and t_elem.text:
+                    para_texts.append(t_elem.text)
+
+            # run 없이 직접 a:t가 있는 경우도 처리
+            if not para_texts:
+                t_elems = p_elem.findall(f'.//{NS_A}t')
+                for t_elem in t_elems:
+                    if t_elem is not None and t_elem.text:
+                        para_texts.append(t_elem.text)
+
+            if para_texts:
+                text_parts.append(''.join(para_texts))
+
+        if text_parts:
+            # 줄바꿈으로 문단 구분
+            full_text = '\n'.join(text_parts).strip()
+            if full_text:
+                return full_text
+
+        return None
+
+    except Exception as e:
+        logger.debug(f"Error extracting textbox content: {e}")
+        return None

xgen_doc2chunk/core/processor/html_helper/__init__.py

@@ -0,0 +1,7 @@
+# xgen_doc2chunk/core/processor/html_helper/__init__.py
+"""HTML helper module for HTML file processing."""
+
+from xgen_doc2chunk.core.processor.html_helper.html_file_converter import HTMLFileConverter
+
+__all__ = ['HTMLFileConverter']
+