mcpcn-office-powerpoint-mcp-server 2.0.7__py3-none-any.whl

utils/content_utils.py

@@ -0,0 +1,579 @@
+"""
+Content management utilities for PowerPoint MCP Server.
+Functions for slides, text, images, tables, charts, and shapes.
+"""
+from pptx import Presentation
+from pptx.chart.data import CategoryChartData
+from pptx.enum.chart import XL_CHART_TYPE
+from pptx.enum.text import PP_ALIGN
+from pptx.util import Inches, Pt
+from pptx.dml.color import RGBColor
+from typing import Dict, List, Tuple, Optional, Any
+import tempfile
+import os
+import base64
+
+
+def add_slide(presentation: Presentation, layout_index: int = 1) -> Tuple:
+    """
+    Add a slide to the presentation.
+    
+    Args:
+        presentation: The Presentation object
+        layout_index: Index of the slide layout to use
+        
+    Returns:
+        A tuple containing the slide and its layout
+    """
+    layout = presentation.slide_layouts[layout_index]
+    slide = presentation.slides.add_slide(layout)
+    return slide, layout
+
+
+def get_slide_info(slide, slide_index: int) -> Dict:
+    """
+    Get information about a specific slide.
+    
+    Args:
+        slide: The slide object
+        slide_index: Index of the slide
+        
+    Returns:
+        Dictionary containing slide information
+    """
+    try:
+        placeholders = []
+        for placeholder in slide.placeholders:
+            placeholder_info = {
+                "idx": placeholder.placeholder_format.idx,
+                "type": str(placeholder.placeholder_format.type),
+                "name": placeholder.name
+            }
+            placeholders.append(placeholder_info)
+        
+        shapes = []
+        for i, shape in enumerate(slide.shapes):
+            shape_info = {
+                "index": i,
+                "name": shape.name,
+                "shape_type": str(shape.shape_type),
+                "left": shape.left,
+                "top": shape.top,
+                "width": shape.width,
+                "height": shape.height
+            }
+            shapes.append(shape_info)
+        
+        return {
+            "slide_index": slide_index,
+            "layout_name": slide.slide_layout.name,
+            "placeholder_count": len(placeholders),
+            "placeholders": placeholders,
+            "shape_count": len(shapes),
+            "shapes": shapes
+        }
+    except Exception as e:
+        raise Exception(f"Failed to get slide info: {str(e)}")
+
+
+def set_title(slide, title: str) -> None:
+    """
+    Set the title of a slide.
+    
+    Args:
+        slide: The slide object
+        title: The title text
+    """
+    if slide.shapes.title:
+        slide.shapes.title.text = title
+
+
+def populate_placeholder(slide, placeholder_idx: int, text: str) -> None:
+    """
+    Populate a placeholder with text.
+    
+    Args:
+        slide: The slide object
+        placeholder_idx: The index of the placeholder
+        text: The text to add
+    """
+    placeholder = slide.placeholders[placeholder_idx]
+    placeholder.text = text
+
+
+def add_bullet_points(placeholder, bullet_points: List[str]) -> None:
+    """
+    Add bullet points to a placeholder.
+    
+    Args:
+        placeholder: The placeholder object
+        bullet_points: List of bullet point texts
+    """
+    text_frame = placeholder.text_frame
+    text_frame.clear()
+    
+    for i, point in enumerate(bullet_points):
+        p = text_frame.add_paragraph()
+        p.text = point
+        p.level = 0
+
+
+def add_textbox(slide, left: float, top: float, width: float, height: float, text: str,
+                font_size: int = None, font_name: str = None, bold: bool = None,
+                italic: bool = None, underline: bool = None, 
+                color: Tuple[int, int, int] = None, bg_color: Tuple[int, int, int] = None,
+                alignment: str = None, vertical_alignment: str = None, 
+                auto_fit: bool = True) -> Any:
+    """
+    Add a textbox to a slide with formatting options.
+    
+    Args:
+        slide: The slide object
+        left: Left position in inches
+        top: Top position in inches
+        width: Width in inches
+        height: Height in inches
+        text: Text content
+        font_size: Font size in points
+        font_name: Font name
+        bold: Whether text should be bold
+        italic: Whether text should be italic
+        underline: Whether text should be underlined
+        color: RGB color tuple (r, g, b)
+        bg_color: Background RGB color tuple (r, g, b)
+        alignment: Text alignment ('left', 'center', 'right', 'justify')
+        vertical_alignment: Vertical alignment ('top', 'middle', 'bottom')
+        auto_fit: Whether to auto-fit text
+        
+    Returns:
+        The created textbox shape
+    """
+    textbox = slide.shapes.add_textbox(
+        Inches(left), Inches(top), Inches(width), Inches(height)
+    )
+    
+    textbox.text_frame.text = text
+    
+    # Apply formatting if provided
+    if any([font_size, font_name, bold, italic, underline, color, bg_color, alignment, vertical_alignment]):
+        format_text_advanced(
+            textbox.text_frame,
+            font_size=font_size,
+            font_name=font_name,
+            bold=bold,
+            italic=italic,
+            underline=underline,
+            color=color,
+            bg_color=bg_color,
+            alignment=alignment,
+            vertical_alignment=vertical_alignment
+        )
+    
+    return textbox
+
+
+def format_text(text_frame, font_size: int = None, font_name: str = None, 
+                bold: bool = None, italic: bool = None, color: Tuple[int, int, int] = None,
+                alignment: str = None) -> None:
+    """
+    Format text in a text frame.
+    
+    Args:
+        text_frame: The text frame to format
+        font_size: Font size in points
+        font_name: Font name
+        bold: Whether text should be bold
+        italic: Whether text should be italic
+        color: RGB color tuple (r, g, b)
+        alignment: Text alignment ('left', 'center', 'right', 'justify')
+    """
+    alignment_map = {
+        'left': PP_ALIGN.LEFT,
+        'center': PP_ALIGN.CENTER,
+        'right': PP_ALIGN.RIGHT,
+        'justify': PP_ALIGN.JUSTIFY
+    }
+    
+    for paragraph in text_frame.paragraphs:
+        if alignment and alignment in alignment_map:
+            paragraph.alignment = alignment_map[alignment]
+            
+        for run in paragraph.runs:
+            font = run.font
+            
+            if font_size is not None:
+                font.size = Pt(font_size)
+            if font_name is not None:
+                font.name = font_name
+            if bold is not None:
+                font.bold = bold
+            if italic is not None:
+                font.italic = italic
+            if color is not None:
+                r, g, b = color
+                font.color.rgb = RGBColor(r, g, b)
+
+
+def format_text_advanced(text_frame, font_size: int = None, font_name: str = None, 
+                        bold: bool = None, italic: bool = None, underline: bool = None,
+                        color: Tuple[int, int, int] = None, bg_color: Tuple[int, int, int] = None,
+                        alignment: str = None, vertical_alignment: str = None) -> Dict:
+    """
+    Advanced text formatting with comprehensive options.
+    
+    Args:
+        text_frame: The text frame to format
+        font_size: Font size in points
+        font_name: Font name
+        bold: Whether text should be bold
+        italic: Whether text should be italic
+        underline: Whether text should be underlined
+        color: RGB color tuple (r, g, b)
+        bg_color: Background RGB color tuple (r, g, b)
+        alignment: Text alignment ('left', 'center', 'right', 'justify')
+        vertical_alignment: Vertical alignment ('top', 'middle', 'bottom')
+    
+    Returns:
+        Dictionary with formatting results
+    """
+    result = {
+        'success': True,
+        'warnings': []
+    }
+    
+    try:
+        alignment_map = {
+            'left': PP_ALIGN.LEFT,
+            'center': PP_ALIGN.CENTER,
+            'right': PP_ALIGN.RIGHT,
+            'justify': PP_ALIGN.JUSTIFY
+        }
+        
+        # Enable text wrapping
+        text_frame.word_wrap = True
+        
+        # Apply formatting to all paragraphs and runs
+        for paragraph in text_frame.paragraphs:
+            if alignment and alignment in alignment_map:
+                paragraph.alignment = alignment_map[alignment]
+            
+            for run in paragraph.runs:
+                font = run.font
+                
+                if font_size is not None:
+                    font.size = Pt(font_size)
+                if font_name is not None:
+                    font.name = font_name
+                if bold is not None:
+                    font.bold = bold
+                if italic is not None:
+                    font.italic = italic
+                if underline is not None:
+                    font.underline = underline
+                if color is not None:
+                    r, g, b = color
+                    font.color.rgb = RGBColor(r, g, b)
+        
+        return result
+        
+    except Exception as e:
+        result['success'] = False
+        result['error'] = str(e)
+        return result
+
+
+def add_image(slide, image_path: str, left: float, top: float, width: float = None, height: float = None) -> Any:
+    """
+    Add an image to a slide.
+    
+    Args:
+        slide: The slide object
+        image_path: Path to the image file
+        left: Left position in inches
+        top: Top position in inches
+        width: Width in inches (optional)
+        height: Height in inches (optional)
+        
+    Returns:
+        The created image shape
+    """
+    if width is not None and height is not None:
+        return slide.shapes.add_picture(
+            image_path, Inches(left), Inches(top), Inches(width), Inches(height)
+        )
+    elif width is not None:
+        return slide.shapes.add_picture(
+            image_path, Inches(left), Inches(top), Inches(width)
+        )
+    elif height is not None:
+        return slide.shapes.add_picture(
+            image_path, Inches(left), Inches(top), height=Inches(height)
+        )
+    else:
+        return slide.shapes.add_picture(
+            image_path, Inches(left), Inches(top)
+        )
+
+
+def add_table(slide, rows: int, cols: int, left: float, top: float, width: float, height: float) -> Any:
+    """
+    Add a table to a slide.
+    
+    Args:
+        slide: The slide object
+        rows: Number of rows
+        cols: Number of columns
+        left: Left position in inches
+        top: Top position in inches
+        width: Width in inches
+        height: Height in inches
+        
+    Returns:
+        The created table shape
+    """
+    return slide.shapes.add_table(
+        rows, cols, Inches(left), Inches(top), Inches(width), Inches(height)
+    )
+
+
+def format_table_cell(cell, font_size: int = None, font_name: str = None, 
+                     bold: bool = None, italic: bool = None, 
+                     color: Tuple[int, int, int] = None, bg_color: Tuple[int, int, int] = None,
+                     alignment: str = None, vertical_alignment: str = None) -> None:
+    """
+    Format a table cell.
+    
+    Args:
+        cell: The table cell object
+        font_size: Font size in points
+        font_name: Font name
+        bold: Whether text should be bold
+        italic: Whether text should be italic
+        color: RGB color tuple (r, g, b)
+        bg_color: Background RGB color tuple (r, g, b)
+        alignment: Text alignment
+        vertical_alignment: Vertical alignment
+    """
+    # Format text
+    if any([font_size, font_name, bold, italic, color, alignment]):
+        format_text_advanced(
+            cell.text_frame,
+            font_size=font_size,
+            font_name=font_name,
+            bold=bold,
+            italic=italic,
+            color=color,
+            alignment=alignment
+        )
+    
+    # Set background color
+    if bg_color:
+        cell.fill.solid()
+        cell.fill.fore_color.rgb = RGBColor(*bg_color)
+
+
+def add_chart(slide, chart_type: str, left: float, top: float, width: float, height: float,
+              categories: List[str], series_names: List[str], series_values: List[List[float]]) -> Any:
+    """
+    Add a chart to a slide.
+    
+    Args:
+        slide: The slide object
+        chart_type: Type of chart ('column', 'bar', 'line', 'pie', etc.)
+        left: Left position in inches
+        top: Top position in inches
+        width: Width in inches
+        height: Height in inches
+        categories: List of category names
+        series_names: List of series names
+        series_values: List of value lists for each series
+        
+    Returns:
+        The created chart object
+    """
+    # Map chart type names to enum values
+    chart_type_map = {
+        'column': XL_CHART_TYPE.COLUMN_CLUSTERED,
+        'stacked_column': XL_CHART_TYPE.COLUMN_STACKED,
+        'bar': XL_CHART_TYPE.BAR_CLUSTERED,
+        'stacked_bar': XL_CHART_TYPE.BAR_STACKED,
+        'line': XL_CHART_TYPE.LINE,
+        'line_markers': XL_CHART_TYPE.LINE_MARKERS,
+        'pie': XL_CHART_TYPE.PIE,
+        'doughnut': XL_CHART_TYPE.DOUGHNUT,
+        'area': XL_CHART_TYPE.AREA,
+        'stacked_area': XL_CHART_TYPE.AREA_STACKED,
+        'scatter': XL_CHART_TYPE.XY_SCATTER,
+        'radar': XL_CHART_TYPE.RADAR,
+        'radar_markers': XL_CHART_TYPE.RADAR_MARKERS
+    }
+    
+    xl_chart_type = chart_type_map.get(chart_type.lower(), XL_CHART_TYPE.COLUMN_CLUSTERED)
+    
+    # Create chart data
+    chart_data = CategoryChartData()
+    chart_data.categories = categories
+    
+    for i, series_name in enumerate(series_names):
+        if i < len(series_values):
+            chart_data.add_series(series_name, series_values[i])
+    
+    # Add chart to slide
+    chart_shape = slide.shapes.add_chart(
+        xl_chart_type, Inches(left), Inches(top), Inches(width), Inches(height), chart_data
+    )
+    
+    return chart_shape.chart
+
+
+def format_chart(chart, has_legend: bool = True, legend_position: str = 'right',
+                has_data_labels: bool = False, title: str = None,
+                x_axis_title: str = None, y_axis_title: str = None,
+                color_scheme: str = None) -> None:
+    """
+    Format a chart with various options.
+    
+    Args:
+        chart: The chart object
+        has_legend: Whether to show legend
+        legend_position: Position of legend ('right', 'top', 'bottom', 'left')
+        has_data_labels: Whether to show data labels
+        title: Chart title
+        x_axis_title: X-axis title
+        y_axis_title: Y-axis title
+        color_scheme: Color scheme to apply
+    """
+    try:
+        # Set chart title
+        if title:
+            chart.chart_title.text_frame.text = title
+        
+        # Configure legend
+        if has_legend:
+            chart.has_legend = True
+            # Note: Legend position setting may vary by chart type
+        else:
+            chart.has_legend = False
+        
+        # Configure data labels
+        if has_data_labels:
+            for series in chart.series:
+                series.has_data_labels = True
+        
+        # Set axis titles if available
+        try:
+            if x_axis_title and hasattr(chart, 'category_axis'):
+                chart.category_axis.axis_title.text_frame.text = x_axis_title
+            if y_axis_title and hasattr(chart, 'value_axis'):
+                chart.value_axis.axis_title.text_frame.text = y_axis_title
+        except:
+            pass  # Axis titles may not be available for all chart types
+            
+    except Exception:
+        pass  # Graceful degradation for chart formatting
+
+
+def extract_slide_text_content(slide) -> Dict:
+    """
+    Extract all text content from a slide including placeholders and text shapes.
+    
+    Args:
+        slide: The slide object to extract text from
+        
+    Returns:
+        Dictionary containing all text content organized by source type
+    """
+    try:
+        text_content = {
+            "slide_title": "",
+            "placeholders": [],
+            "text_shapes": [],
+            "table_text": [],
+            "all_text_combined": ""
+        }
+        
+        all_texts = []
+        
+        # Extract title from slide if available
+        if hasattr(slide, 'shapes') and hasattr(slide.shapes, 'title') and slide.shapes.title:
+            try:
+                title_text = slide.shapes.title.text_frame.text.strip()
+                if title_text:
+                    text_content["slide_title"] = title_text
+                    all_texts.append(title_text)
+            except:
+                pass
+        
+        # Extract text from all shapes
+        for i, shape in enumerate(slide.shapes):
+            shape_text_info = {
+                "shape_index": i,
+                "shape_name": shape.name,
+                "shape_type": str(shape.shape_type),
+                "text": ""
+            }
+            
+            try:
+                # Check if shape has text frame
+                if hasattr(shape, 'text_frame') and shape.text_frame:
+                    text = shape.text_frame.text.strip()
+                    if text:
+                        shape_text_info["text"] = text
+                        all_texts.append(text)
+                        
+                        # Categorize by shape type
+                        if hasattr(shape, 'placeholder_format'):
+                            # This is a placeholder
+                            placeholder_info = shape_text_info.copy()
+                            placeholder_info["placeholder_type"] = str(shape.placeholder_format.type)
+                            placeholder_info["placeholder_idx"] = shape.placeholder_format.idx
+                            text_content["placeholders"].append(placeholder_info)
+                        else:
+                            # This is a regular text shape
+                            text_content["text_shapes"].append(shape_text_info)
+                
+                # Extract text from tables
+                elif hasattr(shape, 'table'):
+                    table_texts = []
+                    table = shape.table
+                    for row_idx, row in enumerate(table.rows):
+                        row_texts = []
+                        for col_idx, cell in enumerate(row.cells):
+                            cell_text = cell.text_frame.text.strip()
+                            if cell_text:
+                                row_texts.append(cell_text)
+                                all_texts.append(cell_text)
+                        if row_texts:
+                            table_texts.append({
+                                "row": row_idx,
+                                "cells": row_texts
+                            })
+                    
+                    if table_texts:
+                        text_content["table_text"].append({
+                            "shape_index": i,
+                            "shape_name": shape.name,
+                            "table_content": table_texts
+                        })
+                        
+            except Exception as e:
+                # Skip shapes that can't be processed
+                continue
+        
+        # Combine all text
+        text_content["all_text_combined"] = "\n".join(all_texts)
+        
+        return {
+            "success": True,
+            "text_content": text_content,
+            "total_text_shapes": len(text_content["placeholders"]) + len(text_content["text_shapes"]),
+            "has_title": bool(text_content["slide_title"]),
+            "has_tables": len(text_content["table_text"]) > 0
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Failed to extract text content: {str(e)}",
+            "text_content": None
+        }

