Inventory

#!/usr/bin/env python3 """ Extract structured text content from PowerPoint presentations.

This module provides functionality to:

• Extract all text content from PowerPoint shapes
• Preserve paragraph formatting (alignment, bullets, fonts, spacing)
• Handle nested GroupShapes recursively with correct absolute positions
• Sort shapes by visual position on slides
• Filter out slide numbers and non-content placeholders
• Export to JSON with clean, structured data

Classes: ParagraphData: Represents a text paragraph with formatting ShapeData: Represents a shape with position and text content

Main Functions: extract_text_inventory: Extract all text from a presentation save_inventory: Save extracted data to JSON

Usage: python inventory.py input.pptx output.json """

import argparse import json import platform import sys from dataclasses import dataclass from pathlib import Path from typing import Any, Dict, List, Optional, Tuple, Union

from PIL import Image, ImageDraw, ImageFont from pptx import Presentation from pptx.enum.text import PP_ALIGN from pptx.shapes.base import BaseShape

Type aliases for cleaner signatures

JsonValue = Union[str, int, float, bool, None] ParagraphDict = Dict[str, JsonValue] ShapeDict = Dict[ str, Union[str, float, bool, List[ParagraphDict], List[str], Dict[str, Any], None] ] InventoryData = Dict[ str, Dict[str, "ShapeData"] ] # Dict of slide_id -> {shape_id -> ShapeData} InventoryDict = Dict[str, Dict[str, ShapeDict]] # JSON-serializable inventory

def main(): """Main entry point for command-line usage.""" parser = argparse.ArgumentParser( description="Extract text inventory from PowerPoint with proper GroupShape support.", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: python inventory.py presentation.pptx inventory.json Extracts text inventory with correct absolute positions for grouped shapes

python inventory.py presentation.pptx inventory.json --issues-only Extracts only text shapes that have overflow or overlap issues

The output JSON includes:

• All text content organized by slide and shape

• Correct absolute positions for shapes in groups

• Visual position and size in inches

• Paragraph properties and formatting

• Issue detection: text overflow and shape overlaps """, )

  parser.add_argument("input", help="Input PowerPoint file (.pptx)") parser.add_argument("output", help="Output JSON file for inventory") parser.add_argument( "--issues-only", action="store_true", help="Include only text shapes that have overflow or overlap issues", )

  args = parser.parse_args()

  input_path = Path(args.input) if not input_path.exists(): print(f"Error: Input file not found: {args.input}") sys.exit(1) if not input_path.suffix.lower() == ".pptx": print("Error: Input must be a PowerPoint file (.pptx)") sys.exit(1) try: print(f"Extracting text inventory from: {args.input}") if args.issues_only: print( "Filtering to include only text shapes with issues (overflow/overlap)" ) inventory = extract_text_inventory(input_path, issues_only=args.issues_only) output_path = Path(args.output) output_path.parent.mkdir(parents=True, exist_ok=True) save_inventory(inventory, output_path) print(f"Output saved to: {args.output}") # Report statistics total_slides = len(inventory) total_shapes = sum(len(shapes) for shapes in inventory.values()) if args.issues_only: if total_shapes > 0: print( f"Found {total_shapes} text elements with issues in {total_slides} slides" ) else: print("No issues discovered") else: print( f"Found text in {total_slides} slides with {total_shapes} text elements" ) except Exception as e: print(f"Error processing presentation: {e}") import traceback traceback.print_exc() sys.exit(1)

@dataclass class ShapeWithPosition: """A shape with its absolute position on the slide."""

shape: BaseShape
absolute_left: int  # in EMUs
absolute_top: int  # in EMUs

class ParagraphData: """Data structure for paragraph properties extracted from a PowerPoint paragraph."""

