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

xgen_doc2chunk/core/processor/ppt_helper/ppt_image_processor.py

@@ -0,0 +1,196 @@
+# xgen_doc2chunk/core/processor/ppt_helper/ppt_image_processor.py
+"""
+PPT Image Processor
+
+Provides PPT/PPTX-specific image processing that inherits from ImageProcessor.
+Handles slide images, shape images, and embedded pictures.
+"""
+import logging
+from typing import Any, Dict, Optional, Set, TYPE_CHECKING
+
+from xgen_doc2chunk.core.functions.img_processor import ImageProcessor
+from xgen_doc2chunk.core.functions.storage_backend import BaseStorageBackend
+
+if TYPE_CHECKING:
+    from pptx import Presentation
+    from pptx.slide import Slide
+    from pptx.shapes.base import BaseShape
+
+logger = logging.getLogger("xgen_doc2chunk.image_processor.ppt")
+
+
+class PPTImageProcessor(ImageProcessor):
+    """
+    PPT/PPTX-specific image processor.
+    
+    Inherits from ImageProcessor and provides PPT-specific processing.
+    
+    Handles:
+    - Picture shapes
+    - Embedded images
+    - Group shape images
+    - Background images
+    
+    Example:
+        processor = PPTImageProcessor()
+        
+        # Process slide image
+        tag = processor.process_image(image_data, slide_num=1)
+        
+        # Process from shape
+        tag = processor.process_picture_shape(shape)
+    """
+    
+    def __init__(
+        self,
+        directory_path: str = "temp/images",
+        tag_prefix: str = "[Image:",
+        tag_suffix: str = "]",
+        storage_backend: Optional[BaseStorageBackend] = None,
+    ):
+        """
+        Initialize PPTImageProcessor.
+        
+        Args:
+            directory_path: Image save directory
+            tag_prefix: Tag prefix for image references
+            tag_suffix: Tag suffix for image references
+            storage_backend: Storage backend for saving images
+        """
+        super().__init__(
+            directory_path=directory_path,
+            tag_prefix=tag_prefix,
+            tag_suffix=tag_suffix,
+            storage_backend=storage_backend,
+        )
+    
+    def process_image(
+        self,
+        image_data: bytes,
+        slide_num: Optional[int] = None,
+        shape_id: Optional[int] = None,
+        **kwargs
+    ) -> Optional[str]:
+        """
+        Process and save PPT image data.
+        
+        Args:
+            image_data: Raw image binary data
+            slide_num: Source slide number (for naming)
+            shape_id: Shape ID (for naming)
+            **kwargs: Additional options
+            
+        Returns:
+            Image tag string, or None on failure
+        """
+        custom_name = None
+        if slide_num is not None:
+            if shape_id is not None:
+                custom_name = f"ppt_slide{slide_num}_shape{shape_id}"
+            else:
+                custom_name = f"ppt_slide{slide_num}"
+        elif shape_id is not None:
+            custom_name = f"ppt_shape{shape_id}"
+        
+        return self.save_image(image_data, custom_name=custom_name)
+    
+    def process_picture_shape(
+        self,
+        shape: "BaseShape",
+        slide_num: Optional[int] = None,
+    ) -> Optional[str]:
+        """
+        Process python-pptx picture shape.
+        
+        Args:
+            shape: Picture shape object
+            slide_num: Source slide number
+            
+        Returns:
+            Image tag string, or None on failure
+        """
+        try:
+            if not hasattr(shape, 'image'):
+                return None
+            
+            image = shape.image
+            image_data = image.blob
+            
+            if not image_data:
+                return None
+            
+            shape_id = shape.shape_id if hasattr(shape, 'shape_id') else None
+            
+            return self.process_image(
+                image_data,
+                slide_num=slide_num,
+                shape_id=shape_id
+            )
+            
+        except Exception as e:
+            self._logger.warning(f"Failed to process picture shape: {e}")
+            return None
+    
+    def process_embedded_image(
+        self,
+        image_data: bytes,
+        image_name: Optional[str] = None,
+        slide_num: Optional[int] = None,
+        **kwargs
+    ) -> Optional[str]:
+        """
+        Process embedded PPT image.
+        
+        Args:
+            image_data: Image binary data
+            image_name: Original image filename
+            slide_num: Source slide number
+            **kwargs: Additional options
+            
+        Returns:
+            Image tag string, or None on failure
+        """
+        custom_name = image_name
+        if custom_name is None and slide_num is not None:
+            custom_name = f"ppt_embed_slide{slide_num}"
+        
+        return self.save_image(image_data, custom_name=custom_name)
+    
+    def process_group_shape_images(
+        self,
+        group_shape: "BaseShape",
+        slide_num: Optional[int] = None,
+    ) -> list:
+        """
+        Process all images in a group shape.
+        
+        Args:
+            group_shape: Group shape containing other shapes
+            slide_num: Source slide number
+            
+        Returns:
+            List of image tags
+        """
+        tags = []
+        
+        try:
+            if not hasattr(group_shape, 'shapes'):
+                return tags
+            
+            for shape in group_shape.shapes:
+                if hasattr(shape, 'image'):
+                    tag = self.process_picture_shape(shape, slide_num)
+                    if tag:
+                        tags.append(tag)
+                elif hasattr(shape, 'shapes'):
+                    # Nested group
+                    nested_tags = self.process_group_shape_images(shape, slide_num)
+                    tags.extend(nested_tags)
+                    
+        except Exception as e:
+            self._logger.warning(f"Failed to process group shape: {e}")
+        
+        return tags
+
+
+__all__ = ["PPTImageProcessor"]

