mcpcn-office-powerpoint-mcp-server 2.1.1__py3-none-any.whl → 2.1.2__py3-none-any.whl

tools/hyperlink_tools.py

@@ -1,138 +1,138 @@
-"""
-Hyperlink management tools for PowerPoint MCP Server.
-Implements hyperlink operations for text shapes and runs.
-"""
-
-from typing import Dict, List, Optional, Any
-
-def register_hyperlink_tools(app, presentations, get_current_presentation_id, validate_parameters, 
-                          is_positive, is_non_negative, is_in_range, is_valid_rgb):
-    """Register hyperlink management tools with the FastMCP app."""
-    
-    @app.tool()
-    def manage_hyperlinks(
-        operation: str,
-        slide_index: int,
-        shape_index: int = None,
-        text: str = None, 
-        url: str = None,
-        run_index: int = 0,
-        presentation_id: str = None
-    ) -> Dict:
-        """
-        Manage hyperlinks in text shapes and runs.
-        
-        Args:
-            operation: Operation type ("add", "remove", "list", "update")
-            slide_index: Index of the slide (0-based)
-            shape_index: Index of the shape on the slide (0-based)
-            text: Text to make into hyperlink (for "add" operation)
-            url: URL for the hyperlink
-            run_index: Index of text run within the shape (0-based)
-            presentation_id: Optional presentation ID (uses current if not provided)
-            
-        Returns:
-            Dictionary with operation results
-        """
-        try:
-            # Get presentation
-            pres_id = presentation_id or get_current_presentation_id()
-            if pres_id not in presentations:
-                return {"error": "Presentation not found"}
-            
-            pres = presentations[pres_id]
-            
-            # Validate slide index
-            if not (0 <= slide_index < len(pres.slides)):
-                return {"error": f"Slide index {slide_index} out of range"}
-            
-            slide = pres.slides[slide_index]
-            
-            if operation == "list":
-                # List all hyperlinks in the slide
-                hyperlinks = []
-                for shape_idx, shape in enumerate(slide.shapes):
-                    if hasattr(shape, 'text_frame') and shape.text_frame:
-                        for para_idx, paragraph in enumerate(shape.text_frame.paragraphs):
-                            for run_idx, run in enumerate(paragraph.runs):
-                                if run.hyperlink.address:
-                                    hyperlinks.append({
-                                        "shape_index": shape_idx,
-                                        "paragraph_index": para_idx,
-                                        "run_index": run_idx,
-                                        "text": run.text,
-                                        "url": run.hyperlink.address
-                                    })
-                
-                return {
-                    "message": f"Found {len(hyperlinks)} hyperlinks on slide {slide_index}",
-                    "hyperlinks": hyperlinks
-                }
-            
-            # For other operations, validate shape index
-            if shape_index is None or not (0 <= shape_index < len(slide.shapes)):
-                return {"error": f"Shape index {shape_index} out of range"}
-            
-            shape = slide.shapes[shape_index]
-            
-            # Check if shape has text
-            if not hasattr(shape, 'text_frame') or not shape.text_frame:
-                return {"error": "Shape does not contain text"}
-            
-            if operation == "add":
-                if not text or not url:
-                    return {"error": "Both 'text' and 'url' are required for adding hyperlinks"}
-                
-                # Add new text run with hyperlink
-                paragraph = shape.text_frame.paragraphs[0]
-                run = paragraph.add_run()
-                run.text = text
-                run.hyperlink.address = url
-                
-                return {
-                    "message": f"Added hyperlink '{text}' -> '{url}' to shape {shape_index}",
-                    "text": text,
-                    "url": url
-                }
-            
-            elif operation == "update":
-                if not url:
-                    return {"error": "URL is required for updating hyperlinks"}
-                
-                # Update existing hyperlink
-                paragraphs = shape.text_frame.paragraphs
-                if run_index < len(paragraphs[0].runs):
-                    run = paragraphs[0].runs[run_index]
-                    old_url = run.hyperlink.address
-                    run.hyperlink.address = url
-                    
-                    return {
-                        "message": f"Updated hyperlink from '{old_url}' to '{url}'",
-                        "old_url": old_url,
-                        "new_url": url,
-                        "text": run.text
-                    }
-                else:
-                    return {"error": f"Run index {run_index} out of range"}
-            
-            elif operation == "remove":
-                # Remove hyperlink from specific run
-                paragraphs = shape.text_frame.paragraphs
-                if run_index < len(paragraphs[0].runs):
-                    run = paragraphs[0].runs[run_index]
-                    old_url = run.hyperlink.address
-                    run.hyperlink.address = None
-                    
-                    return {
-                        "message": f"Removed hyperlink '{old_url}' from text '{run.text}'",
-                        "removed_url": old_url,
-                        "text": run.text
-                    }
-                else:
-                    return {"error": f"Run index {run_index} out of range"}
-            
-            else:
-                return {"error": f"Unsupported operation: {operation}. Use 'add', 'remove', 'list', or 'update'"}
-                
-        except Exception as e:
+"""
+Hyperlink management tools for PowerPoint MCP Server.
+Implements hyperlink operations for text shapes and runs.
+"""
+
+from typing import Dict, List, Optional, Any
+
+def register_hyperlink_tools(app, presentations, get_current_presentation_id, validate_parameters, 
+                          is_positive, is_non_negative, is_in_range, is_valid_rgb):
+    """Register hyperlink management tools with the FastMCP app."""
+    
+    @app.tool()
+    def manage_hyperlinks(
+        operation: str,
+        slide_index: int,
+        shape_index: int = None,
+        text: str = None, 
+        url: str = None,
+        run_index: int = 0,
+        presentation_id: str = None
+    ) -> Dict:
+        """
+        Manage hyperlinks in text shapes and runs.
+        
+        Args:
+            operation: Operation type ("add", "remove", "list", "update")
+            slide_index: Index of the slide (0-based)
+            shape_index: Index of the shape on the slide (0-based)
+            text: Text to make into hyperlink (for "add" operation)
+            url: URL for the hyperlink
+            run_index: Index of text run within the shape (0-based)
+            presentation_id: Optional presentation ID (uses current if not provided)
+            
+        Returns:
+            Dictionary with operation results
+        """
+        try:
+            # Get presentation
+            pres_id = presentation_id or get_current_presentation_id()
+            if pres_id not in presentations:
+                return {"error": "Presentation not found"}
+            
+            pres = presentations[pres_id]
+            
+            # Validate slide index
+            if not (0 <= slide_index < len(pres.slides)):
+                return {"error": f"Slide index {slide_index} out of range"}
+            
+            slide = pres.slides[slide_index]
+            
+            if operation == "list":
+                # List all hyperlinks in the slide
+                hyperlinks = []
+                for shape_idx, shape in enumerate(slide.shapes):
+                    if hasattr(shape, 'text_frame') and shape.text_frame:
+                        for para_idx, paragraph in enumerate(shape.text_frame.paragraphs):
+                            for run_idx, run in enumerate(paragraph.runs):
+                                if run.hyperlink.address:
+                                    hyperlinks.append({
+                                        "shape_index": shape_idx,
+                                        "paragraph_index": para_idx,
+                                        "run_index": run_idx,
+                                        "text": run.text,
+                                        "url": run.hyperlink.address
+                                    })
+                
+                return {
+                    "message": f"Found {len(hyperlinks)} hyperlinks on slide {slide_index}",
+                    "hyperlinks": hyperlinks
+                }
+            
+            # For other operations, validate shape index
+            if shape_index is None or not (0 <= shape_index < len(slide.shapes)):
+                return {"error": f"Shape index {shape_index} out of range"}
+            
+            shape = slide.shapes[shape_index]
+            
+            # Check if shape has text
+            if not hasattr(shape, 'text_frame') or not shape.text_frame:
+                return {"error": "Shape does not contain text"}
+            
+            if operation == "add":
+                if not text or not url:
+                    return {"error": "Both 'text' and 'url' are required for adding hyperlinks"}
+                
+                # Add new text run with hyperlink
+                paragraph = shape.text_frame.paragraphs[0]
+                run = paragraph.add_run()
+                run.text = text
+                run.hyperlink.address = url
+                
+                return {
+                    "message": f"Added hyperlink '{text}' -> '{url}' to shape {shape_index}",
+                    "text": text,
+                    "url": url
+                }
+            
+            elif operation == "update":
+                if not url:
+                    return {"error": "URL is required for updating hyperlinks"}
+                
+                # Update existing hyperlink
+                paragraphs = shape.text_frame.paragraphs
+                if run_index < len(paragraphs[0].runs):
+                    run = paragraphs[0].runs[run_index]
+                    old_url = run.hyperlink.address
+                    run.hyperlink.address = url
+                    
+                    return {
+                        "message": f"Updated hyperlink from '{old_url}' to '{url}'",
+                        "old_url": old_url,
+                        "new_url": url,
+                        "text": run.text
+                    }
+                else:
+                    return {"error": f"Run index {run_index} out of range"}
+            
+            elif operation == "remove":
+                # Remove hyperlink from specific run
+                paragraphs = shape.text_frame.paragraphs
+                if run_index < len(paragraphs[0].runs):
+                    run = paragraphs[0].runs[run_index]
+                    old_url = run.hyperlink.address
+                    run.hyperlink.address = None
+                    
+                    return {
+                        "message": f"Removed hyperlink '{old_url}' from text '{run.text}'",
+                        "removed_url": old_url,
+                        "text": run.text
+                    }
+                else:
+                    return {"error": f"Run index {run_index} out of range"}
+            
+            else:
+                return {"error": f"Unsupported operation: {operation}. Use 'add', 'remove', 'list', or 'update'"}
+                
+        except Exception as e:
             return {"error": f"Failed to manage hyperlinks: {str(e)}"}