def __init__(self, paragraph: Any):
    """Initialize from a PowerPoint paragraph object.

    Args:
        paragraph: The PowerPoint paragraph object
    """
    self.text: str = paragraph.text.strip()
    self.bullet: bool = False
    self.level: Optional[int] = None
    self.alignment: Optional[str] = None
    self.space_before: Optional[float] = None
    self.space_after: Optional[float] = None
    self.font_name: Optional[str] = None
    self.font_size: Optional[float] = None
    self.bold: Optional[bool] = None
    self.italic: Optional[bool] = None
    self.underline: Optional[bool] = None
    self.color: Optional[str] = None
    self.theme_color: Optional[str] = None
    self.line_spacing: Optional[float] = None

    # Check for bullet formatting
    if (
        hasattr(paragraph, "_p")
        and paragraph._p is not None
        and paragraph._p.pPr is not None
    ):
        pPr = paragraph._p.pPr
        ns = "{http://schemas.openxmlformats.org/drawingml/2006/main}"
        if (
            pPr.find(f"{ns}buChar") is not None
            or pPr.find(f"{ns}buAutoNum") is not None
        ):
            self.bullet = True
            if hasattr(paragraph, "level"):
                self.level = paragraph.level

    # Add alignment if not LEFT (default)
    if hasattr(paragraph, "alignment") and paragraph.alignment is not None:
        alignment_map = {
            PP_ALIGN.CENTER: "CENTER",
            PP_ALIGN.RIGHT: "RIGHT",
            PP_ALIGN.JUSTIFY: "JUSTIFY",
        }
        if paragraph.alignment in alignment_map:
            self.alignment = alignment_map[paragraph.alignment]

    # Add spacing properties if set
    if hasattr(paragraph, "space_before") and paragraph.space_before:
        self.space_before = paragraph.space_before.pt
    if hasattr(paragraph, "space_after") and paragraph.space_after:
        self.space_after = paragraph.space_after.pt

    # Extract font properties from first run
    if paragraph.runs:
        first_run = paragraph.runs[0]
        if hasattr(first_run, "font"):
            font = first_run.font
            if font.name:
                self.font_name = font.name
            if font.size:
                self.font_size = font.size.pt
            if font.bold is not None:
                self.bold = font.bold
            if font.italic is not None:
                self.italic = font.italic
            if font.underline is not None:
                self.underline = font.underline

            # Handle color - both RGB and theme colors
            try:
                # Try RGB color first
                if font.color.rgb:
                    self.color = str(font.color.rgb)
            except (AttributeError, TypeError):
                # Fall back to theme color
                try:
                    if font.color.theme_color:
                        self.theme_color = font.color.theme_color.name
                except (AttributeError, TypeError):
                    pass

    # Add line spacing if set
    if hasattr(paragraph, "line_spacing") and paragraph.line_spacing is not None:
        if hasattr(paragraph.line_spacing, "pt"):
            self.line_spacing = round(paragraph.line_spacing.pt, 2)
        else:
            # Multiplier - convert to points
            font_size = self.font_size if self.font_size else 12.0
            self.line_spacing = round(paragraph.line_spacing * font_size, 2)

def to_dict(self) -> ParagraphDict:
    """Convert to dictionary for JSON serialization, excluding None values."""
    result: ParagraphDict = {"text": self.text}

    # Add optional fields only if they have values
    if self.bullet:
        result["bullet"] = self.bullet
    if self.level is not None:
        result["level"] = self.level
    if self.alignment:
        result["alignment"] = self.alignment
    if self.space_before is not None:
        result["space_before"] = self.space_before
    if self.space_after is not None:
        result["space_after"] = self.space_after
    if self.font_name:
        result["font_name"] = self.font_name
    if self.font_size is not None:
        result["font_size"] = self.font_size
    if self.bold is not None:
        result["bold"] = self.bold
    if self.italic is not None:
        result["italic"] = self.italic
    if self.underline is not None:
        result["underline"] = self.underline
    if self.color:
        result["color"] = self.color
    if self.theme_color:
        result["theme_color"] = self.theme_color
    if self.line_spacing is not None:
        result["line_spacing"] = self.line_spacing

    return result

class ShapeData: """Data structure for shape properties extracted from a PowerPoint shape."""

@staticmethod
def emu_to_inches(emu: int) -> float:
    """Convert EMUs (English Metric Units) to inches."""
    return emu / 914400.0