xgen_doc2chunk/core/processor/ppt_helper/ppt_metadata.py

@@ -0,0 +1,71 @@
+# xgen_doc2chunk/core/processor/ppt_helper/ppt_metadata.py
+"""
+PPT Metadata Extraction Module
+
+Provides PPTMetadataExtractor class for extracting metadata from PowerPoint documents.
+Implements BaseMetadataExtractor interface.
+"""
+import logging
+from typing import Any, Optional
+
+from pptx import Presentation
+
+from xgen_doc2chunk.core.functions.metadata_extractor import (
+    BaseMetadataExtractor,
+    DocumentMetadata,
+)
+
+logger = logging.getLogger("document-processor")
+
+
+class PPTMetadataExtractor(BaseMetadataExtractor):
+    """
+    PPT/PPTX Metadata Extractor.
+    
+    Extracts metadata from python-pptx Presentation objects.
+    
+    Supported fields:
+    - title, subject, author, keywords, comments
+    - last_saved_by, create_time, last_saved_time
+    
+    Usage:
+        extractor = PPTMetadataExtractor()
+        metadata = extractor.extract(presentation)
+        text = extractor.format(metadata)
+    """
+    
+    def extract(self, source: Presentation) -> DocumentMetadata:
+        """
+        Extract metadata from PPT document.
+        
+        Args:
+            source: python-pptx Presentation object
+            
+        Returns:
+            DocumentMetadata instance containing extracted metadata.
+        """
+        try:
+            props = source.core_properties
+            
+            return DocumentMetadata(
+                title=self._get_value(props.title),
+                subject=self._get_value(props.subject),
+                author=self._get_value(props.author),
+                keywords=self._get_value(props.keywords),
+                comments=self._get_value(props.comments),
+                last_saved_by=self._get_value(props.last_modified_by),
+                create_time=props.created,
+                last_saved_time=props.modified,
+            )
+        except Exception as e:
+            self.logger.warning(f"Failed to extract PPT metadata: {e}")
+            return DocumentMetadata()
+    
+    def _get_value(self, value: Optional[str]) -> Optional[str]:
+        """Return value if present, None otherwise."""
+        return value if value else None
+
+
+__all__ = [
+    'PPTMetadataExtractor',
+]

xgen_doc2chunk/core/processor/ppt_helper/ppt_preprocessor.py

@@ -0,0 +1,77 @@
+# xgen_doc2chunk/core/processor/ppt_helper/ppt_preprocessor.py
+"""
+PPT Preprocessor - Process PPT/PPTX presentation after conversion.
+
+Processing Pipeline Position:
+    1. PPTFileConverter.convert() ??pptx.Presentation
+    2. PPTPreprocessor.preprocess() ??PreprocessedData (THIS STEP)
+    3. PPTMetadataExtractor.extract() ??DocumentMetadata
+    4. Content extraction (slides, shapes, images, charts)
+
+Current Implementation:
+    - Pass-through (PPT uses python-pptx Presentation object directly)
+"""
+import logging
+from typing import Any, Dict
+
+from xgen_doc2chunk.core.functions.preprocessor import (
+    BasePreprocessor,
+    PreprocessedData,
+)
+
+logger = logging.getLogger("xgen_doc2chunk.ppt.preprocessor")
+
+
+class PPTPreprocessor(BasePreprocessor):
+    """
+    PPT/PPTX Presentation Preprocessor.
+
+    Currently a pass-through implementation as PPT processing
+    is handled during the content extraction phase using python-pptx.
+    """
+
+    def preprocess(
+        self,
+        converted_data: Any,
+        **kwargs
+    ) -> PreprocessedData:
+        """
+        Preprocess the converted PPT presentation.
+
+        Args:
+            converted_data: pptx.Presentation object from PPTFileConverter
+            **kwargs: Additional options
+
+        Returns:
+            PreprocessedData with the presentation and any extracted resources
+        """
+        metadata: Dict[str, Any] = {}
+
+        if hasattr(converted_data, 'slides'):
+            metadata['slide_count'] = len(converted_data.slides)
+
+        if hasattr(converted_data, 'slide_width'):
+            metadata['slide_width'] = converted_data.slide_width
+            metadata['slide_height'] = converted_data.slide_height
+
+        logger.debug("PPT preprocessor: pass-through, metadata=%s", metadata)
+
+        # clean_content is the TRUE SOURCE - contains the Presentation
+        return PreprocessedData(
+            raw_content=converted_data,
+            clean_content=converted_data,  # TRUE SOURCE - pptx.Presentation
+            encoding="utf-8",
+            extracted_resources={},
+            metadata=metadata,
+        )
+
+    def get_format_name(self) -> str:
+        """Return format name."""
+        return "PPT Preprocessor"
+
+    def validate(self, data: Any) -> bool:
+        """Validate if data is a PPT Presentation object."""
+        return hasattr(data, 'slides') and hasattr(data, 'slide_layouts')
+
+
+__all__ = ['PPTPreprocessor']