utils/core_utils.py

@@ -0,0 +1,55 @@
+"""
+Core utility functions for PowerPoint MCP Server.
+Basic operations and error handling.
+"""
+from typing import Any, Callable, List, Tuple, Optional
+
+
+def try_multiple_approaches(operation_name: str, approaches: List[Tuple[Callable, str]]) -> Tuple[Any, Optional[str]]:
+    """
+    Try multiple approaches to perform an operation, returning the first successful result.
+    
+    Args:
+        operation_name: Name of the operation for error reporting
+        approaches: List of (approach_func, description) tuples to try
+        
+    Returns:
+        Tuple of (result, None) if any approach succeeded, or (None, error_messages) if all failed
+    """
+    error_messages = []
+    
+    for approach_func, description in approaches:
+        try:
+            result = approach_func()
+            return result, None
+        except Exception as e:
+            error_messages.append(f"{description}: {str(e)}")
+    
+    return None, f"Failed to {operation_name} after trying multiple approaches: {'; '.join(error_messages)}"
+
+
+def safe_operation(operation_name: str, operation_func: Callable, error_message: Optional[str] = None, *args, **kwargs) -> Tuple[Any, Optional[str]]:
+    """
+    Execute an operation safely with standard error handling.
+    
+    Args:
+        operation_name: Name of the operation for error reporting
+        operation_func: Function to execute
+        error_message: Custom error message (optional)
+        *args, **kwargs: Arguments to pass to the operation function
+        
+    Returns:
+        A tuple (result, error) where error is None if operation was successful
+    """
+    try:
+        result = operation_func(*args, **kwargs)
+        return result, None
+    except ValueError as e:
+        error_msg = error_message or f"Invalid input for {operation_name}: {str(e)}"
+        return None, error_msg
+    except TypeError as e:
+        error_msg = error_message or f"Type error in {operation_name}: {str(e)}"
+        return None, error_msg
+    except Exception as e:
+        error_msg = error_message or f"Failed to execute {operation_name}: {str(e)}"
+        return None, error_msg