@staticmethod
def inches_to_pixels(inches: float, dpi: int = 96) -> int:
    """Convert inches to pixels at given DPI."""
    return int(inches * dpi)

@staticmethod
def get_font_path(font_name: str) -> Optional[str]:
    """Get the font file path for a given font name.

    Args:
        font_name: Name of the font (e.g., 'Arial', 'Calibri')

    Returns:
        Path to the font file, or None if not found
    """
    system = platform.system()

    # Common font file variations to try
    font_variations = [
        font_name,
        font_name.lower(),
        font_name.replace(" ", ""),
        font_name.replace(" ", "-"),
    ]

    # Define font directories and extensions by platform
    if system == "Darwin":  # macOS
        font_dirs = [
            "/System/Library/Fonts/",
            "/Library/Fonts/",
            "~/Library/Fonts/",
        ]
        extensions = [".ttf", ".otf", ".ttc", ".dfont"]
    else:  # Linux
        font_dirs = [
            "/usr/share/fonts/truetype/",
            "/usr/local/share/fonts/",
            "~/.fonts/",
        ]
        extensions = [".ttf", ".otf"]

    # Try to find the font file
    from pathlib import Path

    for font_dir in font_dirs:
        font_dir_path = Path(font_dir).expanduser()
        if not font_dir_path.exists():
            continue

        # First try exact matches
        for variant in font_variations:
            for ext in extensions:
                font_path = font_dir_path / f"{variant}{ext}"
                if font_path.exists():
                    return str(font_path)

        # Then try fuzzy matching - find files containing the font name
        try:
            for file_path in font_dir_path.iterdir():
                if file_path.is_file():
                    file_name_lower = file_path.name.lower()
                    font_name_lower = font_name.lower().replace(" ", "")
                    if font_name_lower in file_name_lower and any(
                        file_name_lower.endswith(ext) for ext in extensions
                    ):
                        return str(file_path)
        except (OSError, PermissionError):
            continue

    return None

@staticmethod
def get_slide_dimensions(slide: Any) -> tuple[Optional[int], Optional[int]]:
    """Get slide dimensions from slide object.

    Args:
        slide: Slide object

    Returns:
        Tuple of (width_emu, height_emu) or (None, None) if not found
    """
    try:
        prs = slide.part.package.presentation_part.presentation
        return prs.slide_width, prs.slide_height
    except (AttributeError, TypeError):
        return None, None

@staticmethod
def get_default_font_size(shape: BaseShape, slide_layout: Any) -> Optional[float]:
    """Extract default font size from slide layout for a placeholder shape.

    Args:
        shape: Placeholder shape
        slide_layout: Slide layout containing the placeholder definition

    Returns:
        Default font size in points, or None if not found
    """
    try:
        if not hasattr(shape, "placeholder_format"):
            return None

        shape_type = shape.placeholder_format.type  # type: ignore
        for layout_placeholder in slide_layout.placeholders:
            if layout_placeholder.placeholder_format.type == shape_type:
                # Find first defRPr element with sz (size) attribute
                for elem in layout_placeholder.element.iter():
                    if "defRPr" in elem.tag and (sz := elem.get("sz")):
                        return float(sz) / 100.0  # Convert EMUs to points
                break
    except Exception:
        pass
    return None

