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

xgen_doc2chunk/core/processor/ppt_helper/ppt_table.py

@@ -0,0 +1,386 @@
+"""
+PPT 테이블 처리 모듈
+
+포함 함수:
+- is_simple_table(): 단순 표인지 확인
+- extract_simple_table_as_text(): 단순 표를 텍스트로 추출
+- convert_table_to_html(): 테이블을 HTML로 변환 (병합 지원)
+- extract_table_as_text(): 테이블을 평문으로 추출
+
+병합 셀(rowspan, colspan) 정확히 처리
+"""
+import logging
+from typing import Dict
+
+logger = logging.getLogger("document-processor")
+
+
+def is_simple_table(table) -> bool:
+    """
+    단순 표인지 확인합니다.
+    
+    단순 표 조건:
+    - 행 또는 열 중 하나라도 1개인 경우 (1xN, Nx1)
+    
+    이런 표는 텍스트박스처럼 사용되는 경우가 많아 HTML 테이블 대신 일반 텍스트로 처리합니다.
+    
+    Args:
+        table: python-pptx의 Table 객체
+        
+    Returns:
+        True면 단순 표 (텍스트로 처리), False면 일반 표 (HTML로 처리)
+    """
+    try:
+        num_rows = len(table.rows)
+        num_cols = len(table.columns)
+        
+        # 행 또는 열이 1개인 경우 (1xN, Nx1)
+        if num_rows == 1 or num_cols == 1:
+            return True
+        
+        return False
+    except Exception:
+        return False
+
+
+def extract_simple_table_as_text(table) -> str:
+    """
+    단순 표(1xN, Nx1, 2x2 이하)를 일반 텍스트로 추출합니다.
+    
+    Args:
+        table: python-pptx의 Table 객체
+        
+    Returns:
+        줄바꿈으로 구분된 텍스트
+    """
+    try:
+        texts = []
+        for row in table.rows:
+            row_texts = []
+            for cell in row.cells:
+                cell_text = cell.text.strip() if cell.text else ""
+                if cell_text:
+                    row_texts.append(cell_text)
+            if row_texts:
+                # 한 행의 셀들은 공백으로 구분
+                texts.append(" ".join(row_texts))
+        
+        # 행들은 줄바꿈으로 구분
+        return "\n".join(texts) if texts else ""
+    except Exception:
+        return ""
+
+
+def convert_table_to_html(table) -> str:
+    """
+    테이블을 HTML 형식으로 변환합니다.
+    병합된 셀(rowspan, colspan)을 정확히 처리합니다.
+    
+    Args:
+        table: python-pptx의 Table 객체
+        
+    Returns:
+        HTML 테이블 문자열
+    """
+    try:
+        num_rows = len(table.rows)
+        num_cols = len(table.columns)
+        
+        if num_rows == 0 or num_cols == 0:
+            return ""
+        
+        # 병합 정보를 저장할 2D 배열
+        # None: 아직 처리 안됨, 'skip': 병합으로 인해 스킵할 셀
+        cell_info = [[None for _ in range(num_cols)] for _ in range(num_rows)]
+        
+        # 1단계: 병합 정보 수집
+        for row_idx in range(num_rows):
+            for col_idx in range(num_cols):
+                if cell_info[row_idx][col_idx] == 'skip':
+                    continue
+                
+                cell = table.cell(row_idx, col_idx)
+                
+                # 병합 정보 추출
+                merge_info = _get_cell_merge_info(cell, table, row_idx, col_idx, num_rows, num_cols)
+                
+                rowspan = merge_info['rowspan']
+                colspan = merge_info['colspan']
+                
+                # 병합된 영역의 다른 셀들을 'skip'으로 표시
+                for r in range(row_idx, min(row_idx + rowspan, num_rows)):
+                    for c in range(col_idx, min(col_idx + colspan, num_cols)):
+                        if r == row_idx and c == col_idx:
+                            # 시작 셀에는 병합 정보 저장
+                            cell_info[r][c] = {
+                                'rowspan': rowspan,
+                                'colspan': colspan,
+                                'text': cell.text.strip() if cell.text else ""
+                            }
+                        else:
+                            cell_info[r][c] = 'skip'
+        
+        # 2단계: HTML 생성
+        html_parts = ["<table border='1'>"]
+        
+        for row_idx in range(num_rows):
+            html_parts.append("<tr>")
+            
+            for col_idx in range(num_cols):
+                info = cell_info[row_idx][col_idx]
+                
+                # 병합으로 스킵할 셀
+                if info == 'skip':
+                    continue
+                
+                # 셀 정보가 없으면 기본값
+                if info is None:
+                    cell = table.cell(row_idx, col_idx)
+                    info = {
+                        'rowspan': 1,
+                        'colspan': 1,
+                        'text': cell.text.strip() if cell.text else ""
+                    }
+                
+                # 태그 결정 (첫 행은 th, 나머지는 td)
+                tag = "th" if row_idx == 0 else "td"
+                
+                # 속성 생성
+                attrs = []
+                if info['rowspan'] > 1:
+                    attrs.append(f"rowspan='{info['rowspan']}'")
+                if info['colspan'] > 1:
+                    attrs.append(f"colspan='{info['colspan']}'")
+                
+                attr_str = " " + " ".join(attrs) if attrs else ""
+                
+                # 텍스트 이스케이프
+                text = _escape_html(info['text'])
+                
+                html_parts.append(f"<{tag}{attr_str}>{text}</{tag}>")
+            
+            html_parts.append("</tr>")
+        
+        html_parts.append("</table>")
+        
+        return "\n".join(html_parts)
+    
+    except Exception as e:
+        logger.warning(f"Error converting table to HTML: {e}")
+        return extract_table_as_text(table)
+
+
+def extract_table_as_text(table) -> str:
+    """
+    테이블을 평문 형식으로 추출합니다.
+    
+    Args:
+        table: python-pptx의 Table 객체
+        
+    Returns:
+        파이프(|)로 구분된 텍스트
+    """
+    try:
+        rows_text = []
+        for row in table.rows:
+            row_cells = []
+            for cell in row.cells:
+                cell_text = cell.text.strip() if cell.text else ""
+                row_cells.append(cell_text)
+            if any(c for c in row_cells):
+                rows_text.append(" | ".join(row_cells))
+
+        return "\n".join(rows_text) if rows_text else ""
+
+    except Exception:
+        return ""
+
+
+def _get_cell_merge_info(cell, table, row_idx: int, col_idx: int, 
+                         num_rows: int, num_cols: int) -> Dict[str, int]:
+    """
+    셀의 병합 정보를 추출합니다.
+    
+    python-pptx에서 병합 셀을 감지하는 방법:
+    1. cell.is_merge_origin: 병합의 시작점인지
+    2. cell.is_spanned: 다른 셀에 의해 병합된 셀인지
+    3. cell.span_height: 세로 병합 크기
+    4. cell.span_width: 가로 병합 크기
+    
+    Args:
+        cell: 테이블 셀 객체
+        table: 테이블 객체
+        row_idx: 현재 행 인덱스
+        col_idx: 현재 열 인덱스
+        num_rows: 총 행 수
+        num_cols: 총 열 수
+        
+    Returns:
+        {'rowspan': int, 'colspan': int}
+    """
+    rowspan = 1
+    colspan = 1
+    
+    try:
+        # 방법 1: python-pptx의 내장 속성 사용 (권장)
+        if hasattr(cell, 'is_merge_origin') and cell.is_merge_origin:
+            # 병합의 시작 셀
+            if hasattr(cell, 'span_height'):
+                rowspan = cell.span_height
+            if hasattr(cell, 'span_width'):
+                colspan = cell.span_width
+            return {'rowspan': rowspan, 'colspan': colspan}
+        
+        # 이미 병합된 셀 (다른 셀에 의해 덮어진 경우) - 스킵 대상
+        if hasattr(cell, 'is_spanned') and cell.is_spanned:
+            return {'rowspan': 0, 'colspan': 0}  # 스킵 표시
+        
+        # 방법 2: XML 직접 파싱 (폴백)
+        tc = cell._tc
+        
+        # gridSpan 속성 (가로 병합)
+        grid_span = tc.get('gridSpan')
+        if grid_span:
+            colspan = int(grid_span)
+        
+        # rowSpan 속성 (세로 병합)
+        row_span_attr = tc.get('rowSpan')
+        if row_span_attr:
+            rowspan = int(row_span_attr)
+        
+        # 방법 3: 동일 셀 참조 비교 (추가 폴백)
+        if colspan == 1:
+            colspan = _detect_colspan_by_reference(table, row_idx, col_idx, num_cols)
+        
+        if rowspan == 1:
+            rowspan = _detect_rowspan_by_reference(table, row_idx, col_idx, num_rows)
+    
+    except Exception as e:
+        logger.debug(f"Error getting merge info: {e}")
+    
+    return {'rowspan': rowspan, 'colspan': colspan}
+
+
+def _detect_colspan_by_reference(table, row_idx: int, col_idx: int, num_cols: int) -> int:
+    """
+    셀 참조 비교로 colspan을 감지합니다.
+    
+    Args:
+        table: 테이블 객체
+        row_idx: 현재 행 인덱스
+        col_idx: 현재 열 인덱스
+        num_cols: 총 열 수
+        
+    Returns:
+        colspan 값
+    """
+    colspan = 1
+    try:
+        current_cell = table.cell(row_idx, col_idx)
+        
+        for c in range(col_idx + 1, num_cols):
+            next_cell = table.cell(row_idx, c)
+            
+            # _tc 참조가 같으면 병합된 셀
+            if next_cell._tc is current_cell._tc:
+                colspan += 1
+            else:
+                break
+    except Exception:
+        pass
+    
+    return colspan
+
+
+def _detect_rowspan_by_reference(table, row_idx: int, col_idx: int, num_rows: int) -> int:
+    """
+    셀 참조 비교로 rowspan을 감지합니다.
+    
+    Args:
+        table: 테이블 객체
+        row_idx: 현재 행 인덱스
+        col_idx: 현재 열 인덱스
+        num_rows: 총 행 수
+        
+    Returns:
+        rowspan 값
+    """
+    rowspan = 1
+    try:
+        current_cell = table.cell(row_idx, col_idx)
+        
+        for r in range(row_idx + 1, num_rows):
+            next_cell = table.cell(r, col_idx)
+            
+            if next_cell._tc is current_cell._tc:
+                rowspan += 1
+            else:
+                break
+    except Exception:
+        pass
+    
+    return rowspan
+
+
+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 debug_table_structure(table):
+    """
+    테이블 구조를 디버깅합니다.
+    병합 정보 확인을 위해 사용합니다.
+    
+    Args:
+        table: python-pptx의 Table 객체
+    """
+    logger.debug("=== Table Structure Debug ===")
+    logger.debug(f"Rows: {len(table.rows)}, Cols: {len(table.columns)}")
+    
+    for row_idx in range(len(table.rows)):
+        for col_idx in range(len(table.columns)):
+            try:
+                cell = table.cell(row_idx, col_idx)
+                tc = cell._tc
+                
+                # XML 속성 확인
+                grid_span = tc.get('gridSpan', '1')
+                row_span = tc.get('rowSpan', '1')
+                
+                # python-pptx 속성 확인
+                is_merge_origin = getattr(cell, 'is_merge_origin', None)
+                is_spanned = getattr(cell, 'is_spanned', None)
+                span_width = getattr(cell, 'span_width', None)
+                span_height = getattr(cell, 'span_height', None)
+                
+                text_preview = cell.text[:20] if cell.text else ""
+                
+                logger.debug(
+                    f"[{row_idx},{col_idx}] "
+                    f"text='{text_preview}' "
+                    f"gridSpan={grid_span} rowSpan={row_span} "
+                    f"is_merge_origin={is_merge_origin} "
+                    f"is_spanned={is_spanned} "
+                    f"span_width={span_width} span_height={span_height}"
+                )
+            except Exception as e:
+                logger.debug(f"[{row_idx},{col_idx}] Error: {e}")
+    
+    logger.debug("=== End Debug ===")

