solidworks-mcp-python 1.5.0__py3-none-any.whl

solidworks_mcp/tools/automation.py

@@ -0,0 +1,578 @@
+"""Automation tools for SolidWorks MCP Server.
+
+Use these when the workflow is already defined and you need repeatable execution.
+Recommended order: generate_vba_code for complex steps, record or stop a macro when a
+manual flow should be captured, batch_process_files for many files, manage_design_table
+for configuration-driven variants, execute_workflow for scripted pipelines,
+create_template for reusable standards, and optimize_performance for tuning.
+"""
+
+from typing import Any
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from ..adapters.base import SolidWorksAdapter
+from .input_compat import CompatInput
+from .tool_boundary import (
+    UnsupportedOperationError,
+    require_capability,
+    require_success,
+    with_tool_boundary,
+)
+
+# Input schemas using Python 3.14 built-in types
+
+
+class GenerateVBAInput(CompatInput):
+    """Input schema for generating VBA code.
+
+    Attributes:
+        code_style (str): The code style value.
+        include_error_handling (bool): The include error handling value.
+        operation_description (str | None): The operation description value.
+        operation_type (str | None): The operation type value.
+        parameters (dict[str, Any]): The parameters value.
+        target_document (str): The target document value.
+    """
+
+    operation_description: str | None = Field(
+        default=None, description="Description of the operation to generate VBA for"
+    )
+    operation_type: str | None = Field(default=None, description="Operation type alias")
+    parameters: dict[str, Any] = Field(
+        default_factory=dict, description="Operation parameters"
+    )
+    target_document: str = Field(
+        default="Part", description="Target document type (Part, Assembly, Drawing)"
+    )
+    include_error_handling: bool = Field(
+        default=True, description="Include error handling in generated code"
+    )
+    code_style: str = Field(
+        default="professional",
+        description="Code style (simple, professional, advanced)",
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the generate vbainput.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        if self.operation_description is None:
+            self.operation_description = self.operation_type or "SolidWorks Operation"
+
+
+VBAGenerationInput = GenerateVBAInput
+
+
+class RecordMacroInput(CompatInput):
+    """Input schema for macro recording.
+
+    Attributes:
+        auto_start (bool): The auto start value.
+        capture_keyboard (bool): The capture keyboard value.
+        capture_mouse (bool): The capture mouse value.
+        description (str): The description value.
+        macro_name (str | None): The macro name value.
+        output_file (str | None): The output file value.
+        recording_mode (str | None): The recording mode value.
+        recording_name (str | None): The recording name value.
+    """
+
+    macro_name: str | None = Field(
+        default=None, description="Name for the recorded macro"
+    )
+    recording_name: str | None = Field(default=None, description="Recording name alias")
+    output_file: str | None = Field(default=None, description="Output file alias")
+    recording_mode: str | None = Field(default=None, description="Recording mode alias")
+    capture_mouse: bool = Field(default=True, description="Capture mouse actions")
+    capture_keyboard: bool = Field(default=True, description="Capture keyboard actions")
+    description: str = Field(
+        default="", description="Description of the macro functionality"
+    )
+    auto_start: bool = Field(default=True, description="Automatically start recording")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the record macro input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        if self.macro_name is None:
+            self.macro_name = self.recording_name or "Recorded Macro"
+
+
+class BatchProcessInput(CompatInput):
+    """Input schema for batch processing.
+
+    Attributes:
+        batch_operation (str | None): The batch operation value.
+        file_pattern (str | None): The file pattern value.
+        filter_patterns (list[str]): The filter patterns value.
+        operation (str | None): The operation value.
+        operation_type (str | None): The operation type value.
+        parallel_processing (bool): The parallel processing value.
+        recursive (bool): The recursive value.
+        source_directory (str): The source directory value.
+        target_format (str | None): The target format value.
+    """
+
+    source_directory: str = Field(description="Directory containing SolidWorks files")
+    operation_type: str | None = Field(
+        default=None,
+        description="Type of operation (rebuild, save_as, export, update_properties)",
+    )
+    batch_operation: str | None = Field(
+        default=None, description="Batch operation alias"
+    )
+    target_format: str | None = Field(
+        default=None, description="Target format for export operations"
+    )
+    file_pattern: str | None = Field(default=None, description="File pattern alias")
+    parallel_processing: bool = Field(
+        default=False, description="Parallel processing alias"
+    )
+    operation: str | None = Field(default=None, description="Operation alias")
+    recursive: bool = Field(
+        default=False, description="Process subdirectories recursively"
+    )
+    filter_patterns: list[str] = Field(
+        default=["*.sldprt", "*.sldasm"], description="File patterns to process"
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the batch process input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        if self.operation_type is None:
+            self.operation_type = self.batch_operation or self.operation or "export"
+
+
+class DesignTableInput(CompatInput):
+    """Input schema for design table operations.
+
+    Attributes:
+        auto_create_configurations (bool): The auto create configurations value.
+        auto_update (bool): The auto update value.
+        configurations (list[str]): The configurations value.
+        create_configurations (bool): The create configurations value.
+        excel_file (str | None): The excel file value.
+        model_path (str | None): The model path value.
+        operation (str | None): The operation value.
+        parameters (list[str]): The parameters value.
+        table_file (str | None): The table file value.
+        table_type (str | None): The table type value.
+    """
+
+    table_type: str | None = Field(
+        default=None, description="Type of design table (create, update, import)"
+    )
+    model_path: str | None = Field(default=None, description="Model path alias")
+    table_file: str | None = Field(default=None, description="Design table file alias")
+    operation: str | None = Field(default=None, description="Operation alias")
+    auto_update: bool = Field(default=False, description="Auto update alias")
+    create_configurations: bool = Field(
+        default=False, description="Create configurations alias"
+    )
+    auto_create_configurations: bool = Field(
+        default=False, description="Auto-create alias"
+    )
+    excel_file: str | None = Field(
+        default=None, description="Excel file path for import/export"
+    )
+    parameters: list[str] = Field(
+        default=[], description="Parameters to include in design table"
+    )
+    configurations: list[str] = Field(default=[], description="Configuration names")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the design table input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        if self.table_type is None:
+            self.table_type = self.operation or "create"
+        if self.create_configurations:
+            self.auto_create_configurations = True
+
+
+class WorkflowInput(CompatInput):
+    """Input schema for workflow automation.
+
+    Attributes:
+        error_handling (str): The error handling value.
+        parallel_execution (bool): The parallel execution value.
+        steps (list[dict[str, Any]]): The steps value.
+        workflow_name (str): The workflow name value.
+    """
+
+    workflow_name: str = Field(description="Name of the workflow")
+    steps: list[dict[str, Any]] = Field(description="List of workflow steps")
+    parallel_execution: bool = Field(
+        default=False, description="Execute compatible steps in parallel"
+    )
+    error_handling: str = Field(
+        default="stop", description="Error handling strategy (stop, skip, retry)"
+    )
+
+
+class TemplateInput(CompatInput):
+    """Input schema for template operations.
+
+    Attributes:
+        base_file (str | None): The base file value.
+        include_custom_properties (bool): The include custom properties value.
+        include_features (list[str]): The include features value.
+        include_materials (bool): The include materials value.
+        metadata (dict[str, Any]): The metadata value.
+        output_path (str | None): The output path value.
+        source_model (str | None): The source model value.
+        template_name (str): The template name value.
+        template_type (str): The template type value.
+    """
+
+    template_type: str = Field(description="Type of template (part, assembly, drawing)")
+    template_name: str = Field(description="Name for the template")
+    base_file: str | None = Field(
+        default=None, description="Base file to create template from"
+    )
+    source_model: str | None = Field(default=None, description="Source model alias")
+    output_path: str | None = Field(default=None, description="Output path alias")
+    include_custom_properties: bool = Field(
+        default=False, description="Include custom properties alias"
+    )
+    include_materials: bool = Field(
+        default=False, description="Include materials alias"
+    )
+    include_features: list[str] = Field(
+        default_factory=list, description="Include features alias"
+    )
+    metadata: dict[str, Any] = Field(
+        default={}, description="Template metadata and properties"
+    )
+
+
+async def register_automation_tools(
+    mcp: FastMCP, adapter: SolidWorksAdapter, config: dict[str, Any]
+) -> int:
+    """Register automation tools with FastMCP.
+
+    Registers comprehensive automation tools for SolidWorks workflow orchestration including
+    VBA generation, macro recording, batch processing, and template management.
+
+    Args:
+        mcp (FastMCP): The mcp value.
+        adapter (SolidWorksAdapter): Adapter instance used for the operation.
+        config (dict[str, Any]): Configuration values for the operation.
+
+    Returns:
+        int: The computed numeric result.
+    """
+    mcp = with_tool_boundary(mcp)
+    tool_count = 0
+
+    @mcp.tool()
+    async def generate_vba_code(input_data: GenerateVBAInput) -> dict[str, Any]:
+        """Generate VBA code for SolidWorks automation.
+
+        Analyzes operation description and generates appropriate VBA code with SolidWorks API
+        calls, error handling, and documentation.
+
+        Args:
+            input_data (GenerateVBAInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            result = await generate_vba_code({
+                                "operation_description": "Create rectangular extrusion",
+                                "target_document": "Part",
+                                "include_error_handling": True
+                            })
+                            ```
+        """
+        if hasattr(adapter, "generate_vba_code"):
+            result = await adapter.generate_vba_code(input_data.model_dump())
+            require_success(result, "Failed to generate VBA code")
+            return {
+                "status": "success",
+                "message": f"Generated VBA code for: {input_data.operation_description}",
+                "data": result.data,
+                "execution_time": result.execution_time,
+            }
+
+        # Build a VBA code skeleton from the operation description. This
+        # is real, usable output (a labelled template), not a stand-in
+        # for a SolidWorks operation that was supposed to run.
+        sample_vba = f"""
+' Generated VBA code for: {input_data.operation_description}
+' Target: {input_data.target_document}
+' Generated by: SolidWorks MCP Server
+
+Option Explicit
+
+Sub {(input_data.operation_description or "").replace(" ", "_")}()
+Dim swApp As SldWorks.SldWorks
+Dim swModel As SldWorks.ModelDoc2
+
+{("On Error GoTo ErrorHandler" if input_data.include_error_handling else "")}
+
+' Connect to SolidWorks
+Set swApp = Application.SldWorks
+Set swModel = swApp.ActiveDoc
+
+If swModel Is Nothing Then
+    MsgBox "No active document found"
+    Exit Sub
+End If
+
+' Main operation code would go here
+' TODO: Implement specific operation
+
+MsgBox "Operation completed successfully"
+Exit Sub
+
+{("ErrorHandler:" if input_data.include_error_handling else "")}
+{('    MsgBox "Error: " & Err.Description' if input_data.include_error_handling else "")}
+{("    Resume Next" if input_data.include_error_handling else "")}
+
+End Sub
+"""
+
+        return {
+            "status": "success",
+            "message": f"Generated VBA code for: {input_data.operation_description}",
+            "vba_code": {
+                "code": sample_vba.strip(),
+                "operation": input_data.operation_description,
+                "target_document": input_data.target_document,
+                "style": input_data.code_style,
+                "lines_of_code": len(sample_vba.strip().split("\n")),
+                "includes_error_handling": input_data.include_error_handling,
+            },
+        }
+
+    @mcp.tool(name="automation_start_macro_recording")
+    async def start_macro_recording(input_data: RecordMacroInput) -> dict[str, Any]:
+        """Start recording a macro in SolidWorks.
+
+        Begins macro recording to capture user actions and generate reusable automation scripts.
+
+        Args:
+            input_data (RecordMacroInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "start_macro_recording",
+            "Active adapter does not support start_macro_recording; "
+            f"no recording of {input_data.macro_name} was started.",
+        )
+        result = await adapter.start_macro_recording(input_data.model_dump())
+        require_success(result, "Failed to start macro recording")
+        return {
+            "status": "success",
+            "message": f"Started recording macro: {input_data.macro_name}",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool(name="automation_stop_macro_recording")
+    async def stop_macro_recording(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Stop recording the current macro.
+
+        This tool stops the active macro recording and saves the recorded actions as a VBA
+        macro.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        raise UnsupportedOperationError(
+            "No adapter capability exists for stopping a macro "
+            "recording; this tool never started a real recording "
+            "session, so there is nothing to stop or save."
+        )
+
+    @mcp.tool()
+    async def batch_process_files(input_data: BatchProcessInput) -> dict[str, Any]:
+        """Handle batch process files.
+
+        This tool processes multiple files in a directory, performing operations like rebuild,
+        save as, export, or property updates.
+
+        Args:
+            input_data (BatchProcessInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "batch_process_files",
+            "Active adapter does not support batch_process_files; no "
+            f"files in {input_data.source_directory} were processed.",
+        )
+        result = await adapter.batch_process_files(input_data.model_dump())
+        require_success(result, "Batch processing failed")
+        return {
+            "status": "success",
+            "message": f"Batch {input_data.operation_type} completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def manage_design_table(input_data: DesignTableInput) -> dict[str, Any]:
+        """Create or manage design tables for parametric modeling.
+
+        Design tables allow you to create multiple configurations of a part or assembly by
+        driving parameters from an Excel spreadsheet.
+
+        Args:
+            input_data (DesignTableInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "manage_design_table",
+            "Active adapter does not support manage_design_table; no "
+            f"{input_data.table_type} operation was performed.",
+        )
+        result = await adapter.manage_design_table(input_data.model_dump())
+        require_success(result, "Design table management failed")
+        return {
+            "status": "success",
+            "message": f"Design table {input_data.table_type} completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def execute_workflow(input_data: WorkflowInput) -> dict[str, Any]:
+        """Handle execute workflow.
+
+        This tool executes a series of automated steps in sequence, with support for parallel
+        execution and error handling.
+
+        Args:
+            input_data (WorkflowInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "execute_workflow",
+            "Active adapter does not support execute_workflow; "
+            f"workflow '{input_data.workflow_name}' was not run.",
+        )
+        result = await adapter.execute_workflow(input_data.model_dump())
+        require_success(result, "Workflow execution failed")
+        return {
+            "status": "success",
+            "message": f"Workflow '{input_data.workflow_name}' completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def create_template(input_data: TemplateInput) -> dict[str, Any]:
+        """Create a SolidWorks template file.
+
+        This tool creates templates for parts, assemblies, or drawings with standardized
+        settings, materials, and configurations.
+
+        Args:
+            input_data (TemplateInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "create_template",
+            "Active adapter does not support create_template; no "
+            f"{input_data.template_type} template "
+            f"'{input_data.template_name}' was created.",
+        )
+        result = await adapter.create_template(input_data.model_dump())
+        require_success(result, "Template creation failed")
+        return {
+            "status": "success",
+            "message": f"Created {input_data.template_type} template: {input_data.template_name}",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def optimize_performance(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Optimize SolidWorks performance settings.
+
+        This tool analyzes the current SolidWorks configuration and suggests or applies
+        performance optimizations.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "optimize_performance",
+            "Active adapter does not support optimize_performance; "
+            "no settings were analyzed or changed.",
+        )
+        result = await adapter.optimize_performance(input_data)
+        require_success(result, "Performance optimization failed")
+        return {
+            "status": "success",
+            "message": "Performance optimization completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    tool_count = 8  # Number of tools registered
+    return tool_count
+
+
+class PerformanceOptimizationInput(CompatInput):
+    """Input schema for performance optimization.
+
+    Attributes:
+        optimization_type (str): The optimization type value.
+        parameters (dict[str, Any]): The parameters value.
+        target_metric (str): The target metric value.
+    """
+
+    optimization_type: str = Field(description="Type of optimization to perform")
+    target_metric: str = Field(default="speed", description="Target performance metric")
+    parameters: dict[str, Any] = Field(
+        default={}, description="Optimization parameters"
+    )