def __init__(
    self,
    shape: BaseShape,
    absolute_left: Optional[int] = None,
    absolute_top: Optional[int] = None,
    slide: Optional[Any] = None,
):
    """Initialize from a PowerPoint shape object.

    Args:
        shape: The PowerPoint shape object (should be pre-validated)
        absolute_left: Absolute left position in EMUs (for shapes in groups)
        absolute_top: Absolute top position in EMUs (for shapes in groups)
        slide: Optional slide object to get dimensions and layout information
    """
    self.shape = shape  # Store reference to original shape
    self.shape_id: str = ""  # Will be set after sorting

    # Get slide dimensions from slide object
    self.slide_width_emu, self.slide_height_emu = (
        self.get_slide_dimensions(slide) if slide else (None, None)
    )

    # Get placeholder type if applicable
    self.placeholder_type: Optional[str] = None
    self.default_font_size: Optional[float] = None
    if hasattr(shape, "is_placeholder") and shape.is_placeholder:  # type: ignore
        if shape.placeholder_format and shape.placeholder_format.type:  # type: ignore
            self.placeholder_type = (
                str(shape.placeholder_format.type).split(".")[-1].split(" ")[0]  # type: ignore
            )

            # Get default font size from layout
            if slide and hasattr(slide, "slide_layout"):
                self.default_font_size = self.get_default_font_size(
                    shape, slide.slide_layout
                )

    # Get position information
    # Use absolute positions if provided (for shapes in groups), otherwise use shape's position
    left_emu = (
        absolute_left
        if absolute_left is not None
        else (shape.left if hasattr(shape, "left") else 0)
    )
    top_emu = (
        absolute_top
        if absolute_top is not None
        else (shape.top if hasattr(shape, "top") else 0)
    )

    self.left: float = round(self.emu_to_inches(left_emu), 2)  # type: ignore
    self.top: float = round(self.emu_to_inches(top_emu), 2)  # type: ignore
    self.width: float = round(
        self.emu_to_inches(shape.width if hasattr(shape, "width") else 0),
        2,  # type: ignore
    )
    self.height: float = round(
        self.emu_to_inches(shape.height if hasattr(shape, "height") else 0),
        2,  # type: ignore
    )

    # Store EMU positions for overflow calculations
    self.left_emu = left_emu
    self.top_emu = top_emu
    self.width_emu = shape.width if hasattr(shape, "width") else 0
    self.height_emu = shape.height if hasattr(shape, "height") else 0

    # Calculate overflow status
    self.frame_overflow_bottom: Optional[float] = None
    self.slide_overflow_right: Optional[float] = None
    self.slide_overflow_bottom: Optional[float] = None
    self.overlapping_shapes: Dict[
        str, float
    ] = {}  # Dict of shape_id -> overlap area in sq inches
    self.warnings: List[str] = []
    self._estimate_frame_overflow()
    self._calculate_slide_overflow()
    self._detect_bullet_issues()

@property
def paragraphs(self) -> List[ParagraphData]:
    """Calculate paragraphs from the shape's text frame."""
    if not self.shape or not hasattr(self.shape, "text_frame"):
        return []

    paragraphs = []
    for paragraph in self.shape.text_frame.paragraphs:  # type: ignore
        if paragraph.text.strip():
            paragraphs.append(ParagraphData(paragraph))
    return paragraphs

def _get_default_font_size(self) -> int:
    """Get default font size from theme text styles or use conservative default."""
    try:
        if not (
            hasattr(self.shape, "part") and hasattr(self.shape.part, "slide_layout")
        ):
            return 14

        slide_master = self.shape.part.slide_layout.slide_master  # type: ignore
        if not hasattr(slide_master, "element"):
            return 14

        # Determine theme style based on placeholder type
        style_name = "bodyStyle"  # Default
        if self.placeholder_type and "TITLE" in self.placeholder_type:
            style_name = "titleStyle"

        # Find font size in theme styles
        for child in slide_master.element.iter():
            tag = child.tag.split("}")[-1] if "}" in child.tag else child.tag
            if tag == style_name:
                for elem in child.iter():
                    if "sz" in elem.attrib:
                        return int(elem.attrib["sz"]) // 100
    except Exception:
        pass

    return 14  # Conservative default for body text

def _get_usable_dimensions(self, text_frame) -> Tuple[int, int]:
    """Get usable width and height in pixels after accounting for margins."""
    # Default PowerPoint margins in inches
    margins = {"top": 0.05, "bottom": 0.05, "left": 0.1, "right": 0.1}

    # Override with actual margins if set
    if hasattr(text_frame, "margin_top") and text_frame.margin_top:
        margins["top"] = self.emu_to_inches(text_frame.margin_top)
    if hasattr(text_frame, "margin_bottom") and text_frame.margin_bottom:
        margins["bottom"] = self.emu_to_inches(text_frame.margin_bottom)
    if hasattr(text_frame, "margin_left") and text_frame.margin_left:
        margins["left"] = self.emu_to_inches(text_frame.margin_left)
    if hasattr(text_frame, "margin_right") and text_frame.margin_right:
        margins["right"] = self.emu_to_inches(text_frame.margin_right)

    # Calculate usable area
    usable_width = self.width - margins["left"] - margins["right"]
    usable_height = self.height - margins["top"] - margins["bottom"]

    # Convert to pixels
    return (
        self.inches_to_pixels(usable_width),
        self.inches_to_pixels(usable_height),
    )