tools/master_tools.py

@@ -1,114 +1,114 @@
-"""
-Slide master management tools for PowerPoint MCP Server.
-Implements slide master and layout access capabilities.
-"""
-
-from typing import Dict, List, Optional, Any
-
-def register_master_tools(app, presentations, get_current_presentation_id, validate_parameters, 
-                          is_positive, is_non_negative, is_in_range, is_valid_rgb):
-    """Register slide master management tools with the FastMCP app."""
-    
-    @app.tool()
-    def manage_slide_masters(
-        operation: str,
-        master_index: int = 0,
-        layout_index: int = None,
-        presentation_id: str = None
-    ) -> Dict:
-        """
-        Access and manage slide master properties and layouts.
-        
-        Args:
-            operation: Operation type ("list", "get_layouts", "get_info")
-            master_index: Index of the slide master (0-based)
-            layout_index: Index of specific layout within master (0-based)
-            presentation_id: Optional presentation ID (uses current if not provided)
-            
-        Returns:
-            Dictionary with slide master information
-        """
-        try:
-            # Get presentation
-            pres_id = presentation_id or get_current_presentation_id()
-            if pres_id not in presentations:
-                return {"error": "Presentation not found"}
-            
-            pres = presentations[pres_id]
-            
-            if operation == "list":
-                # List all slide masters
-                masters_info = []
-                for idx, master in enumerate(pres.slide_masters):
-                    masters_info.append({
-                        "index": idx,
-                        "layout_count": len(master.slide_layouts),
-                        "name": getattr(master, 'name', f"Master {idx}")
-                    })
-                
-                return {
-                    "message": f"Found {len(masters_info)} slide masters",
-                    "masters": masters_info,
-                    "total_masters": len(pres.slide_masters)
-                }
-            
-            # Validate master index
-            if not (0 <= master_index < len(pres.slide_masters)):
-                return {"error": f"Master index {master_index} out of range"}
-            
-            master = pres.slide_masters[master_index]
-            
-            if operation == "get_layouts":
-                # Get all layouts for a specific master
-                layouts_info = []
-                for idx, layout in enumerate(master.slide_layouts):
-                    layouts_info.append({
-                        "index": idx,
-                        "name": layout.name,
-                        "placeholder_count": len(layout.placeholders) if hasattr(layout, 'placeholders') else 0
-                    })
-                
-                return {
-                    "message": f"Master {master_index} has {len(layouts_info)} layouts",
-                    "master_index": master_index,
-                    "layouts": layouts_info
-                }
-            
-            elif operation == "get_info":
-                # Get detailed info about master or specific layout
-                if layout_index is not None:
-                    if not (0 <= layout_index < len(master.slide_layouts)):
-                        return {"error": f"Layout index {layout_index} out of range"}
-                    
-                    layout = master.slide_layouts[layout_index]
-                    placeholders_info = []
-                    
-                    if hasattr(layout, 'placeholders'):
-                        for placeholder in layout.placeholders:
-                            placeholders_info.append({
-                                "idx": placeholder.placeholder_format.idx,
-                                "type": str(placeholder.placeholder_format.type),
-                                "name": getattr(placeholder, 'name', 'Unnamed')
-                            })
-                    
-                    return {
-                        "message": f"Layout info for master {master_index}, layout {layout_index}",
-                        "master_index": master_index,
-                        "layout_index": layout_index,
-                        "layout_name": layout.name,
-                        "placeholders": placeholders_info
-                    }
-                else:
-                    # Master info
-                    return {
-                        "message": f"Master {master_index} information",
-                        "master_index": master_index,
-                        "layout_count": len(master.slide_layouts),
-                        "name": getattr(master, 'name', f"Master {master_index}")
-                    }
-            
-            else:
-                return {"error": f"Unsupported operation: {operation}. Use 'list', 'get_layouts', or 'get_info'"}
-                
-        except Exception as e:
+"""
+Slide master management tools for PowerPoint MCP Server.
+Implements slide master and layout access capabilities.
+"""
+
+from typing import Dict, List, Optional, Any
+
+def register_master_tools(app, presentations, get_current_presentation_id, validate_parameters, 
+                          is_positive, is_non_negative, is_in_range, is_valid_rgb):
+    """Register slide master management tools with the FastMCP app."""
+    
+    @app.tool()
+    def manage_slide_masters(
+        operation: str,
+        master_index: int = 0,
+        layout_index: int = None,
+        presentation_id: str = None
+    ) -> Dict:
+        """
+        Access and manage slide master properties and layouts.
+        
+        Args:
+            operation: Operation type ("list", "get_layouts", "get_info")
+            master_index: Index of the slide master (0-based)
+            layout_index: Index of specific layout within master (0-based)
+            presentation_id: Optional presentation ID (uses current if not provided)
+            
+        Returns:
+            Dictionary with slide master information
+        """
+        try:
+            # Get presentation
+            pres_id = presentation_id or get_current_presentation_id()
+            if pres_id not in presentations:
+                return {"error": "Presentation not found"}
+            
+            pres = presentations[pres_id]
+            
+            if operation == "list":
+                # List all slide masters
+                masters_info = []
+                for idx, master in enumerate(pres.slide_masters):
+                    masters_info.append({
+                        "index": idx,
+                        "layout_count": len(master.slide_layouts),
+                        "name": getattr(master, 'name', f"Master {idx}")
+                    })
+                
+                return {
+                    "message": f"Found {len(masters_info)} slide masters",
+                    "masters": masters_info,
+                    "total_masters": len(pres.slide_masters)
+                }
+            
+            # Validate master index
+            if not (0 <= master_index < len(pres.slide_masters)):
+                return {"error": f"Master index {master_index} out of range"}
+            
+            master = pres.slide_masters[master_index]
+            
+            if operation == "get_layouts":
+                # Get all layouts for a specific master
+                layouts_info = []
+                for idx, layout in enumerate(master.slide_layouts):
+                    layouts_info.append({
+                        "index": idx,
+                        "name": layout.name,
+                        "placeholder_count": len(layout.placeholders) if hasattr(layout, 'placeholders') else 0
+                    })
+                
+                return {
+                    "message": f"Master {master_index} has {len(layouts_info)} layouts",
+                    "master_index": master_index,
+                    "layouts": layouts_info
+                }
+            
+            elif operation == "get_info":
+                # Get detailed info about master or specific layout
+                if layout_index is not None:
+                    if not (0 <= layout_index < len(master.slide_layouts)):
+                        return {"error": f"Layout index {layout_index} out of range"}
+                    
+                    layout = master.slide_layouts[layout_index]
+                    placeholders_info = []
+                    
+                    if hasattr(layout, 'placeholders'):
+                        for placeholder in layout.placeholders:
+                            placeholders_info.append({
+                                "idx": placeholder.placeholder_format.idx,
+                                "type": str(placeholder.placeholder_format.type),
+                                "name": getattr(placeholder, 'name', 'Unnamed')
+                            })
+                    
+                    return {
+                        "message": f"Layout info for master {master_index}, layout {layout_index}",
+                        "master_index": master_index,
+                        "layout_index": layout_index,
+                        "layout_name": layout.name,
+                        "placeholders": placeholders_info
+                    }
+                else:
+                    # Master info
+                    return {
+                        "message": f"Master {master_index} information",
+                        "master_index": master_index,
+                        "layout_count": len(master.slide_layouts),
+                        "name": getattr(master, 'name', f"Master {master_index}")
+                    }
+            
+            else:
+                return {"error": f"Unsupported operation: {operation}. Use 'list', 'get_layouts', or 'get_info'"}
+                
+        except Exception as e:
             return {"error": f"Failed to manage slide masters: {str(e)}"}