xgen_doc2chunk/core/processor/rtf_handler.py

@@ -0,0 +1,290 @@
+# xgen_doc2chunk/core/processor/rtf_handler.py
+"""
+RTF Handler
+
+Class-based handler for RTF files.
+Follows the correct architecture:
+1. Converter: Pass through (RTF uses raw binary)
+2. Preprocessor: Binary preprocessing (image extraction, \\bin removal)
+3. Handler: Sequential processing (metadata ??tables ??content ??result)
+"""
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+from striprtf.striprtf import rtf_to_text
+
+from xgen_doc2chunk.core.processor.base_handler import BaseHandler
+from xgen_doc2chunk.core.functions.img_processor import ImageProcessor
+from xgen_doc2chunk.core.functions.chart_extractor import BaseChartExtractor, NullChartExtractor
+
+# Import from rtf_helper
+from xgen_doc2chunk.core.processor.rtf_helper import (
+    RTFFileConverter,
+    RTFConvertedData,
+    RTFMetadataExtractor,
+    RTFSourceInfo,
+    RTFPreprocessor,
+    extract_tables_with_positions,
+    extract_inline_content,
+    extract_text_only,
+    decode_content,
+    detect_encoding,
+)
+
+if TYPE_CHECKING:
+    from xgen_doc2chunk.core.document_processor import CurrentFile
+
+logger = logging.getLogger("xgen_doc2chunk.rtf.handler")
+
+
+class RTFHandler(BaseHandler):
+    """
+    RTF Document Processing Handler.
+
+    Processing flow:
+    1. file_converter.convert() ??bytes (pass through)
+    2. preprocessor.preprocess() ??PreprocessedData (image extraction, binary cleanup)
+    3. decode content ??string
+    4. metadata_extractor.extract() ??DocumentMetadata
+    5. extract_tables_with_positions() ??List[RTFTable]
+    6. extract_inline_content() ??str
+    7. Build result string
+    """
+
+    def _create_file_converter(self) -> RTFFileConverter:
+        """Create RTF-specific file converter."""
+        return RTFFileConverter()
+
+    def _create_preprocessor(self) -> RTFPreprocessor:
+        """Create RTF-specific preprocessor."""
+        return RTFPreprocessor()
+
+    def _create_chart_extractor(self) -> BaseChartExtractor:
+        """RTF files do not contain charts. Return NullChartExtractor."""
+        return NullChartExtractor(self._chart_processor)
+
+    def _create_metadata_extractor(self) -> RTFMetadataExtractor:
+        """Create RTF-specific metadata extractor."""
+        return RTFMetadataExtractor()
+
+    def _create_format_image_processor(self) -> ImageProcessor:
+        """Create RTF-specific image processor (use base for now)."""
+        return self._image_processor
+
+    def extract_text(
+        self,
+        current_file: "CurrentFile",
+        extract_metadata: bool = True,
+        **kwargs
+    ) -> str:
+        """
+        Extract text from RTF file.
+
+        Args:
+            current_file: CurrentFile dict containing file info and binary data
+            extract_metadata: Whether to extract metadata
+            **kwargs: Additional options
+
+        Returns:
+            Extracted text
+        """
+        file_path = current_file.get("file_path", "unknown")
+        file_data = current_file.get("file_data", b"")
+
+        self.logger.info(f"RTF processing: {file_path}")
+
+        if not file_data:
+            self.logger.error(f"Empty file data: {file_path}")
+            return f"[RTF file is empty: {file_path}]"
+
+        # Validate RTF format
+        if not file_data.strip().startswith(b'{\\rtf'):
+            self.logger.warning(f"Invalid RTF format: {file_path}")
+            return self._extract_fallback(file_data, extract_metadata)
+
+        try:
+            # Step 1: Converter - pass through (RTF uses raw binary)
+            raw_data: bytes = self.file_converter.convert(file_data)
+
+            # Step 2: Preprocessor - extract images, remove binary data
+            output_dir = self._get_output_dir(file_path)
+            doc_name = Path(file_path).stem if file_path != "unknown" else "document"
+
+            preprocessed = self.preprocessor.preprocess(
+                raw_data,
+                output_dir=output_dir,
+                doc_name=doc_name,
+            )
+
+            clean_content = preprocessed.clean_content
+            image_tags = preprocessed.extracted_resources.get("image_tags", [])
+            encoding = preprocessed.encoding or "cp949"
+
+            # Step 3: Decode to string if still bytes
+            if isinstance(clean_content, bytes):
+                encoding = detect_encoding(clean_content) or encoding
+                content = decode_content(clean_content, encoding)
+            else:
+                content = clean_content
+
+            # Build RTFConvertedData for downstream processing
+            converted = RTFConvertedData(
+                content=content,
+                encoding=encoding,
+                image_tags=image_tags,
+                original_size=len(file_data),
+            )
+
+            self.logger.debug(
+                f"RTF preprocessed: encoding={encoding}, "
+                f"images={len(image_tags)}, size={len(file_data)}"
+            )
+
+            # Step 4: Extract content
+            return self._extract_from_converted(
+                converted,
+                current_file,
+                extract_metadata,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error in RTF processing: {e}", exc_info=True)
+            return self._extract_fallback(file_data, extract_metadata)
+
+    def _extract_from_converted(
+        self,
+        converted: RTFConvertedData,
+        current_file: "CurrentFile",
+        extract_metadata: bool,
+    ) -> str:
+        """
+        Internal method to extract content from RTFConvertedData.
+
+        Args:
+            converted: RTFConvertedData object
+            current_file: CurrentFile dict
+            extract_metadata: Whether to extract metadata
+
+        Returns:
+            Extracted text
+        """
+        content = converted.content
+        encoding = converted.encoding
+
+        result_parts = []
+
+        # Step 2: Extract metadata
+        if extract_metadata:
+            source = RTFSourceInfo(content=content, encoding=encoding)
+            metadata = self.metadata_extractor.extract(source)
+            metadata_str = self.metadata_extractor.format(metadata)
+            if metadata_str:
+                result_parts.append(metadata_str + "\n\n")
+
+        # Add page tag
+        page_tag = self.create_page_tag(1)
+        result_parts.append(f"{page_tag}\n")
+
+        # Step 3: Extract tables with positions
+        tables, table_regions = extract_tables_with_positions(content, encoding)
+
+        # Step 4: Extract inline content (preserves table positions)
+        inline_content = extract_inline_content(content, table_regions, encoding)
+
+        if inline_content:
+            result_parts.append(inline_content)
+        else:
+            # Fallback: separate text and tables
+            text_only = extract_text_only(content, encoding)
+            if text_only:
+                result_parts.append(text_only)
+
+            for table in tables:
+                if not table.rows:
+                    continue
+                if table.is_real_table():
+                    result_parts.append("\n" + table.to_html() + "\n")
+                else:
+                    result_parts.append("\n" + table.to_text_list() + "\n")
+
+        # Step 5: Add image tags
+        if converted.image_tags:
+            result_parts.append("\n")
+            for tag in converted.image_tags:
+                result_parts.append(tag + "\n")
+
+        result = "\n".join(result_parts)
+
+        # Clean up invalid image tags
+        result = re.sub(r'\[image:[^\]]*uploads/\.[^\]]*\]', '', result)
+
+        return result
+
+    def _extract_fallback(
+        self,
+        file_data: bytes,
+        extract_metadata: bool,
+    ) -> str:
+        """
+        Fallback extraction using striprtf library.
+
+        Args:
+            file_data: Raw binary data
+            extract_metadata: Whether to extract metadata
+
+        Returns:
+            Extracted text
+        """
+        # Try different encodings
+        content = None
+        for encoding in ['utf-8', 'cp949', 'euc-kr', 'cp1252', 'latin-1']:
+            try:
+                content = file_data.decode(encoding)
+                break
+            except (UnicodeDecodeError, UnicodeError):
+                continue
+
+        if content is None:
+            content = file_data.decode('cp1252', errors='replace')
+
+        result_parts = []
+
+        # Extract metadata from raw content
+        if extract_metadata:
+            source = RTFSourceInfo(content=content, encoding='cp1252')
+            metadata = self.metadata_extractor.extract(source)
+            metadata_str = self.extract_and_format_metadata(metadata)
+            if metadata_str:
+                result_parts.append(metadata_str + "\n\n")
+
+        # Add page tag
+        page_tag = self.create_page_tag(1)
+        result_parts.append(f"{page_tag}\n")
+
+        # Extract text using striprtf
+        try:
+            text = rtf_to_text(content)
+        except Exception:
+            # Manual cleanup
+            text = re.sub(r'\\[a-z]+\d*\s?', '', content)
+            text = re.sub(r"\\'[0-9a-fA-F]{2}", '', text)
+            text = re.sub(r'[{}]', '', text)
+
+        if text:
+            text = re.sub(r'\n{3,}', '\n\n', text)
+            result_parts.append(text.strip())
+
+        return "\n".join(result_parts)
+
+    def _get_output_dir(self, file_path: str) -> Optional[Path]:
+        """Get output directory for images."""
+        if hasattr(self._image_processor, 'config'):
+            dir_path = self._image_processor.config.directory_path
+            if dir_path:
+                return Path(dir_path)
+        return None
+
+
+__all__ = ['RTFHandler']