def _wrap_text_line(self, line: str, max_width_px: int, draw, font) -> List[str]:
    """Wrap a single line of text to fit within max_width_px."""
    if not line:
        return [""]

    # Use textlength for efficient width calculation
    if draw.textlength(line, font=font) <= max_width_px:
        return [line]

    # Need to wrap - split into words
    wrapped = []
    words = line.split(" ")
    current_line = ""

    for word in words:
        test_line = current_line + (" " if current_line else "") + word
        if draw.textlength(test_line, font=font) <= max_width_px:
            current_line = test_line
        else:
            if current_line:
                wrapped.append(current_line)
            current_line = word

    if current_line:
        wrapped.append(current_line)

    return wrapped

def _estimate_frame_overflow(self) -> None:
    """Estimate if text overflows the shape bounds using PIL text measurement."""
    if not self.shape or not hasattr(self.shape, "text_frame"):
        return

    text_frame = self.shape.text_frame  # type: ignore
    if not text_frame or not text_frame.paragraphs:
        return

    # Get usable dimensions after accounting for margins
    usable_width_px, usable_height_px = self._get_usable_dimensions(text_frame)
    if usable_width_px <= 0 or usable_height_px <= 0:
        return

    # Set up PIL for text measurement
    dummy_img = Image.new("RGB", (1, 1))
    draw = ImageDraw.Draw(dummy_img)

    # Get default font size from placeholder or use conservative estimate
    default_font_size = self._get_default_font_size()

    # Calculate total height of all paragraphs
    total_height_px = 0

    for para_idx, paragraph in enumerate(text_frame.paragraphs):
        if not paragraph.text.strip():
            continue

        para_data = ParagraphData(paragraph)

        # Load font for this paragraph
        font_name = para_data.font_name or "Arial"
        font_size = int(para_data.font_size or default_font_size)

        font = None
        font_path = self.get_font_path(font_name)
        if font_path:
            try:
                font = ImageFont.truetype(font_path, size=font_size)
            except Exception:
                font = ImageFont.load_default()
        else:
            font = ImageFont.load_default()

        # Wrap all lines in this paragraph
        all_wrapped_lines = []
        for line in paragraph.text.split("\n"):
            wrapped = self._wrap_text_line(line, usable_width_px, draw, font)
            all_wrapped_lines.extend(wrapped)

        if all_wrapped_lines:
            # Calculate line height
            if para_data.line_spacing:
                # Custom line spacing explicitly set
                line_height_px = para_data.line_spacing * 96 / 72
            else:
                # PowerPoint default single spacing (1.0x font size)
                line_height_px = font_size * 96 / 72

            # Add space_before (except first paragraph)
            if para_idx > 0 and para_data.space_before:
                total_height_px += para_data.space_before * 96 / 72

            # Add paragraph text height
            total_height_px += len(all_wrapped_lines) * line_height_px

            # Add space_after
            if para_data.space_after:
                total_height_px += para_data.space_after * 96 / 72

    # Check for overflow (ignore negligible overflows <= 0.05")
    if total_height_px > usable_height_px:
        overflow_px = total_height_px - usable_height_px
        overflow_inches = round(overflow_px / 96.0, 2)
        if overflow_inches > 0.05:  # Only report significant overflows
            self.frame_overflow_bottom = overflow_inches