xgen_doc2chunk/core/processor/ppt_helper/ppt_shape.py

@@ -0,0 +1,189 @@
+"""
+PPT Shape 처리 모듈
+
+포함 함수:
+- get_shape_position(): Shape의 위치 정보 반환
+- is_picture_shape(): Shape이 이미지인지 확인
+- process_image_shape(): 이미지 Shape 처리 및 로컬 저장
+- process_group_shape(): 그룹 Shape 처리
+"""
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+from xgen_doc2chunk.core.functions.img_processor import ImageProcessor
+
+from xgen_doc2chunk.core.processor.ppt_helper.ppt_constants import ElementType, SlideElement
+from xgen_doc2chunk.core.processor.ppt_helper.ppt_bullet import extract_text_with_bullets
+from xgen_doc2chunk.core.processor.ppt_helper.ppt_table import is_simple_table, extract_simple_table_as_text, convert_table_to_html
+
+logger = logging.getLogger("document-processor")
+
+
+def get_shape_position(shape) -> Tuple[int, int, int, int]:
+    """
+    Shape의 위치 정보를 반환합니다.
+
+    Args:
+        shape: python-pptx Shape 객체
+
+    Returns:
+        (left, top, width, height) 튜플 (EMU 단위)
+    """
+    try:
+        left = shape.left if hasattr(shape, 'left') and shape.left else 0
+        top = shape.top if hasattr(shape, 'top') and shape.top else 0
+        width = shape.width if hasattr(shape, 'width') and shape.width else 0
+        height = shape.height if hasattr(shape, 'height') and shape.height else 0
+        return (left, top, width, height)
+    except Exception:
+        return (0, 0, 0, 0)
+
+
+def is_picture_shape(shape) -> bool:
+    """
+    Shape이 이미지인지 확인합니다.
+
+    Args:
+        shape: python-pptx Shape 객체
+
+    Returns:
+        이미지이면 True
+    """
+    # 방법 1: shape_type 확인
+    try:
+        from pptx.enum.shapes import MSO_SHAPE_TYPE
+        if hasattr(shape, 'shape_type') and shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+            return True
+    except Exception:
+        pass
+
+    # 방법 2: image 속성 확인
+    if hasattr(shape, 'image'):
+        try:
+            _ = shape.image
+            return True
+        except Exception:
+            pass
+
+    return False
+
+
+def process_image_shape(
+    shape,
+    processed_images: set,
+    image_processor: ImageProcessor
+) -> Optional[str]:
+    """
+    이미지 Shape을 처리하고 로컬에 저장합니다.
+
+    Args:
+        shape: python-pptx Shape 객체 (이미지)
+        processed_images: 이미 처리된 이미지 해시 집합
+        image_processor: ImageProcessor 인스턴스
+
+    Returns:
+        이미지 태그 문자열 또는 None
+    """
+
+    try:
+        if not hasattr(shape, 'image'):
+            return None
+
+        image = shape.image
+        image_bytes = image.blob
+
+        if not image_bytes:
+            return None
+
+        image_tag = image_processor.save_image(image_bytes, processed_images=processed_images)
+
+        if image_tag:
+            return f"\n{image_tag}\n"
+
+        return None
+
+    except Exception as e:
+        logger.warning("Error processing image shape: %s", e)
+        return None
+
+
+def process_group_shape(
+    group_shape,
+    processed_images: set,
+    image_processor: ImageProcessor
+) -> List[SlideElement]:
+    """
+    그룹 Shape 내의 요소들을 처리합니다.
+
+    Args:
+        group_shape: python-pptx Group Shape 객체
+        processed_images: 이미 처리된 이미지 해시 집합
+        image_processor: ImageProcessor 인스턴스
+
+    Returns:
+        SlideElement 리스트
+    """
+
+    elements = []
+
+    try:
+        for shape in group_shape.shapes:
+            position = get_shape_position(shape)
+            shape_id = shape.shape_id if hasattr(shape, 'shape_id') else id(shape)
+
+            if shape.has_table:
+                # 단순 표(1xN, Nx1, 2x2 이하)는 텍스트로 처리
+                if is_simple_table(shape.table):
+                    simple_text = extract_simple_table_as_text(shape.table)
+                    if simple_text:
+                        elements.append(SlideElement(
+                            element_type=ElementType.TEXT,
+                            content=simple_text,
+                            position=position,
+                            shape_id=shape_id
+                        ))
+                else:
+                    # 일반 표는 HTML로 처리
+                    table_html = convert_table_to_html(shape.table)
+                    if table_html:
+                        elements.append(SlideElement(
+                            element_type=ElementType.TABLE,
+                            content=table_html,
+                            position=position,
+                            shape_id=shape_id
+                        ))
+
+            elif is_picture_shape(shape):
+                image_tag = process_image_shape(shape, processed_images, image_processor)
+                if image_tag:
+                    elements.append(SlideElement(
+                        element_type=ElementType.IMAGE,
+                        content=image_tag,
+                        position=position,
+                        shape_id=shape_id
+                    ))
+
+            # 텍스트 처리 - 목록 정보 포함
+            elif hasattr(shape, "text_frame") and shape.text_frame:
+                text_content = extract_text_with_bullets(shape.text_frame)
+                if text_content:
+                    elements.append(SlideElement(
+                        element_type=ElementType.TEXT,
+                        content=text_content,
+                        position=position,
+                        shape_id=shape_id
+                    ))
+
+            # 기존 text 속성만 있는 경우 (폴백)
+            elif hasattr(shape, "text") and shape.text.strip():
+                elements.append(SlideElement(
+                    element_type=ElementType.TEXT,
+                    content=shape.text.strip(),
+                    position=position,
+                    shape_id=shape_id
+                ))
+
+    except Exception as e:
+        logger.warning(f"Error processing group shape: {e}")
+
+    return elements

