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

solidworks_mcp/tools/drawing_analysis.py

@@ -0,0 +1,456 @@
+"""Advanced Drawing Analysis tools for SolidWorks MCP Server.
+
+Provides advanced analysis capabilities for drawing documents including dimension
+analysis, view analysis, annotation checking, and compliance verification.
+"""
+
+from typing import Any
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from ..adapters.base import SolidWorksAdapter
+from .file_facts import file_fact_snapshot
+from .input_compat import CompatInput
+from .tool_boundary import (
+    InvalidInputError,
+    ToolOperationError,
+    UnsupportedOperationError,
+    require_capability,
+    require_success,
+    with_tool_boundary,
+)
+
+# Input schemas for drawing analysis
+
+
+class DrawingAnalysisInput(CompatInput):
+    """Input schema for drawing analysis operations.
+
+    Attributes:
+        analysis_depth (str): The analysis depth value.
+        analysis_type (str): The analysis type value.
+        drawing_path (str): The drawing path value.
+        generate_report (bool): The generate report value.
+        standards_check (bool): The standards check value.
+    """
+
+    drawing_path: str = Field(description="Path to drawing file (.slddrw)")
+    analysis_type: str = Field(
+        default="comprehensive",
+        description="Analysis type (comprehensive, dimensions, views, annotations)",
+    )
+    analysis_depth: str = Field(default="Basic", description="Analysis depth level")
+    standards_check: bool = Field(
+        default=True, description="Check against drafting standards"
+    )
+    generate_report: bool = Field(default=True, description="Generate detailed report")
+
+
+class DimensionAnalysisInput(CompatInput):
+    """Input schema for dimension analysis.
+
+    Attributes:
+        check_completeness (bool): The check completeness value.
+        check_precision (bool): The check precision value.
+        check_tolerances (bool): The check tolerances value.
+        drawing_path (str): The drawing path value.
+    """
+
+    drawing_path: str = Field(description="Path to drawing file")
+    check_precision: bool = Field(
+        default=True, description="Check dimension precision consistency"
+    )
+    check_tolerances: bool = Field(
+        default=True, description="Check tolerance formatting"
+    )
+    check_completeness: bool = Field(
+        default=True, description="Check dimension completeness"
+    )
+
+
+class AnnotationAnalysisInput(CompatInput):
+    """Input schema for annotation analysis.
+
+    Attributes:
+        check_annotations (bool): The check annotations value.
+        check_notes (bool): The check notes value.
+        check_symbols (bool): The check symbols value.
+        check_text_styles (bool): The check text styles value.
+        drawing_path (str): The drawing path value.
+    """
+
+    drawing_path: str = Field(description="Path to drawing file")
+    check_notes: bool = Field(
+        default=True, description="Check note formatting and content"
+    )
+    check_symbols: bool = Field(
+        default=True, description="Check symbol usage and placement"
+    )
+    check_text_styles: bool = Field(
+        default=True, description="Check text style consistency"
+    )
+    check_annotations: bool = Field(default=True, description="Alias used by tests")
+
+
+class ComplianceCheckInput(CompatInput):
+    """Input schema for standards compliance checking.
+
+    Attributes:
+        check_sheet_format (bool): The check sheet format value.
+        check_title_block (bool): The check title block value.
+        drawing_path (str): The drawing path value.
+        standard (str): The standard value.
+        standards_to_check (list[str]): The standards to check value.
+    """
+
+    drawing_path: str = Field(description="Path to drawing file")
+    standard: str = Field(
+        default="ISO", description="Standard to check against (ISO, ANSI, DIN)"
+    )
+    standards_to_check: list[str] = Field(
+        default_factory=lambda: ["ISO"], description="Standards list alias"
+    )
+    check_title_block: bool = Field(
+        default=True, description="Check title block compliance"
+    )
+    check_sheet_format: bool = Field(
+        default=True, description="Check sheet format compliance"
+    )
+
+
+async def register_drawing_analysis_tools(
+    mcp: FastMCP, adapter: SolidWorksAdapter, config: Any
+) -> int:
+    """Register advanced drawing analysis tools with FastMCP.
+
+    Args:
+        mcp (FastMCP): The mcp value.
+        adapter (SolidWorksAdapter): Adapter instance used for the operation.
+        config (Any): Configuration values for the operation.
+
+    Returns:
+        int: The computed numeric result.
+
+    Example:
+                        >>> tool_count = await register_drawing_analysis_tools(mcp, adapter, config)
+    """
+    mcp = with_tool_boundary(mcp)
+    tool_count = 0
+
+    @mcp.tool()
+    async def analyze_drawing_comprehensive(
+        input_data: DrawingAnalysisInput,
+    ) -> dict[str, Any]:
+        """Handle analyze drawing comprehensive.
+
+        Args:
+            input_data (DrawingAnalysisInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await analyze_drawing_comprehensive(analysis_input)
+        """
+        require_capability(
+            adapter,
+            "analyze_drawing_comprehensive",
+            "Active adapter does not support "
+            "analyze_drawing_comprehensive; no analysis of "
+            f"{input_data.drawing_path} was performed.",
+        )
+        result = await adapter.analyze_drawing_comprehensive(input_data.model_dump())
+        require_success(result, "Failed to analyze drawing")
+        return {
+            "status": "success",
+            "message": "Comprehensive drawing analysis completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def analyze_drawing_dimensions(
+        input_data: DimensionAnalysisInput,
+    ) -> dict[str, Any]:
+        """Analyze dimensions in a SolidWorks drawing for consistency and completeness.
+
+        This tool performs detailed dimensional analysis including precision, tolerances, and
+        completeness checking.
+
+        Args:
+            input_data (DimensionAnalysisInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await analyze_drawing_dimensions(dimension_input)
+        """
+
+        require_capability(
+            adapter,
+            "analyze_drawing_dimensions",
+            "Active adapter does not support analyze_drawing_dimensions; "
+            f"no analysis of {input_data.drawing_path} was performed.",
+        )
+        result = await adapter.analyze_drawing_dimensions(input_data.model_dump())
+        require_success(result, "Failed to analyze dimensions")
+        return {
+            "status": "success",
+            "message": "Dimension analysis completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def analyze_drawing_annotations(
+        input_data: AnnotationAnalysisInput,
+    ) -> dict[str, Any]:
+        """Analyze drawing annotations and notes quality.
+
+        Args:
+            input_data (AnnotationAnalysisInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await analyze_drawing_annotations(annotation_input)
+        """
+        """
+        Analyze annotations in a SolidWorks drawing for consistency and standards compliance.
+
+        This tool examines notes, symbols, and text formatting for quality and compliance.
+        """
+        require_capability(
+            adapter,
+            "analyze_drawing_annotations",
+            "Active adapter does not support analyze_drawing_annotations; "
+            f"no analysis of {input_data.drawing_path} was performed.",
+        )
+        result = await adapter.analyze_drawing_annotations(input_data.model_dump())
+        require_success(result, "Failed to analyze annotations")
+        return {
+            "status": "success",
+            "message": "Annotation analysis completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def check_drawing_compliance(
+        input_data: ComplianceCheckInput,
+    ) -> dict[str, Any]:
+        """Check drawing compliance with company standards.
+
+        Args:
+            input_data (ComplianceCheckInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await check_drawing_compliance(compliance_input)
+        """
+        """
+        Check drawing compliance against specified drafting standards.
+
+        This tool verifies compliance with ISO, ANSI, DIN, or other drafting standards.
+        """
+        require_capability(
+            adapter,
+            "check_drawing_compliance",
+            "Active adapter does not support check_drawing_compliance; "
+            f"no {input_data.standard} compliance check was performed.",
+        )
+        result = await adapter.check_drawing_compliance(input_data.model_dump())
+        require_success(result, "Compliance check failed")
+        return {
+            "status": "success",
+            "message": f"Standards compliance check completed for {input_data.standard}",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def analyze_drawing_views(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Analyze drawing views arrangement and quality.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await analyze_drawing_views(view_input)
+        """
+        """
+        Analyze drawing views for clarity, completeness, and optimal presentation.
+
+        This tool examines view selection, placement, and clarity.
+        """
+        if hasattr(adapter, "analyze_drawing_views"):
+            result = await adapter.analyze_drawing_views(input_data)
+            require_success(result, "Failed to analyze drawing views")
+            return {
+                "status": "success",
+                "message": "Drawing view analysis completed",
+                "data": result.data,
+                "execution_time": result.execution_time,
+            }
+
+        drawing_path = input_data.get("drawing_path", "")
+
+        raise UnsupportedOperationError(
+            "Active adapter does not support analyze_drawing_views; "
+            f"no analysis of {drawing_path} was performed."
+        )
+
+    @mcp.tool()
+    async def generate_drawing_report(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Generate comprehensive drawing analysis report.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await generate_drawing_report(report_input)
+        """
+        """
+        Generate a comprehensive quality report for a drawing.
+
+        This tool creates a detailed report combining all analysis results.
+        """
+        if hasattr(adapter, "generate_drawing_report"):
+            result = await adapter.generate_drawing_report(input_data)
+            require_success(result, "Failed to generate drawing report")
+            return {
+                "status": "success",
+                "message": "Drawing quality report generated successfully",
+                "data": result.data,
+                "execution_time": result.execution_time,
+            }
+
+        drawing_path = input_data.get("drawing_path", "")
+
+        raise UnsupportedOperationError(
+            "Active adapter does not support generate_drawing_report; "
+            f"no report for {drawing_path} was generated."
+        )
+
+    @mcp.tool()
+    async def compare_drawing_versions(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Compare different versions of drawing files.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await compare_drawing_versions(version_input)
+        """
+        """
+        Compare two drawing files on disk using real filesystem facts.
+
+        This tool cannot parse SLDDRW internals (no SolidWorks session is
+        opened), so it does not report geometric/dimension/annotation
+        differences. It reports what it can honestly determine from the
+        filesystem: whether each file exists, its size, modified time, and
+        whether the two files are byte-for-byte identical.
+        """
+        drawing_v1 = input_data.get("drawing_version_1", "")
+        drawing_v2 = input_data.get("drawing_version_2", "")
+
+        if not drawing_v1 or not drawing_v2:
+            raise InvalidInputError(
+                "compare_drawing_versions requires both "
+                "drawing_version_1 and drawing_version_2 paths."
+            )
+
+        file_1 = file_fact_snapshot(drawing_v1)
+        file_2 = file_fact_snapshot(drawing_v2)
+
+        missing = [
+            path
+            for path, snapshot in ((drawing_v1, file_1), (drawing_v2, file_2))
+            if snapshot is None
+        ]
+        if missing:
+            raise ToolOperationError(
+                "Cannot compare drawing versions; file(s) not found "
+                f"on disk: {', '.join(missing)}. No SolidWorks-level "
+                "diff was performed."
+            )
+
+        assert file_1 is not None
+        assert file_2 is not None
+        identical = file_1["sha256"] == file_2["sha256"]
+
+        return {
+            "status": "success",
+            "message": (
+                "Drawing files are byte-identical"
+                if identical
+                else "Drawing files differ on disk"
+            ),
+            "comparison": {
+                "file_1": file_1,
+                "file_2": file_2,
+                "identical": identical,
+                "size_delta_bytes": file_2["size_bytes"] - file_1["size_bytes"],
+            },
+            "note": (
+                "This is a filesystem-level comparison only; no "
+                "SolidWorks session was opened, so geometric, "
+                "dimension, and annotation differences were not "
+                "analyzed."
+            ),
+        }
+
+    @mcp.tool()
+    async def validate_drawing_completeness(
+        input_data: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Validate drawing completeness for production readiness.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            >>> result = await validate_drawing_completeness(validation_input)
+        """
+        """
+        Validate that a drawing contains all necessary information for manufacturing.
+
+        This tool checks for completeness from a manufacturing perspective.
+        """
+        drawing_path = input_data.get("drawing_path", "")
+
+        require_capability(
+            adapter,
+            "validate_drawing_completeness",
+            "Active adapter does not support "
+            "validate_drawing_completeness; no validation of "
+            f"{drawing_path} was performed.",
+        )
+        result = await adapter.validate_drawing_completeness(input_data)
+        require_success(result, "Failed to validate completeness")
+        return {
+            "status": "success",
+            "message": "Drawing completeness validation completed",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    tool_count = 8  # Legacy count expected by tests
+    return tool_count