def _calculate_slide_overflow(self) -> None:
    """Calculate if shape overflows the slide boundaries."""
    if self.slide_width_emu is None or self.slide_height_emu is None:
        return

    # Check right overflow (ignore negligible overflows <= 0.01")
    right_edge_emu = self.left_emu + self.width_emu
    if right_edge_emu > self.slide_width_emu:
        overflow_emu = right_edge_emu - self.slide_width_emu
        overflow_inches = round(self.emu_to_inches(overflow_emu), 2)
        if overflow_inches > 0.01:  # Only report significant overflows
            self.slide_overflow_right = overflow_inches

    # Check bottom overflow (ignore negligible overflows <= 0.01")
    bottom_edge_emu = self.top_emu + self.height_emu
    if bottom_edge_emu > self.slide_height_emu:
        overflow_emu = bottom_edge_emu - self.slide_height_emu
        overflow_inches = round(self.emu_to_inches(overflow_emu), 2)
        if overflow_inches > 0.01:  # Only report significant overflows
            self.slide_overflow_bottom = overflow_inches

def _detect_bullet_issues(self) -> None:
    """Detect bullet point formatting issues in paragraphs."""
    if not self.shape or not hasattr(self.shape, "text_frame"):
        return

    text_frame = self.shape.text_frame  # type: ignore
    if not text_frame or not text_frame.paragraphs:
        return

    # Common bullet symbols that indicate manual bullets
    bullet_symbols = ["•", "●", "○"]

    for paragraph in text_frame.paragraphs:
        text = paragraph.text.strip()
        # Check for manual bullet symbols
        if text and any(text.startswith(symbol + " ") for symbol in bullet_symbols):
            self.warnings.append(
                "manual_bullet_symbol: use proper bullet formatting"
            )
            break

@property
def has_any_issues(self) -> bool:
    """Check if shape has any issues (overflow, overlap, or warnings)."""
    return (
        self.frame_overflow_bottom is not None
        or self.slide_overflow_right is not None
        or self.slide_overflow_bottom is not None
        or len(self.overlapping_shapes) > 0
        or len(self.warnings) > 0
    )

def to_dict(self) -> ShapeDict:
    """Convert to dictionary for JSON serialization."""
    result: ShapeDict = {
        "left": self.left,
        "top": self.top,
        "width": self.width,
        "height": self.height,
    }

    # Add optional fields if present
    if self.placeholder_type:
        result["placeholder_type"] = self.placeholder_type

    if self.default_font_size:
        result["default_font_size"] = self.default_font_size

    # Add overflow information only if there is overflow
    overflow_data = {}

    # Add frame overflow if present
    if self.frame_overflow_bottom is not None:
        overflow_data["frame"] = {"overflow_bottom": self.frame_overflow_bottom}

    # Add slide overflow if present
    slide_overflow = {}
    if self.slide_overflow_right is not None:
        slide_overflow["overflow_right"] = self.slide_overflow_right
    if self.slide_overflow_bottom is not None:
        slide_overflow["overflow_bottom"] = self.slide_overflow_bottom
    if slide_overflow:
        overflow_data["slide"] = slide_overflow

    # Only add overflow field if there is overflow
    if overflow_data:
        result["overflow"] = overflow_data

    # Add overlap field if there are overlapping shapes
    if self.overlapping_shapes:
        result["overlap"] = {"overlapping_shapes": self.overlapping_shapes}

    # Add warnings field if there are warnings
    if self.warnings:
        result["warnings"] = self.warnings

    # Add paragraphs after placeholder_type
    result["paragraphs"] = [para.to_dict() for para in self.paragraphs]

    return result

def is_valid_shape(shape: BaseShape) -> bool: """Check if a shape contains meaningful text content.""" # Must have a text frame with content if not hasattr(shape, "text_frame") or not shape.text_frame: # type: ignore return False

text = shape.text_frame.text.strip()  # type: ignore
if not text:
    return False

# Skip slide numbers and numeric footers
if hasattr(shape, "is_placeholder") and shape.is_placeholder:  # type: ignore
    if shape.placeholder_format and shape.placeholder_format.type:  # type: ignore
        placeholder_type = (
            str(shape.placeholder_format.type).split(".")[-1].split(" ")[0]  # type: ignore
        )
        if placeholder_type == "SLIDE_NUMBER":
            return False
        if placeholder_type == "FOOTER" and text.isdigit():
            return False

return True