xgen_doc2chunk/core/processor/ppt_helper/ppt_slide.py

@@ -0,0 +1,69 @@
+"""
+PPT 슬라이드 처리 모듈
+
+포함 함수:
+- extract_slide_notes(): 슬라이드 노트 추출
+- merge_slide_elements(): 슬라이드 요소들을 병합하여 최종 텍스트 생성
+"""
+import logging
+from typing import List, Optional
+
+from xgen_doc2chunk.core.processor.ppt_helper.ppt_constants import ElementType, SlideElement
+
+logger = logging.getLogger("document-processor")
+
+
+def extract_slide_notes(slide) -> Optional[str]:
+    """
+    슬라이드 노트를 추출합니다.
+    
+    Args:
+        slide: python-pptx Slide 객체
+        
+    Returns:
+        노트 텍스트 또는 None
+    """
+    try:
+        if hasattr(slide, "notes_slide") and slide.notes_slide:
+            notes_frame = slide.notes_slide.notes_text_frame
+            if notes_frame:
+                notes_text = notes_frame.text.strip()
+                if notes_text:
+                    return notes_text
+    except Exception:
+        pass
+    return None
+
+
+def merge_slide_elements(elements: List[SlideElement]) -> str:
+    """
+    슬라이드 요소들을 병합하여 최종 텍스트를 생성합니다.
+    
+    각 요소 타입에 맞게 적절한 포맷팅을 적용합니다:
+    - TABLE: 앞뒤 줄바꿈 추가
+    - IMAGE: 그대로 출력 (이미 줄바꿈 포함)
+    - CHART: 앞뒤 줄바꿈 추가
+    - TEXT: 뒤에 줄바꿈 추가
+    
+    Args:
+        elements: SlideElement 리스트 (위치 기준 정렬된 상태)
+        
+    Returns:
+        병합된 텍스트
+    """
+    if not elements:
+        return ""
+
+    result_parts = []
+
+    for element in elements:
+        if element.element_type == ElementType.TABLE:
+            result_parts.append("\n" + element.content + "\n")
+        elif element.element_type == ElementType.IMAGE:
+            result_parts.append(element.content)
+        elif element.element_type == ElementType.CHART:
+            result_parts.append("\n" + element.content + "\n")
+        elif element.element_type == ElementType.TEXT:
+            result_parts.append(element.content + "\n")
+
+    return "".join(result_parts)