def collect_shapes_with_absolute_positions( shape: BaseShape, parent_left: int = 0, parent_top: int = 0 ) -> List[ShapeWithPosition]: """Recursively collect all shapes with valid text, calculating absolute positions.

For shapes within groups, their positions are relative to the group.
This function calculates the absolute position on the slide by accumulating
parent group offsets.

Args:
    shape: The shape to process
    parent_left: Accumulated left offset from parent groups (in EMUs)
    parent_top: Accumulated top offset from parent groups (in EMUs)

Returns:
    List of ShapeWithPosition objects with absolute positions
"""
if hasattr(shape, "shapes"):  # GroupShape
    result = []
    # Get this group's position
    group_left = shape.left if hasattr(shape, "left") else 0
    group_top = shape.top if hasattr(shape, "top") else 0

    # Calculate absolute position for this group
    abs_group_left = parent_left + group_left
    abs_group_top = parent_top + group_top

    # Process children with accumulated offsets
    for child in shape.shapes:  # type: ignore
        result.extend(
            collect_shapes_with_absolute_positions(
                child, abs_group_left, abs_group_top
            )
        )
    return result

# Regular shape - check if it has valid text
if is_valid_shape(shape):
    # Calculate absolute position
    shape_left = shape.left if hasattr(shape, "left") else 0
    shape_top = shape.top if hasattr(shape, "top") else 0

    return [
        ShapeWithPosition(
            shape=shape,
            absolute_left=parent_left + shape_left,
            absolute_top=parent_top + shape_top,
        )
    ]

return []

def sort_shapes_by_position(shapes: List[ShapeData]) -> List[ShapeData]: """Sort shapes by visual position (top-to-bottom, left-to-right).

Shapes within 0.5 inches vertically are considered on the same row.
"""
if not shapes:
    return shapes

# Sort by top position first
shapes = sorted(shapes, key=lambda s: (s.top, s.left))

# Group shapes by row (within 0.5 inches vertically)
result = []
row = [shapes[0]]
row_top = shapes[0].top

for shape in shapes[1:]:
    if abs(shape.top - row_top) <= 0.5:
        row.append(shape)
    else:
        # Sort current row by left position and add to result
        result.extend(sorted(row, key=lambda s: s.left))
        row = [shape]
        row_top = shape.top

# Don't forget the last row
result.extend(sorted(row, key=lambda s: s.left))
return result

def calculate_overlap( rect1: Tuple[float, float, float, float], rect2: Tuple[float, float, float, float], tolerance: float = 0.05, ) -> Tuple[bool, float]: """Calculate if and how much two rectangles overlap.

Args:
    rect1: (left, top, width, height) of first rectangle in inches
    rect2: (left, top, width, height) of second rectangle in inches
    tolerance: Minimum overlap in inches to consider as overlapping (default: 0.05")

Returns:
    Tuple of (overlaps, overlap_area) where:
    - overlaps: True if rectangles overlap by more than tolerance
    - overlap_area: Area of overlap in square inches
"""
left1, top1, w1, h1 = rect1
left2, top2, w2, h2 = rect2

# Calculate overlap dimensions
overlap_width = min(left1 + w1, left2 + w2) - max(left1, left2)
overlap_height = min(top1 + h1, top2 + h2) - max(top1, top2)

# Check if there's meaningful overlap (more than tolerance)
if overlap_width > tolerance and overlap_height > tolerance:
    # Calculate overlap area in square inches
    overlap_area = overlap_width * overlap_height
    return True, round(overlap_area, 2)

return False, 0

def detect_overlaps(shapes: List[ShapeData]) -> None: """Detect overlapping shapes and update their overlapping_shapes dictionaries.

This function requires each ShapeData to have its shape_id already set.
It modifies the shapes in-place, adding shape IDs with overlap areas in square inches.

Args:
    shapes: List of ShapeData objects with shape_id attributes set
"""
n = len(shapes)

# Compare each pair of shapes
for i in range(n):
    for j in range(i + 1, n):
        shape1 = shapes[i]
        shape2 = shapes[j]

        # Ensure shape IDs are set
        assert shape1.shape_id, f"Shape at index {i} has no shape_id"
        assert shape2.shape_id, f"Shape at index {j} has no shape_id"

        rect1 = (shape1.left, shape1.top, shape1.width, shape1.height)
        rect2 = (shape2.left, shape2.top, shape2.width, shape2.height)

        overlaps, overlap_area = calculate_overlap(rect1, rect2)

        if overlaps:
            # Add shape IDs with overlap area in square inches
            shape1.overlapping_shapes[shape2.shape_id] = overlap_area
            shape2.overlapping_shapes[shape1.shape_id] = overlap_area

def extract_text_inventory( pptx_path: Path, prs: Optional[Any] = None, issues_only: bool = False ) -> InventoryData: """Extract text content from all slides in a PowerPoint presentation.

Args:
    pptx_path: Path to the PowerPoint file
    prs: Optional Presentation object to use. If not provided, will load from pptx_path.
    issues_only: If True, only include shapes that have overflow or overlap issues

Returns a nested dictionary: {slide-N: {shape-N: ShapeData}}
Shapes are sorted by visual position (top-to-bottom, left-to-right).
The ShapeData objects contain the full shape information and can be
converted to dictionaries for JSON serialization using to_dict().
"""
if prs is None:
    prs = Presentation(str(pptx_path))
inventory: InventoryData = {}

for slide_idx, slide in enumerate(prs.slides):
    # Collect all valid shapes from this slide with absolute positions
    shapes_with_positions = []
    for shape in slide.shapes:  # type: ignore
        shapes_with_positions.extend(collect_shapes_with_absolute_positions(shape))

    if not shapes_with_positions:
        continue

    # Convert to ShapeData with absolute positions and slide reference
    shape_data_list = [
        ShapeData(
            swp.shape,
            swp.absolute_left,
            swp.absolute_top,
            slide,
        )
        for swp in shapes_with_positions
    ]

    # Sort by visual position and assign stable IDs in one step
    sorted_shapes = sort_shapes_by_position(shape_data_list)
    for idx, shape_data in enumerate(sorted_shapes):
        shape_data.shape_id = f"shape-{idx}"

    # Detect overlaps using the stable shape IDs
    if len(sorted_shapes) > 1:
        detect_overlaps(sorted_shapes)

    # Filter for issues only if requested (after overlap detection)
    if issues_only:
        sorted_shapes = [sd for sd in sorted_shapes if sd.has_any_issues]

    if not sorted_shapes:
        continue

    # Create slide inventory using the stable shape IDs
    inventory[f"slide-{slide_idx}"] = {
        shape_data.shape_id: shape_data for shape_data in sorted_shapes
    }

return inventory

def get_inventory_as_dict(pptx_path: Path, issues_only: bool = False) -> InventoryDict: """Extract text inventory and return as JSON-serializable dictionaries.

This is a convenience wrapper around extract_text_inventory that returns
dictionaries instead of ShapeData objects, useful for testing and direct
JSON serialization.

Args:
    pptx_path: Path to the PowerPoint file
    issues_only: If True, only include shapes that have overflow or overlap issues

Returns:
    Nested dictionary with all data serialized for JSON
"""
inventory = extract_text_inventory(pptx_path, issues_only=issues_only)

# Convert ShapeData objects to dictionaries
dict_inventory: InventoryDict = {}
for slide_key, shapes in inventory.items():
    dict_inventory[slide_key] = {
        shape_key: shape_data.to_dict() for shape_key, shape_data in shapes.items()
    }

return dict_inventory

def save_inventory(inventory: InventoryData, output_path: Path) -> None: """Save inventory to JSON file with proper formatting.

Converts ShapeData objects to dictionaries for JSON serialization.
"""
# Convert ShapeData objects to dictionaries
json_inventory: InventoryDict = {}
for slide_key, shapes in inventory.items():
    json_inventory[slide_key] = {
        shape_key: shape_data.to_dict() for shape_key, shape_data in shapes.items()
    }

with open(output_path, "w", encoding="utf-8") as f:
    json.dump(json_inventory, f, indent=2, ensure_ascii=False)

if name == "main": main()