solidworks_mcp.progress.generate¶

solidworks_mcp.progress.generate ¶

Regenerate the progress image, its data and the docs page's tables.

Run from the repository root after adding a tool, changing a level or calling new COM methods in an adapter::

python -m solidworks_mcp.progress.generate

It writes, under docs/assets/progress/:

progress.svg: the README image;
progress.json: every tool's family, level and summary, and the coverage of each core interface;
tables.html: the docs page's HTML tables, readable without scripts.

tests/integration/test_progress_up_to_date.py fails when any of them is out of date.

Attributes¶

OUTPUTS `module-attribute` ¶

OUTPUTS = ('progress.svg', 'progress.json', 'tables.html')

OUTPUT_DIR `module-attribute` ¶

OUTPUT_DIR = Path('docs/assets/progress')

SNAPSHOT_PATH `module-attribute` ¶

SNAPSHOT_PATH = Path('docs/assets/progress/com_snapshot.json')

SUPPORT_LEVELS `module-attribute` ¶

SUPPORT_LEVELS: dict[str, Support] = {'analyze_geometry': _PLANNED, 'calculate_mass_properties': _STABLE, 'check_interference': _STABLE, 'get_mass_properties': _STABLE, 'get_material_properties': _PLANNED, 'verify_model': _STABLE, 'automation_start_macro_recording': _PLANNED, 'automation_stop_macro_recording': _PLANNED, 'batch_process_files': _PLANNED, 'create_template': _PLANNED, 'execute_workflow': _PLANNED, 'generate_vba_code': _STABLE, 'manage_design_table': _PLANNED, 'optimize_performance': _PLANNED, 'discover_solidworks_docs': _STABLE, 'find_related_api_members': _STABLE, 'lookup_api_interface': _STABLE, 'lookup_api_method': _STABLE, 'search_solidworks_api_help': _STABLE, 'add_annotation': _PLANNED, 'add_dimension': _PLANNED, 'add_drawing_view': _STABLE, 'add_note': _STABLE, 'auto_center_marks': _STABLE, 'auto_dimension_view': _PLANNED, 'check_drawing_standards': _PLANNED, 'create_detail_view': _PLANNED, 'create_drawing_view': _STABLE, 'create_section_view': _PLANNED, 'create_technical_drawing': _STABLE, 'list_drawing_views': _STABLE, 'update_sheet_format': _PLANNED, 'update_title_block': _PLANNED, 'analyze_drawing_annotations': _PLANNED, 'analyze_drawing_comprehensive': _PLANNED, 'analyze_drawing_dimensions': _PLANNED, 'analyze_drawing_views': _PLANNED, 'check_drawing_compliance': _PLANNED, 'compare_drawing_versions': _STABLE, 'generate_drawing_report': _PLANNED, 'validate_drawing_completeness': _PLANNED, 'add_datum_tag': _STABLE, 'add_gtol': _STABLE, 'arrange_dimensions': _STABLE, 'generate_drawing_package': _STABLE, 'insert_bom_table': _STABLE, 'insert_model_dimensions': _STABLE, 'set_sheet_scale': _STABLE, 'export_flat_pattern': _STABLE, 'get_custom_properties': _STABLE, 'get_material': _STABLE, 'list_available_materials': _STABLE, 'list_model_dimensions': _STABLE, 'measure_entities': _STABLE, 'set_custom_property': _STABLE, 'set_material': _STABLE, 'batch_export': _PLANNED, 'export_dwg': _STABLE, 'export_iges': _STABLE, 'export_image': _STABLE, 'export_pdf': _STABLE, 'export_step': _STABLE, 'export_stl': _STABLE, 'activate_document': _STABLE, 'batch_file_operations': _PLANNED, 'classify_feature_tree': _STABLE, 'convert_file_format': _PLANNED, 'get_file_properties': _STABLE, 'get_model_info': _STABLE, 'get_selected_entities': _STABLE, 'list_configurations': _STABLE, 'list_features': _STABLE, 'list_open_documents': _STABLE, 'load_assembly': _STABLE, 'load_part': _STABLE, 'manage_file_properties': _PLANNED, 'pack_and_go_assembly': _STABLE, 'save_as': _STABLE, 'save_assembly': _STABLE, 'save_body_as_part': _STABLE, 'save_file': _STABLE, 'save_part': _STABLE, 'analyze_macro': _PLANNED, 'batch_execute_macros': _PLANNED, 'create_macro_library': _PLANNED, 'execute_macro': _STABLE, 'optimize_macro': _PLANNED, 'start_macro_recording': _PLANNED, 'stop_macro_recording': _PLANNED, 'add_chamfer': _STABLE, 'add_fillet': _STABLE, 'add_mate': _STABLE, 'close_model': _STABLE, 'create_assembly': _STABLE, 'create_axis': _STABLE, 'create_cut_extrude': _STABLE, 'create_drawing': _STABLE, 'create_extrusion': _STABLE, 'create_loft': _STABLE, 'create_part': _STABLE, 'create_reference_plane': _STABLE, 'create_reference_point': _STABLE, 'create_revolve': _STABLE, 'create_sweep': _STABLE, 'delete_feature': _STABLE, 'get_dimension': _STABLE, 'insert_component': _STABLE, 'list_components': _STABLE, 'mirror_feature': _STABLE, 'open_model': _STABLE, 'pattern_circular': _STABLE, 'rebuild_model': _STABLE, 'rename_feature': _STABLE, 'select_face_edges': _STABLE, 'select_feature': _STABLE, 'set_component_state': _STABLE, 'set_dimension': _STABLE, 'set_units': _STABLE, 'suppress_feature': _STABLE, 'undo': _STABLE, 'reset_circuit_breaker': _STABLE, 'add_arc': _STABLE, 'add_centerline': _STABLE, 'add_circle': _STABLE, 'add_ellipse': _STABLE, 'add_line': _STABLE, 'add_polygon': _STABLE, 'add_rectangle': _STABLE, 'add_sketch_constraint': _STABLE, 'add_sketch_dimension': _STABLE, 'add_spline': _STABLE, 'check_sketch_fully_defined': _STABLE, 'create_sketch': _STABLE, 'exit_sketch': _STABLE, 'sketch_circular_pattern': _STABLE, 'sketch_linear_pattern': _STABLE, 'sketch_mirror': _STABLE, 'sketch_offset': _STABLE, 'sketch_tutorial_simple_hole': _STABLE, 'tutorial_simple_hole': _PLANNED, 'apply_template': _PLANNED, 'batch_apply_template': _PLANNED, 'compare_templates': _STABLE, 'extract_template': _PLANNED, 'list_template_library': _PLANNED, 'save_to_template_library': _PLANNED, 'generate_vba_assembly_insert': _STABLE, 'generate_vba_assembly_mates': _STABLE, 'generate_vba_batch_export': _STABLE, 'generate_vba_drawing_dimensions': _STABLE, 'generate_vba_drawing_views': _STABLE, 'generate_vba_extrusion': _STABLE, 'generate_vba_file_operations': _STABLE, 'generate_vba_macro_recorder': _STABLE, 'generate_vba_part_modeling': _STABLE, 'generate_vba_revolve': _STABLE}

_WRAP_CLOSE `module-attribute` ¶

_WRAP_CLOSE = '</div></div>'

_WRAP_OPEN `module-attribute` ¶

_WRAP_OPEN = '<div class="md-typeset__scrollwrap"><div class="md-typeset__table">'

Classes¶

ComCoverage `dataclass` ¶

ComCoverage(interfaces: tuple[InterfaceCoverage, ...], api_covered: int, api_total: int, type_library: str)

Coverage of the core interfaces and of the whole API.

Attributes:

Name	Type	Description
`interfaces`	`tuple[InterfaceCoverage, ...]`	One entry per core interface, in `CORE_INTERFACES` order.
`api_covered`	`int`	Distinct method names called, across the whole API.
`api_total`	`int`	Distinct method names in the whole API.
`type_library`	`str`	The snapshot's source, which carries its version.

Attributes¶

core_covered `property` ¶

core_covered: int

Called methods summed over the core interfaces.

core_total `property` ¶

core_total: int

Methods summed over the core interfaces.

MockSolidWorksAdapter ¶

MockSolidWorksAdapter(config: object | None = None)

Bases: SolidWorksAdapter

Mock adapter that simulates SolidWorks operations.

Parameters:

Name	Type	Description	Default
`config`	`object \| None`	Configuration values for the operation. Defaults to None.	`None`

Attributes:

Name	Type	Description
`_connected`	`Any`	The connected value.
`_delays`	`Any`	The delays value.
`_is_connected_proxy`	`Any`	The is connected proxy value.
`_operation_count`	`Any`	The operation count value.
`_simulate_errors`	`Any`	The simulate errors value.

Initialize the mock solid works adapter.

Parameters:

Name	Type	Description	Default
`config`	`object \| None`	Configuration values for the operation. Defaults to None.	`None`

Returns:

Name	Type	Description
`None`	`None`	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __init__(self, config: object | None = None) -> None:
    """Initialize the mock solid works adapter.

    Args:
        config (object | None): Configuration values for the operation. Defaults to None.

    Returns:
        None: None.
    """
    super().__init__(config)
    cfg: dict[str, Any] = dict(self.config_dict)
    self._connected = False
    self._current_model = None
    self._models: dict[str, SolidWorksModel] = {}
    self._features: dict[str, SolidWorksFeature] = {}
    # Names suppressed via suppress_feature. Kept beside _features rather
    # than on SolidWorksFeature, which has no suppression field.
    self._suppressed_features: set[str] = set()
    # Component tree for an Assembly-type current model, keyed by
    # component name. See ``_flatten_assembly_components`` for shape.
    # Empty means "use the canned default fixture" (see list_features).
    self._assembly_components: dict[str, dict[str, Any]] = {}
    self._sketches: dict[str, str] = {}
    self._current_sketch: str | None = None
    # Names currently "selected" via select_feature / select_face_edges,
    # so append and selection_count behave like the real selection set.
    self._selection: list[str] = []
    # Test hook: RawRebuildIssue objects rebuild_model should report, so
    # the error/warning paths can be exercised without real geometry.
    self.injected_rebuild_issues: list[Any] = []
    # Tracks IDs returned by add_line/add_arc/add_circle/add_centerline/
    # add_rectangle/add_spline so add_sketch_constraint can validate
    # entity1/entity2 the same way the real adapter validates against
    # its sketch-entity registry.
    self._sketch_entity_ids: set[str] = set()
    self._dimensions: dict[str, float] = {}
    # Assembly components inserted via insert_component, keyed by
    # insertion order. See insert_component/list_components/add_mate.
    self._components: list[str] = []
    # Mates added via add_mate, in order, so the geometry summary can
    # report a mate count without real geometry.
    self._mates: list[dict[str, Any]] = []
    self._component_states: dict[str, dict[str, bool]] = {}
    # Drawing views placed via create_drawing_view / add_drawing_view /
    # create_technical_drawing, in sheet order. See list_drawing_views.
    self._drawing_views: list[str] = []
    # Reference planes created via create_reference_plane, in creation
    # order, used to invent sequential "PlaneN" names. Shared feature
    # tree counter with create_axis mirrors the live adapter's
    # features_before/features_after pair (see _feature_count in
    # solidworks/features.py).
    self._reference_planes: list[str] = []
    # Axes created via create_axis, in creation order, used to invent
    # sequential "AxisN" names the same way self._reference_planes
    # invents "PlaneN" names, and to validate the axis name passed to
    # pattern_circular the same way known_sources validates mirror
    # sources.
    self._axes: list[str] = []
    # Reference points created via create_reference_point, in creation
    # order, invented "PointN" names on the same pattern as _axes.
    self._reference_points: list[str] = []
    # Centre-mark count per drawing-view name, grown by auto_center_marks.
    self._center_marks: dict[str, int] = {}
    self._feature_tree_count = 0
    # Volume tracked for mirror_feature, in mm^3. Seeded at the
    # live-measured 1819569.1 mm^3 wing volume from
    # _mirror_feature_impl in solidworks/features.py, then doubled on
    # each successful mirror so volume_before/volume_after/volume_ratio
    # stay self-consistent without a real geometry engine.
    self._mirror_volume: float = 1819569.1
    # Volume tracked for pattern_circular, in mm^3. Seeded at the
    # live-measured 48431.5 mm^3 hub+blade volume from
    # _pattern_circular_impl in solidworks/features.py, then grown by
    # _PATTERN_BLADE_VOLUME per extra instance on each successful
    # pattern so volume_before/volume_after/volume_ratio stay
    # self-consistent without a real geometry engine.
    self._pattern_volume: float = 48431.5
    self._operation_count = 0

    # Configurable simulation delays (in seconds)
    self._delays = {
        "connect": cfg.get("mock_connect_delay", 0.1),
        "model_operation": cfg.get("mock_model_delay", 0.02),
        "feature_operation": cfg.get("mock_feature_delay", 0.03) if cfg else 0.03,
        "sketch_operation": cfg.get("mock_sketch_delay", 0.1),
    }
    self._is_connected_proxy = _BoolCallable(lambda: self._connected)
    self._simulate_errors = bool(cfg.get("simulate_errors", False))

Methods:¶

getattribute ¶

__getattribute__(name: str) -> Any

Build internal getattribute.

Parameters:

Name	Type	Description	Default
`name`	`str`	The name value.	required

Returns:

Name	Type	Description
`Any`	`Any`	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __getattribute__(self, name: str) -> Any:
    """Build internal getattribute.

    Args:
        name (str): The name value.

    Returns:
        Any: The result produced by the operation.
    """
    if name == "is_connected":
        return object.__getattribute__(self, "_is_connected_proxy")
    return object.__getattribute__(self, name)

activate_document `async` ¶

activate_document(title_or_path: str) -> AdapterResult[dict[str, Any]]

Mock making an already-open document active.

Parameters:

Name	Type	Description	Default
`title_or_path`	`str`	Title, full path, or file name of an open document.	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def activate_document(
    self, title_or_path: str
) -> AdapterResult[dict[str, Any]]:
    """Mock making an already-open document active.

    Args:
        title_or_path (str): Title, full path, or file name of an open
            document.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(0.05)
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )
    target = (title_or_path or "").strip()
    if not target:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="title_or_path is required"
        )

    needle = target.lower()
    match = None
    for model in self._models.values():
        names = {
            model.name.lower(),
            model.path.lower(),
            model.path.rsplit("/", 1)[-1].lower(),
        }
        if needle in names:
            match = model
            break
    if match is None:
        open_titles = ", ".join(m.name for m in self._models.values()) or "none"
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"No open document matches {target!r}. Open: {open_titles}",
        )

    self._current_model = match
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"activated": match.name, "verified": True},
        execution_time=0.05,
    )

add_arc `async` ¶

add_arc(center_x: float, center_y: float, start_x: float, start_y: float, end_x: float, end_y: float) -> AdapterResult[str]

Mock adding a circular arc to sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	Arc centre X.	required
`center_y`	`float`	Arc centre Y.	required
`start_x`	`float`	Arc start point X.	required
`start_y`	`float`	Arc start point Y.	required
`end_x`	`float`	Arc end point X.	required
`end_y`	`float`	Arc end point Y.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_arc(
    self,
    center_x: float,
    center_y: float,
    start_x: float,
    start_y: float,
    end_x: float,
    end_y: float,
) -> AdapterResult[str]:
    """Mock adding a circular arc to sketch.

    Args:
        center_x (float): Arc centre X.
        center_y (float): Arc centre Y.
        start_x (float): Arc start point X.
        start_y (float): Arc start point Y.
        end_x (float): Arc end point X.
        end_y (float): Arc end point Y.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    arc_id = f"Arc_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(arc_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=arc_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_centerline `async` ¶

add_centerline(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Mock adding a construction centerline to sketch.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_centerline(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a construction centerline to sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    centerline_id = f"Centerline_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(centerline_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=centerline_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_chamfer `async` ¶

add_chamfer(distance: float, edge_names: list[str], angle: float = 45.0, flip: bool = False) -> AdapterResult[SolidWorksFeature]

Mock angle-distance chamfer (see :meth:_mock_edge_feature).

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_chamfer(
    self,
    distance: float,
    edge_names: list[str],
    angle: float = 45.0,
    flip: bool = False,
) -> AdapterResult[SolidWorksFeature]:
    """Mock angle-distance chamfer (see :meth:`_mock_edge_feature`)."""
    result = await self._mock_edge_feature("Chamfer", distance, edge_names)
    if result.is_success:
        result.data.parameters.update({"angle": angle, "flip": flip})
    return result

add_circle `async` ¶

add_circle(center_x: float, center_y: float, radius: float) -> AdapterResult[str]

Mock adding a circle to sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	The center x value.	required
`center_y`	`float`	The center y value.	required
`radius`	`float`	The radius value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_circle(
    self, center_x: float, center_y: float, radius: float
) -> AdapterResult[str]:
    """Mock adding a circle to sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    circle_id = f"Circle{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(circle_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=circle_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_datum_tag `async` ¶

add_datum_tag(label: str, attach_at_mm: tuple[float, float], x_mm: float, y_mm: float) -> AdapterResult[dict[str, Any]]

Mock adding a datum tag; refuses what the real one refuses.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_datum_tag(
    self,
    label: str,
    attach_at_mm: tuple[float, float],
    x_mm: float,
    y_mm: float,
) -> AdapterResult[dict[str, Any]]:
    """Mock adding a datum tag; refuses what the real one refuses."""
    guard = self._mock_doc_error({"Drawing"}, "add_datum_tag")
    if guard is not None:
        return guard
    letter = label.strip().upper()
    if len(letter) != 1 or not letter.isalpha():
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="label must be a single letter, e.g. 'A'",
        )
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"label": letter, "position_mm": [x_mm, y_mm]},
    )

add_drawing_view `async` ¶

add_drawing_view(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock adding a view of a model to the active drawing sheet.

Parameters:

Name	Type	Description	Default
`payload`	`Any`	Tool payload carrying the model path and orientation.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_drawing_view(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock adding a view of a model to the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the model path and orientation.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    return self._mock_place_view(payload)

add_ellipse `async` ¶

add_ellipse(center_x: float, center_y: float, major_axis: float, minor_axis: float) -> AdapterResult[str]

Mock adding an axis-aligned ellipse to sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	Ellipse centre X in millimetres.	required
`center_y`	`float`	Ellipse centre Y in millimetres.	required
`major_axis`	`float`	Full major-axis length in millimetres.	required
`minor_axis`	`float`	Full minor-axis length in millimetres.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_ellipse(
    self,
    center_x: float,
    center_y: float,
    major_axis: float,
    minor_axis: float,
) -> AdapterResult[str]:
    """Mock adding an axis-aligned ellipse to sketch.

    Args:
        center_x (float): Ellipse centre X in millimetres.
        center_y (float): Ellipse centre Y in millimetres.
        major_axis (float): Full major-axis length in millimetres.
        minor_axis (float): Full minor-axis length in millimetres.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    ellipse_id = f"Ellipse_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(ellipse_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=ellipse_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_fillet `async` ¶

add_fillet(radius: float, edge_names: list[str]) -> AdapterResult[SolidWorksFeature]

Mock constant-radius fillet (see :meth:_mock_edge_feature).

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_fillet(
    self, radius: float, edge_names: list[str]
) -> AdapterResult[SolidWorksFeature]:
    """Mock constant-radius fillet (see :meth:`_mock_edge_feature`)."""
    return await self._mock_edge_feature("Fillet", radius, edge_names)

add_gtol `async` ¶

add_gtol(characteristic: str, tolerance: float, x_mm: float, y_mm: float, diameter_zone: bool = False, material_condition: str = 'none', datums: list[str] | None = None, attach_at_mm: tuple[float, float] | None = None, dimension: tuple[str, str] | None = None) -> AdapterResult[dict[str, Any]]

Mock adding a feature control frame; refuses what the real one refuses.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_gtol(
    self,
    characteristic: str,
    tolerance: float,
    x_mm: float,
    y_mm: float,
    diameter_zone: bool = False,
    material_condition: str = "none",
    datums: list[str] | None = None,
    attach_at_mm: tuple[float, float] | None = None,
    dimension: tuple[str, str] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock adding a feature control frame; refuses what the real one refuses."""
    guard = self._mock_doc_error({"Drawing"}, "add_gtol")
    if guard is not None:
        return guard
    problem = gtol_problem(characteristic, tolerance, material_condition, datums)
    if problem is not None:
        return AdapterResult(status=AdapterResultStatus.ERROR, error=problem)
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "characteristic": characteristic,
            "tolerance": f"{tolerance:g}",
            "diameter_zone": diameter_zone,
            "material_condition": material_condition,
            "datums": [d.strip().upper() for d in datums or []],
            "attached": (
                dimension[1] if dimension is not None else attach_at_mm is not None
            ),
            "position_mm": None if dimension is not None else [x_mm, y_mm],
            "layout": None,
        },
    )

add_line `async` ¶

add_line(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Mock adding a line to sketch.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a line to sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    line_id = f"Line{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(line_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=line_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_mate `async` ¶

add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0, face_a: list[float] | None = None, face_b: list[float] | None = None) -> AdapterResult[dict[str, Any]]

Mock mating two components in the active assembly.

Parameters:

Name	Type	Description	Default
`component_a`	`str`	First component instance name.	required
`component_b`	`str`	Second component instance name.	required
`entity_a`	`str`	Named feature on the first component. Defaults to "Front Plane".	`'Front Plane'`
`entity_b`	`str`	Named feature on the second component. Defaults to "Front Plane".	`'Front Plane'`
`mate_type`	`str`	Mate type. Defaults to "coincident".	`'coincident'`
`alignment`	`str`	Mate alignment. Defaults to "aligned".	`'aligned'`
`distance`	`float`	Distance in millimetres, for a distance mate. Defaults to 0.0.	`0.0`
`angle`	`float`	Angle in degrees, for an angle mate. Defaults to 0.0.	`0.0`
`face_a`	`list[float] \| None`	A point on a face of the first component (part coordinates, mm), used instead of entity_a.	`None`
`face_b`	`list[float] \| None`	The same for the second component.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
    face_a: list[float] | None = None,
    face_b: list[float] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock mating two components in the active assembly.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type. Defaults to "coincident".
        alignment (str): Mate alignment. Defaults to "aligned".
        distance (float): Distance in millimetres, for a distance mate.
            Defaults to 0.0.
        angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.
        face_a (list[float] | None): A point on a face of the first
            component (part coordinates, mm), used instead of entity_a.
        face_b (list[float] | None): The same for the second component.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    from .solidworks.face_selection import mate_entity_label

    known_mate_types = {
        "coincident",
        "concentric",
        "perpendicular",
        "parallel",
        "tangent",
        "distance",
        "angle",
    }
    if mate_type not in known_mate_types:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown mate type '{mate_type}'. "
                f"Use one of: {', '.join(sorted(known_mate_types))}."
            ),
        )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1
    self._mates.append(
        {"mate_type": mate_type, "components": [component_a, component_b]}
    )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "mate_type": mate_type,
            "alignment": alignment,
            "components": [component_a, component_b],
            "entities": [
                mate_entity_label(entity_a, face_a),
                mate_entity_label(entity_b, face_b),
            ],
            "distance": distance or None,
            "angle": angle or None,
            # The real adapter fills these by comparing every component's
            # Transform2 before and after the mate. The mock has no
            # geometry to move, so it reports "not determinable" rather
            # than True: this field exists precisely so a caller can tell
            # a mate that positioned something from one SolidWorks
            # accepted and ignored, and a mock that always answers True
            # would make that check useless wherever mock mode is used.
            "moved_components": [],
            "geometry_moved": None,
        },
        execution_time=self._delays["model_operation"],
    )

add_note `async` ¶

add_note(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock placing a text note on the active drawing sheet.

Parameters:

Name	Type	Description	Default
`payload`	`Any`	Tool payload carrying the text and position.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_note(self, payload: Any = None) -> AdapterResult[dict[str, Any]]:
    """Mock placing a text note on the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the text and position.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    data = payload if isinstance(payload, dict) else {}
    text = data.get("text")
    if not text:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="add_note requires text"
        )

    self._operation_count += 1
    font_points = float(data.get("font_size") or 0.0)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "text": text,
            "position": {
                "x": float(data.get("position_x", 100.0)),
                "y": float(data.get("position_y", 50.0)),
            },
            # The real adapter sets this from IAnnotation::SetPosition's
            # return. Mock mode has no sheet to place anything on, so it
            # reports "not determinable" rather than claiming success at a
            # check it never performed.
            "positioned": None,
            "font_size_points": font_points or None,
        },
        execution_time=self._delays["model_operation"],
    )

add_polygon `async` ¶

add_polygon(center_x: float, center_y: float, radius: float, sides: int) -> AdapterResult[str]

Mock adding a regular polygon to sketch.

Parameters:

Name	Type	Description	Default
`center_x`	`float`	Polygon centre X in millimetres.	required
`center_y`	`float`	Polygon centre Y in millimetres.	required
`radius`	`float`	Circumradius in millimetres (distance from centre to each vertex; matches the real adapter's `CreatePolygon(..., Inscribed=True)` semantics).	required
`sides`	`int`	Number of polygon sides.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_polygon(
    self, center_x: float, center_y: float, radius: float, sides: int
) -> AdapterResult[str]:
    """Mock adding a regular polygon to sketch.

    Args:
        center_x (float): Polygon centre X in millimetres.
        center_y (float): Polygon centre Y in millimetres.
        radius (float): Circumradius in millimetres (distance from centre
            to each vertex; matches the real adapter's
            ``CreatePolygon(..., Inscribed=True)`` semantics).
        sides (int): Number of polygon sides.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    # ID format mirrors the real PyWin32 adapter, which uses
    # ``_register_sketch_entity("Polygon", ...)`` (counter-based) so the
    # returned ID is a valid input to downstream sketch_linear_pattern /
    # sketch_circular_pattern / sketch_mirror / sketch_offset calls.
    polygon_id = f"Polygon_{len(self._sketch_entity_ids) + 1}"
    self._sketch_entity_ids.add(polygon_id)
    _ = sides  # informational only; the sides count is no longer part of the ID

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=polygon_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_rectangle `async` ¶

add_rectangle(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Mock adding a rectangle to sketch.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_rectangle(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a rectangle to sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"])
    self._operation_count += 1

    rect_id = f"Rectangle{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(rect_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=rect_id,
        execution_time=self._delays["sketch_operation"],
    )

add_sketch_constraint `async` ¶

add_sketch_constraint(entity1: str, entity2: str | None, relation_type: str, entity3: str | None = None) -> AdapterResult[str]

Mock adding a geometric constraint between sketch entities.

Parameters:

Name	Type	Description	Default
`entity1`	`str`	Primary sketch-entity ID.	required
`entity2`	`str \| None`	Secondary sketch-entity ID, or None for single-entity relations (horizontal, vertical, fix).	required
`relation_type`	`str`	Constraint name (see RELATION_NAME_MAP).	required
`entity3`	`str \| None`	Third entity ID — only used by the `symmetric` relation (the centerline of symmetry). All other relation types reject a non-null `entity3`.	`None`

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: SUCCESS with a placeholder constraint ID, or ERROR if no active sketch, the relation_type is unsupported, arity is wrong, or an entity ID is unknown.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_sketch_constraint(
    self,
    entity1: str,
    entity2: str | None,
    relation_type: str,
    entity3: str | None = None,
) -> AdapterResult[str]:
    """Mock adding a geometric constraint between sketch entities.

    Args:
        entity1 (str): Primary sketch-entity ID.
        entity2 (str | None): Secondary sketch-entity ID, or None for
            single-entity relations (horizontal, vertical, fix).
        relation_type (str): Constraint name (see RELATION_NAME_MAP).
        entity3 (str | None): Third entity ID — only used by the
            ``symmetric`` relation (the centerline of symmetry). All
            other relation types reject a non-null ``entity3``.

    Returns:
        AdapterResult[str]: SUCCESS with a placeholder constraint ID, or
            ERROR if no active sketch, the relation_type is unsupported,
            arity is wrong, or an entity ID is unknown.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    rt_norm = (relation_type or "").strip().lower()
    if rt_norm not in RELATION_NAME_MAP:
        supported = ", ".join(sorted(RELATION_NAME_MAP))
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unsupported relation type '{relation_type}'. "
                f"Supported: {supported}"
            ),
        )

    # Arity validation — mirror the real adapter
    if rt_norm == "symmetric":
        if entity2 is None or entity3 is None:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Relation '{relation_type}' requires entity1, "
                    "entity2, and entity3 (the centerline of symmetry)"
                ),
            )
    elif entity3 is not None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Relation '{relation_type}' does not accept entity3 — "
                "only 'symmetric' takes a third entity (the centerline)"
            ),
        )

    # Validate entity IDs against the in-process sketch-entity registry
    # so the mock surfaces the same "Unknown sketch entity" error as the
    # real adapter (which checks adapter._sketch_entities).
    for ent in (entity1, entity2, entity3):
        if ent is not None and ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    constraint_id = f"Constraint_{relation_type}_{random.randint(1000, 9999)}"

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=constraint_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_sketch_line `async` ¶

add_sketch_line(x1: float, y1: float, x2: float, y2: float, construction: bool = False) -> AdapterResult[dict[str, Any]]

Legacy compatibility wrapper around add_line.

Parameters:

Name	Type	Description	Default
`x1`	`float`	The x1 value.	required
`y1`	`float`	The y1 value.	required
`x2`	`float`	The x2 value.	required
`y2`	`float`	The y2 value.	required
`construction`	`bool`	The construction value. Defaults to False.	`False`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_sketch_line(
    self,
    x1: float,
    y1: float,
    x2: float,
    y2: float,
    construction: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Legacy compatibility wrapper around add_line.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.
        construction (bool): The construction value. Defaults to False.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    result = await self.add_line(x1, y1, x2, y2)
    if not result.is_success:
        return AdapterResult(
            status=result.status,
            error=result.error,
            execution_time=result.execution_time,
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "id": result.data,
            "start": {"x": x1, "y": y1},
            "end": {"x": x2, "y": y2},
            "construction": construction,
        },
        execution_time=result.execution_time,
    )

add_spline `async` ¶

add_spline(points: list[dict[str, float]]) -> AdapterResult[str]

Mock adding a NURBS spline through the supplied points.

Parameters:

Name	Type	Description	Default
`points`	`list[dict[str, float]]`	Ordered control points with `"x"` / `"y"` keys. Minimum 2 points.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
    """Mock adding a NURBS spline through the supplied points.

    Args:
        points (list[dict[str, float]]): Ordered control points with
            ``"x"`` / ``"y"`` keys. Minimum 2 points.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if len(points) < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="add_spline requires at least 2 points",
        )
    # Match the real adapter's point contract: each dict must carry
    # both ``x`` and ``y`` keys, or the live impl raises KeyError on
    # ``point["x"]``. Validating here keeps mock/live parity so tests
    # that pass against the mock won't fail live on malformed input.
    for index, point in enumerate(points):
        if not isinstance(point, dict) or "x" not in point or "y" not in point:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"add_spline point at index {index} is missing "
                    "required 'x' and/or 'y' keys"
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    spline_id = f"Spline_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(spline_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=spline_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

arrange_dimensions `async` ¶

arrange_dimensions(view_name: str | None = None) -> AdapterResult[dict[str, Any]]

Mock arranging drawing dimensions: reports a clean layout.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def arrange_dimensions(
    self, view_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock arranging drawing dimensions: reports a clean layout."""
    guard = self._mock_doc_error({"Drawing"}, "arrange_dimensions")
    if guard is not None:
        return guard
    if view_name and view_name not in self._drawing_views:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {view_name!r}. Views: "
                f"{', '.join(self._drawing_views) or 'none'}"
            ),
        )
    counts = getattr(self, "_view_dimensions", {})
    total = sum(n for v, n in counts.items() if not view_name or v == view_name)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "dimensions": total,
            "moved": total,
            "unplaced": [],
            "overlaps_before": total,
            "overlaps_after": 0,
            "remaining_overlaps": [],
            "sheet_size_m": [0.42, 0.297],
        },
    )

auto_center_marks `async` ¶

auto_center_marks(view_name: str, mark_holes: bool = True, mark_fillets: bool = False, mark_slots: bool = True) -> AdapterResult[dict[str, Any]]

Mock auto-inserting centre marks on a drawing view.

The mock has no geometry, so it cannot know how many circular features a view holds - it mirrors the live adapter's refusals (not a drawing, no feature type selected, unknown view) and, on a valid request, records a nominal centre-mark increase per view so before/after deltas stay monotonic across calls.

Parameters:

Name	Type	Description	Default
`view_name`	`str`	Name of a view on the active drawing.	required
`mark_holes`	`bool`	Mark holes / bores.	`True`
`mark_fillets`	`bool`	Mark fillets.	`False`
`mark_slots`	`bool`	Mark slots.	`True`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The view, the feature types acted
`AdapterResult[dict[str, Any]]`	on, and before/after centre-mark counts, or an error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def auto_center_marks(
    self,
    view_name: str,
    mark_holes: bool = True,
    mark_fillets: bool = False,
    mark_slots: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mock auto-inserting centre marks on a drawing view.

    The mock has no geometry, so it cannot know how many circular
    features a view holds - it mirrors the live adapter's refusals (not
    a drawing, no feature type selected, unknown view) and, on a valid
    request, records a nominal centre-mark increase per view so
    before/after deltas stay monotonic across calls.

    Args:
        view_name (str): Name of a view on the active drawing.
        mark_holes (bool): Mark holes / bores.
        mark_fillets (bool): Mark fillets.
        mark_slots (bool): Mark slots.

    Returns:
        AdapterResult[dict[str, Any]]: The view, the feature types acted
        on, and before/after centre-mark counts, or an error.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)

    model = self._current_model
    if model is None or getattr(model, "type", None) != "Drawing":
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="auto_center_marks requires an active drawing document",
        )
    if not (mark_holes or mark_fillets or mark_slots):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "Select at least one feature type: mark_holes, "
                "mark_fillets or mark_slots."
            ),
        )
    if view_name not in self._drawing_views:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {view_name!r} on the active drawing. "
                f"Views: {', '.join(self._drawing_views) or 'none'}"
            ),
        )

    self._operation_count += 1
    before = self._center_marks.get(view_name, 0)
    # Nominal: two marks per selected feature type, added once.
    added = 0 if before else 2 * sum((mark_holes, mark_fillets, mark_slots))
    after = before + added
    self._center_marks[view_name] = after

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "view": view_name,
            "feature_types": [
                label
                for label, on in (
                    ("holes", mark_holes),
                    ("fillets", mark_fillets),
                    ("slots", mark_slots),
                )
                if on
            ],
            "center_marks_before": before,
            "center_marks_after": after,
            "center_marks_added": added,
        },
        execution_time=self._delays["model_operation"] / 2,
    )

check_interference `async` ¶

check_interference(params: Any = None) -> AdapterResult[dict[str, Any]]

Mock checking the active assembly for interfering components.

Parameters:

Name	Type	Description	Default
`params`	`Any`	Optional settings; `coincident`, `components`.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def check_interference(
    self, params: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock checking the active assembly for interfering components.

    Args:
        params (Any): Optional settings; ``coincident``, ``components``.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    options = params if isinstance(params, dict) else {}

    if len(self._components) < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "Interference detection needs at least two components; the "
                f"assembly has {len(self._components)}."
            ),
        )

    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            # The real adapter gets this from SolidWorks' interference
            # engine. The mock has no geometry, so it cannot know whether
            # anything overlaps and says so rather than reporting a clean
            # assembly it never checked - a mock that always answered
            # False would make this tool useless wherever mock mode runs.
            "interference_found": None,
            "interference_count": None,
            "interferences": [],
            "coincident_treated_as_interference": bool(
                options.get("coincident", False)
            ),
            "scope": "whole assembly",
            "tolerance_applied": None,
        },
        execution_time=self._delays["model_operation"],
    )

check_sketch_fully_defined `async` ¶

check_sketch_fully_defined(sketch_name: str | None = None) -> AdapterResult[dict[str, Any]]

Mock check for sketch definition status.

Parameters:

Name	Type	Description	Default
`sketch_name`	`str \| None`	Optional sketch name to inspect. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: Definition status payload.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def check_sketch_fully_defined(
    self, sketch_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock check for sketch definition status.

    Args:
        sketch_name (str | None): Optional sketch name to inspect. Defaults to None.

    Returns:
        AdapterResult[dict[str, Any]]: Definition status payload.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 3)
    self._operation_count += 1

    resolved_name = sketch_name or self._current_sketch or "Sketch1"
    if sketch_name and sketch_name not in self._sketches:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Sketch not found: {sketch_name}",
        )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "sketch_name": resolved_name,
            "is_fully_defined": True,
            "definition_state": "fully_defined",
            "source": "mock",
            "raw_status": True,
        },
        execution_time=self._delays["sketch_operation"] / 3,
    )

close_model `async` ¶

close_model(save: bool = False) -> AdapterResult[None]

Mock closing the current model.

Parameters:

Name	Type	Description	Default
`save`	`bool`	The save value. Defaults to False.	`False`

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def close_model(self, save: bool = False) -> AdapterResult[None]:
    """Mock closing the current model.

    Args:
        save (bool): The save value. Defaults to False.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.WARNING, error="No active model to close"
        )

    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    if save:
        # Simulate save operation
        await asyncio.sleep(self._delays["model_operation"])

    self._current_model = None

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=None,
        execution_time=self._delays["model_operation"],
    )

connect `async` ¶

connect() -> None

Mock connection to SolidWorks.

Returns:

Name	Type	Description
`None`	`None`	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def connect(self) -> None:
    """Mock connection to SolidWorks.

    Returns:
        None: None.
    """
    await asyncio.sleep(self._delays["connect"])
    self._connected = True

    # Initialize some sample data
    self._dimensions = {
        "D1@Sketch1": 10.0,
        "D2@Sketch1": 20.0,
        "D1@Boss-Extrude1": 50.0,
    }

create_assembly `async` ¶

create_assembly(name: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Mock creating a new assembly.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name value. Defaults to None.	`None`
`template`	`str \| None`	Template file path. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_assembly(
    self, name: str | None = None, template: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new assembly.

    Args:
        name (str | None): The name value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    model_id = name or f"Assembly{len(self._models) + 1}"
    model = SolidWorksModel(
        path=f"Mock://{model_id}.sldasm",
        name=f"{model_id}",
        type="Assembly",
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "mock": True,
            "template": template,
        },
    )

    self._current_model = model
    self._models[model.path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

create_axis `async` ¶

create_axis(reference: str) -> AdapterResult[dict[str, Any]]

Mock creating a reference axis along a principal direction.

Mirrors the live adapter's plane-pair mapping (_AXIS_PLANE_PAIRS in solidworks/features.py, imported here directly so the two can never drift apart) and validation: only x/y/z (case-insensitive, leading ± stripped) are accepted.

Parameters:

Name	Type	Description	Default
`reference`	`str`	"x", "y" or "z" (case-insensitive; leading ± stripped).	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The plane pair used and the
`AdapterResult[dict[str, Any]]`	feature counter before/after, or error for an unknown reference.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_axis(self, reference: str) -> AdapterResult[dict[str, Any]]:
    """Mock creating a reference axis along a principal direction.

    Mirrors the live adapter's plane-pair mapping (``_AXIS_PLANE_PAIRS``
    in ``solidworks/features.py``, imported here directly so the two can
    never drift apart) and validation: only ``x``/``y``/``z``
    (case-insensitive, leading +/- stripped) are accepted.

    Args:
        reference (str): "x", "y" or "z" (case-insensitive; leading +/-
            stripped).

    Returns:
        AdapterResult[dict[str, Any]]: The plane pair used and the
        feature counter before/after, or error for an unknown reference.
    """
    key = str(reference or "").strip().lower().lstrip("+-")
    if key not in _AXIS_PLANE_PAIRS:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown axis reference '{reference}'. "
                f"Use one of: {', '.join(sorted(_AXIS_PLANE_PAIRS))}."
            ),
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    before = self._feature_tree_count
    self._feature_tree_count += 1
    after = self._feature_tree_count

    plane_a, plane_b = _AXIS_PLANE_PAIRS[key]

    # Invent a sequential "AxisN" name, tracked on self._axes, the same
    # way create_reference_plane invents "PlaneN" names on
    # self._reference_planes. The live adapter reads the new axis's name
    # from the end of the feature tree (InsertAxis2 returns only a bool).
    self._axes.append(f"Axis{len(self._axes) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": self._axes[-1],
            "reference": key,
            "planes": [plane_a, plane_b],
            "features_before": before,
            "features_after": after,
        },
        execution_time=self._delays["feature_operation"],
    )

create_drawing `async` ¶

create_drawing(name: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Mock creating a new drawing.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name value. Defaults to None.	`None`
`template`	`str \| None`	Template file path. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_drawing(
    self, name: str | None = None, template: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new drawing.

    Args:
        name (str | None): The name value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    model_id = name or f"Drawing{len(self._models) + 1}"
    model = SolidWorksModel(
        path=f"Mock://{model_id}.slddrw",
        name=f"{model_id}",
        type="Drawing",
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "mock": True,
            "template": template,
        },
    )

    self._current_model = model
    self._models[model.path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

create_drawing_view `async` ¶

create_drawing_view(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock placing a view of a model on the active drawing sheet.

Parameters:

Name	Type	Description	Default
`payload`	`Any`	Tool payload carrying the model path and orientation.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_drawing_view(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock placing a view of a model on the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the model path and orientation.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    return self._mock_place_view(payload)

create_extrusion `async` ¶

create_extrusion(params: ExtrusionParameters | str, depth: float | None = None, direction: str | None = None) -> AdapterResult[SolidWorksFeature]

Mock creating an extrusion feature.

Parameters:

Name	Type	Description	Default
`params`	`ExtrusionParameters \| str`	The params value.	required
`depth`	`float \| None`	The depth value. Defaults to None.	`None`
`direction`	`str \| None`	The direction value. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_extrusion(
    self,
    params: ExtrusionParameters | str,
    depth: float | None = None,
    direction: str | None = None,
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating an extrusion feature.

    Args:
        params (ExtrusionParameters | str): The params value.
        depth (float | None): The depth value. Defaults to None.
        direction (str | None): The direction value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    if isinstance(params, str):
        params = ExtrusionParameters(depth=depth or 0.0)
    sketch = self._mock_named_sketch(
        getattr(params, "sketch_name", None), "extrude"
    )
    if isinstance(sketch, AdapterResult):
        return sketch

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Extrude{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Extrusion",
        id=str(uuid.uuid4()),
        parameters={
            "depth": params.depth,
            "direction": direction or "blind",
            "draft_angle": params.draft_angle,
            "reverse_direction": params.reverse_direction,
            "both_directions": params.both_directions,
            "end_condition": "MidPlane"
            if params.both_directions
            else params.end_condition,
            "thin_feature": params.thin_feature,
            "thin_thickness": params.thin_thickness,
            "thin_side": params.thin_side if params.thin_feature else None,
            "sketch_name": sketch,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_loft `async` ¶

create_loft(params: LoftParameters) -> AdapterResult[SolidWorksFeature]

Mock creating a loft feature.

Parameters:

Name	Type	Description	Default
`params`	`LoftParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_loft(
    self, params: LoftParameters
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating a loft feature.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Loft{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Loft",
        id=str(uuid.uuid4()),
        parameters={
            "profiles": params.profiles,
            "guide_curves": params.guide_curves,
            "start_tangent": params.start_tangent,
            "end_tangent": params.end_tangent,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_part `async` ¶

create_part(name: str | None = None, units: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Mock creating a new part.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name value. Defaults to None.	`None`
`units`	`str \| None`	The units value. Defaults to None.	`None`
`template`	`str \| None`	Template file path. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_part(
    self,
    name: str | None = None,
    units: str | None = None,
    template: str | None = None,
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new part.

    Args:
        name (str | None): The name value. Defaults to None.
        units (str | None): The units value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    token = "mm"
    if units is not None and str(units).strip():
        token = _normalise_mock_unit_system(str(units))
        if token is None:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unrecognised units {units!r}. "
                    "Expected one of: mm, cm, m, in, ft."
                ),
            )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    model_id = name or f"Part{len(self._models) + 1}"
    model = SolidWorksModel(
        path=f"Mock://{model_id}.sldprt",
        name=f"{model_id}",
        type="Part",
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "mock": True,
            "units": token,
            "template": template,
        },
    )

    self._current_model = model
    self._models[model.path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

create_reference_plane `async` ¶

create_reference_plane(reference: str, offset: float = 0.0, angle: float = 0.0, flip: bool = False, axis: str | None = None, face_point: list[float] | None = None) -> AdapterResult[dict[str, Any]]

Mock creating a reference plane offset from, angled to, or on a face.

Refuses exactly what the live adapter refuses (the shared reference_plane_refusal in solidworks/features.py). On success, invents a sequential PlaneN name tracked on self._reference_planes and advances the shared mock feature-tree counter so features_before/features_after differ by exactly one, the same signal the live adapter derives from IFeatureManager::GetFeatureCount.

Parameters:

Name	Type	Description	Default
`reference`	`str`	Name of the reference plane.	required
`offset`	`float`	Offset distance in millimetres. Defaults to 0.0.	`0.0`
`angle`	`float`	Angle in degrees about `axis`. Defaults to 0.0.	`0.0`
`flip`	`bool`	Reverse the offset direction. Defaults to False.	`False`
`axis`	`str \| None`	Axis to rotate about, for an angle.	`None`
`face_point`	`list[float] \| None`	Point on a flat face, in mm.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The new plane's name and
`AdapterResult[dict[str, Any]]`	parameters, or error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_reference_plane(
    self,
    reference: str,
    offset: float = 0.0,
    angle: float = 0.0,
    flip: bool = False,
    axis: str | None = None,
    face_point: list[float] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock creating a reference plane offset from, angled to, or on a face.

    Refuses exactly what the live adapter refuses (the shared
    ``reference_plane_refusal`` in ``solidworks/features.py``). On
    success, invents a sequential ``PlaneN`` name tracked on
    ``self._reference_planes`` and advances the shared mock feature-tree
    counter so ``features_before``/``features_after`` differ by exactly
    one, the same signal the live adapter derives from
    ``IFeatureManager::GetFeatureCount``.

    Args:
        reference (str): Name of the reference plane.
        offset (float): Offset distance in millimetres. Defaults to 0.0.
        angle (float): Angle in degrees about ``axis``. Defaults to 0.0.
        flip (bool): Reverse the offset direction. Defaults to False.
        axis (str | None): Axis to rotate about, for an angle.
        face_point (list[float] | None): Point on a flat face, in mm.

    Returns:
        AdapterResult[dict[str, Any]]: The new plane's name and
        parameters, or error.
    """
    from .solidworks.features import reference_plane_refusal

    refusal = reference_plane_refusal(reference, offset, angle, axis, face_point)
    if refusal is not None:
        return AdapterResult(status=AdapterResultStatus.ERROR, error=refusal)

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    before = self._feature_tree_count
    self._feature_tree_count += 1
    after = self._feature_tree_count

    self._reference_planes.append(f"Plane{len(self._reference_planes) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": self._reference_planes[-1],
            "reference": reference if face_point is None else None,
            "face_point": face_point,
            "offset": offset or None,
            "angle": angle or None,
            "axis": axis if angle else None,
            "flip": flip,
            "features_before": before,
            "features_after": after,
        },
        execution_time=self._delays["feature_operation"],
    )

create_reference_point `async` ¶

create_reference_point(mode: str, x: float, y: float, z: float, distance: float | None = None, percent: float | None = None) -> AdapterResult[dict[str, Any]]

Mock creating a reference point on the active part.

The mock has no geometry, so it cannot resolve a coordinate to an edge/face - it mirrors the live adapter's validation (unknown mode, the distance/percent XOR, range checks) and, on a valid request, bumps the feature counter the way InsertReferencePoint would.

Parameters:

Name	Type	Description	Default
`mode`	`str`	"along_curve" or "face_center".	required
`x`	`float`	X of a point on the target entity, in millimetres.	required
`y`	`float`	Y of a point on the target entity, in millimetres.	required
`z`	`float`	Z of a point on the target entity, in millimetres.	required
`distance`	`float \| None`	For "along_curve", offset from the edge start in millimetres.	`None`
`percent`	`float \| None`	For "along_curve", 0-100 of edge length.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The mode and feature counts, or an
`AdapterResult[dict[str, Any]]`	error matching the live adapter's refusals.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_reference_point(
    self,
    mode: str,
    x: float,
    y: float,
    z: float,
    distance: float | None = None,
    percent: float | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock creating a reference point on the active part.

    The mock has no geometry, so it cannot resolve a coordinate to an
    edge/face - it mirrors the live adapter's *validation* (unknown mode,
    the distance/percent XOR, range checks) and, on a valid request,
    bumps the feature counter the way ``InsertReferencePoint`` would.

    Args:
        mode (str): "along_curve" or "face_center".
        x (float): X of a point on the target entity, in millimetres.
        y (float): Y of a point on the target entity, in millimetres.
        z (float): Z of a point on the target entity, in millimetres.
        distance (float | None): For "along_curve", offset from the edge
            start in millimetres.
        percent (float | None): For "along_curve", 0-100 of edge length.

    Returns:
        AdapterResult[dict[str, Any]]: The mode and feature counts, or an
        error matching the live adapter's refusals.
    """
    key = str(mode or "").strip().lower()
    if key not in ("along_curve", "face_center"):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(f"Unknown mode {mode!r}. Use 'along_curve' or 'face_center'."),
        )
    if key == "along_curve":
        if (distance is None) == (percent is None):
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error="along_curve needs exactly one of distance or percent",
            )
        if distance is not None and float(distance) <= 0.0:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error="distance must be positive",
            )
        if percent is not None and not 0.0 < float(percent) < 100.0:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error="percent must be between 0 and 100 (exclusive)",
            )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1
    before = self._feature_tree_count
    self._feature_tree_count += 1
    self._reference_points.append(f"Point{len(self._reference_points) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": self._reference_points[-1],
            "mode": key,
            "at_mm": [x, y, z],
            "distance_mm": distance if key == "along_curve" else None,
            "percent": percent if key == "along_curve" else None,
            "features_before": before,
            "features_after": self._feature_tree_count,
        },
        execution_time=self._delays["feature_operation"],
    )

create_revolve `async` ¶

create_revolve(params: RevolveParameters) -> AdapterResult[SolidWorksFeature]

Mock creating a revolve feature.

Parameters:

Name	Type	Description	Default
`params`	`RevolveParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_revolve(
    self, params: RevolveParameters
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating a revolve feature.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    sketch = self._mock_named_sketch(
        getattr(params, "sketch_name", None), "revolve"
    )
    if isinstance(sketch, AdapterResult):
        return sketch
    axis = getattr(params, "axis_entity", None)
    if axis and axis not in self._axes:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Axis '{axis}' is not a reference axis in the "
            "model. Create one with create_axis.",
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Revolve{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Revolve",
        id=str(uuid.uuid4()),
        parameters={
            "angle": params.angle,
            "reverse_direction": params.reverse_direction,
            "both_directions": params.both_directions,
            "thin_feature": params.thin_feature,
            "thin_thickness": params.thin_thickness,
            "sketch_name": sketch,
            "axis_entity": axis,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_sketch `async` ¶

create_sketch(plane: str) -> AdapterResult[dict[str, Any]]

Mock creating a sketch.

Parameters:

Name	Type	Description	Default
`plane`	`str`	The plane value.	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_sketch(self, plane: str) -> AdapterResult[dict[str, Any]]:  # type: ignore[override]
    """Mock creating a sketch.

    Args:
        plane (str): The plane value.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        # Legacy tests start sketching immediately after connect.
        await self.create_part()

    await asyncio.sleep(self._delays["sketch_operation"])
    self._operation_count += 1

    sketch_id = f"Sketch{len(self._sketches) + 1}"
    self._sketches[sketch_id] = plane
    self._current_sketch = sketch_id

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "id": sketch_id,
            "name": sketch_id,
            "sketch_name": sketch_id,
            "plane": plane,
        },
        execution_time=self._delays["sketch_operation"],
    )

create_standard_drawing `async` ¶

create_standard_drawing(model_path: str, output_dir: str | None = None, title: str | None = None, subtitle: str | None = None, drawing_number: str | None = None, author: str = '', revision: str = 'A', company: str = '', drawn_date: str | None = None, notes: list[str] | None = None, include_isometric: bool = True, write_model_properties: bool = True, title_block_text_height_mm: float | None = None, include_bom: bool = False) -> AdapterResult[dict[str, Any]]

Mock standard A3 drawing: validates inputs, writes nothing to disk.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_standard_drawing(
    self,
    model_path: str,
    output_dir: str | None = None,
    title: str | None = None,
    subtitle: str | None = None,
    drawing_number: str | None = None,
    author: str = "",
    revision: str = "A",
    company: str = "",
    drawn_date: str | None = None,
    notes: list[str] | None = None,
    include_isometric: bool = True,
    write_model_properties: bool = True,
    title_block_text_height_mm: float | None = None,
    include_bom: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Mock standard A3 drawing: validates inputs, writes nothing to disk."""
    if not os.path.isfile(model_path):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Model file not found: {model_path}",
        )
    stem = os.path.splitext(os.path.basename(model_path))[0]
    number = drawing_number or f"{stem.upper().replace(' ', '-')}-Rev{revision}-01"
    out_dir = output_dir or os.path.dirname(model_path)
    views = {
        "Drawing View1": {"role": "front", "caption": "FRONT VIEW"},
        "Drawing View2": {"role": "plan", "caption": "TOP VIEW"},
        "Drawing View3": {"role": "side", "caption": "SIDE VIEW"},
    }
    if include_isometric:
        views["Drawing View4"] = {"role": "iso", "caption": "ISOMETRIC VIEW"}
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "scale": "1:1",
            "isometric_scale": "1:1" if include_isometric else None,
            "views": views,
            "hidden_lines_visible": {
                n: True for n, v in views.items() if v["role"] != "iso"
            },
            "bom": {"bom_type": "top_level_only", "table_box_mm": None}
            if include_bom
            else None,
            "overlap_check": {"overlaps_after": 0, "annotation_overlaps": []},
            "drawing_number": number,
            "drawing_path": os.path.join(out_dir, f"{number}.SLDDRW"),
            "pdf_path": os.path.join(out_dir, f"{number}.pdf"),
            "properties_written": {
                "model": {"Description": title or stem}
                if write_model_properties
                else {},
                "drawing": {"DrawnBy": author, "Revision": revision},
            },
            "notes": ["NOTES", *[n.upper() for n in (notes or [])]],
            "title_block": {
                "drawing number": {"found": True, "fits": True},
                "title": {"found": True, "fits": True},
            },
            "mock": True,
        },
    )

create_sweep `async` ¶

create_sweep(params: SweepParameters) -> AdapterResult[SolidWorksFeature]

Mock creating a sweep feature.

Parameters:

Name	Type	Description	Default
`params`	`SweepParameters`	The params value.	required

Returns:

Type	Description
`AdapterResult[SolidWorksFeature]`	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_sweep(
    self, params: SweepParameters
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating a sweep feature.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Sweep{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Sweep",
        id=str(uuid.uuid4()),
        parameters={
            "path": params.path,
            "twist_along_path": params.twist_along_path,
            "twist_angle": params.twist_angle,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_technical_drawing `async` ¶

create_technical_drawing(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock laying out the three standard views of a model.

Parameters:

Name	Type	Description	Default
`payload`	`Any`	Tool payload carrying the model path and projection.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_technical_drawing(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock laying out the three standard views of a model.

    Args:
        payload (Any): Tool payload carrying the model path and projection.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    data = payload if isinstance(payload, dict) else {}
    model_path = data.get("model_path") or data.get("model_file")
    if not model_path:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="A model path is required (model_path or model_file)",
        )

    third_angle = bool(data.get("third_angle", True))
    if str(data.get("projection", "")).lower() in {"first", "first_angle"}:
        third_angle = False

    before = len(self._drawing_views)
    added = [f"Drawing View{before + offset}" for offset in (1, 2, 3)]
    self._drawing_views.extend(added)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "views": added,
            "model_path": model_path,
            "projection": "third_angle" if third_angle else "first_angle",
            "views_before": before,
            "views_after": len(self._drawing_views),
        },
        execution_time=self._delays["model_operation"],
    )

delete_feature `async` ¶

delete_feature(name: str) -> AdapterResult[dict[str, Any]]

Mock deleting a named feature from the active model.

Parameters:

Name	Type	Description	Default
`name`	`str`	Feature or sketch name.	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def delete_feature(self, name: str) -> AdapterResult[dict[str, Any]]:
    """Mock deleting a named feature from the active model.

    Args:
        name (str): Feature or sketch name.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])

    # _features is keyed by an internal id, so resolve by feature name.
    before = [f.name for f in self._features.values()]
    key = next((k for k, f in self._features.items() if f.name == name), None)
    if key is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Feature not found: {name}. "
                f"Available: {', '.join(before) or 'none'}"
            ),
        )

    del self._features[key]
    self._suppressed_features.discard(name)
    self._operation_count += 1
    after = [f.name for f in self._features.values()]

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "deleted": name,
            "removed_features": [n for n in before if n not in after],
            "features_before": len(before),
            "features_after": len(after),
        },
        execution_time=self._delays["model_operation"],
    )

disconnect `async` ¶

disconnect() -> None

Mock disconnection from SolidWorks.

Returns:

Name	Type	Description
`None`	`None`	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def disconnect(self) -> None:
    """Mock disconnection from SolidWorks.

    Returns:
        None: None.
    """
    self._connected = False
    self._current_model = None
    self._models.clear()
    self._features.clear()
    self._sketches.clear()
    self._current_sketch = None
    self._selection.clear()

exit_sketch `async` ¶

exit_sketch() -> AdapterResult[None]

Mock exiting sketch mode.

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def exit_sketch(self) -> AdapterResult[None]:
    """Mock exiting sketch mode.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.WARNING, error="No active sketch to exit"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._current_sketch = None

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=None,
        execution_time=self._delays["sketch_operation"] / 2,
    )

export_file `async` ¶

export_file(file_path: str, format_type: str) -> AdapterResult[None]

Mock exporting a file.

Parameters:

Name	Type	Description	Default
`file_path`	`str`	Path to the target file.	required
`format_type`	`str`	The format type value.	required

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def export_file(
    self, file_path: str, format_type: str
) -> AdapterResult[None]:
    """Mock exporting a file.

    Args:
        file_path (str): Path to the target file.
        format_type (str): The format type value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    # Simulate export time based on format
    export_times = {
        "step": 2.0,
        "iges": 1.5,
        "stl": 1.0,
        "pdf": 0.5,
        "jpg": 0.3,
        "glb": 1.2,
        "gltf": 1.2,
    }

    format_lower = format_type.lower()
    delay = export_times.get(format_lower, 1.0)

    await asyncio.sleep(delay)
    self._operation_count += 1

    # Write a minimal placeholder file so callers that check existence get a valid result
    if format_lower == "stl":
        import pathlib

        out = pathlib.Path(file_path)
        out.parent.mkdir(parents=True, exist_ok=True)
        # Minimal ASCII STL — a single unit triangle (mock geometry placeholder)
        out.write_text(
            "solid mock\n"
            "  facet normal 0 0 1\n"
            "    outer loop\n"
            "      vertex 0 0 0\n"
            "      vertex 10 0 0\n"
            "      vertex 5 10 0\n"
            "    endloop\n"
            "  endfacet\n"
            "  facet normal 0 0 1\n"
            "    outer loop\n"
            "      vertex 0 0 0\n"
            "      vertex 10 0 0\n"
            "      vertex 5 0 10\n"
            "    endloop\n"
            "  endfacet\n"
            "endsolid mock\n",
            encoding="utf-8",
        )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=None,
        execution_time=delay,
        metadata={"exported_format": format_type, "file_path": file_path},
    )

export_flat_pattern `async` ¶

export_flat_pattern(file_path: str) -> AdapterResult[dict[str, Any]]

Mock flat-pattern export: validates the target, writes nothing.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def export_flat_pattern(
    self, file_path: str
) -> AdapterResult[dict[str, Any]]:
    """Mock flat-pattern export: validates the target, writes nothing."""
    guard = self._mock_doc_error({"Part"}, "export_flat_pattern")
    if guard is not None:
        return guard
    if not file_path.lower().endswith((".dxf", ".dwg")):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="file_path must end in .dxf or .dwg",
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"file_path": file_path, "size_bytes": 0, "mock": True},
    )

export_image `async` ¶

export_image(payload: dict) -> AdapterResult[dict]

Mock export of a PNG/JPG viewport screenshot.

Parameters:

Name	Type	Description	Default
`payload`	`dict`	The payload value.	required

Returns:

Type	Description
`AdapterResult[dict]`	AdapterResult[dict]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Mock export of a PNG/JPG viewport screenshot.

    Args:
        payload (dict): The payload value.

    Returns:
        AdapterResult[dict]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    import pathlib

    file_path = payload.get("file_path", "")
    width = int(payload.get("width", 1280))
    height = int(payload.get("height", 720))
    orientation = str(payload.get("view_orientation", "current"))

    await asyncio.sleep(0.3)
    self._operation_count += 1

    out = pathlib.Path(file_path)
    out.parent.mkdir(parents=True, exist_ok=True)

    # Write a valid 1×1 white PNG binary so UI image tags don't break
    _PNG_1X1_WHITE = (
        b"\x89PNG\r\n\x1a\n"  # PNG signature
        b"\x00\x00\x00\rIHDR"  # IHDR chunk length+type
        b"\x00\x00\x00\x01\x00\x00\x00\x01"  # 1x1
        b"\x08\x02\x00\x00\x00\x90wS\xde"  # 8-bit RGB + CRC
        b"\x00\x00\x00\x0cIDATx\x9cc\xf8\xff\xff\xff\x00\x05\xfe\x02\xfe\xdc\xcaY\xe7"  # IDAT
        b"\x00\x00\x00\x00IEND\xaeB`\x82"  # IEND
    )
    out.write_bytes(_PNG_1X1_WHITE)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "file_path": file_path,
            "format": "PNG",
            "dimensions": f"{width}x{height}",
            "view": orientation,
        },
        execution_time=0.3,
        metadata={"mock": True, "orientation": orientation},
    )

get_application_info `async` ¶

get_application_info() -> AdapterResult[dict[str, Any]]

Mock SolidWorks description: a fixed 2026 install in English.

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_application_info(self) -> AdapterResult[dict[str, Any]]:
    """Mock SolidWorks description: a fixed 2026 install in English.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "revision": "34.0.0",
            "language": "english",
            "templates": {
                kind: {"file_name": f"{kind}.{ext}", "exists": True}
                for kind, ext in (
                    ("part", "prtdot"),
                    ("assembly", "asmdot"),
                    ("drawing", "drwdot"),
                )
            },
        },
    )

get_custom_properties `async` ¶

get_custom_properties(configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock reading custom properties.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_custom_properties(
    self, configuration: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock reading custom properties."""
    if self._current_model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    store = getattr(self, "_custom_properties", {})
    props = store.get((self._mock_doc_key(), configuration or ""), {})
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "configuration": configuration or "",
            "properties": {
                k: {"value": v, "resolved": v} for k, v in props.items()
            },
        },
    )

get_dimension `async` ¶

get_dimension(name: str) -> AdapterResult[dict[str, Any]]

Mock getting a dimension value; the mock's dimensions are lengths.

Parameters:

Name	Type	Description	Default
`name`	`str`	The name value.	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: `value` in mm and `units: "mm"`.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_dimension(self, name: str) -> AdapterResult[dict[str, Any]]:
    """Mock getting a dimension value; the mock's dimensions are lengths.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[dict[str, Any]]: ``value`` in mm and ``units: "mm"``.
    """
    await asyncio.sleep(0.05)  # Very fast operation
    self._operation_count += 1

    if name in self._dimensions:
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data={"value": self._dimensions[name], "units": "mm"},
            execution_time=0.05,
        )
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Dimension '{name}' not found; list the names with "
                "list_model_dimensions"
            ),
        )

get_mass_properties `async` ¶

get_mass_properties() -> AdapterResult[MassProperties]

Mock getting mass properties.

Returns:

Type	Description
`AdapterResult[MassProperties]`	AdapterResult[MassProperties]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_mass_properties(self) -> AdapterResult[MassProperties]:
    """Mock getting mass properties.

    Returns:
        AdapterResult[MassProperties]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    # Generate realistic mock data
    properties = MassProperties(
        volume=random.uniform(1000, 100000),  # mm³
        surface_area=random.uniform(1000, 50000),  # mm²
        mass=random.uniform(0.1, 50.0),  # kg (assuming typical density)
        center_of_mass=[
            random.uniform(-100, 100),
            random.uniform(-100, 100),
            random.uniform(-100, 100),
        ],
        moments_of_inertia={
            "Ixx": random.uniform(1e6, 1e9),
            "Iyy": random.uniform(1e6, 1e9),
            "Izz": random.uniform(1e6, 1e9),
            "Ixy": random.uniform(-1e8, 1e8),
            "Ixz": random.uniform(-1e8, 1e8),
            "Iyz": random.uniform(-1e8, 1e8),
        },
    )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=properties,
        execution_time=self._delays["feature_operation"],
    )

get_material `async` ¶

get_material(configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock reading the active part material.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_material(
    self, configuration: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock reading the active part material."""
    guard = self._mock_doc_error({"Part"}, "get_material")
    if guard is not None:
        return guard
    assigned = getattr(self, "_materials", {}).get(self._mock_doc_key())
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "material": assigned["name"] if assigned else None,
            "database": assigned["database"] if assigned else None,
            "density_kg_m3": (
                self._MOCK_DENSITIES.get(assigned["name"]) if assigned else None
            ),
            "configuration": configuration,
        },
    )

get_model_geometry_summary `async` ¶

get_model_geometry_summary() -> AdapterResult[dict[str, Any]]

Mock summary of the active part or assembly.

The mock has no geometry, so volume, bounding box and body count are None ("not determinable") rather than invented numbers a caller could mistake for a measurement. Component and mate counts are real: they come from insert_component and add_mate this session.

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_model_geometry_summary(self) -> AdapterResult[dict[str, Any]]:
    """Mock summary of the active part or assembly.

    The mock has no geometry, so volume, bounding box and body count are
    ``None`` ("not determinable") rather than invented numbers a caller
    could mistake for a measurement. Component and mate counts are real:
    they come from ``insert_component`` and ``add_mate`` this session.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    guard = self._mock_doc_error({"Part", "Assembly"}, "get_model_geometry_summary")
    if guard is not None:
        return guard
    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    is_assembly = self._current_model.type == "Assembly"
    summary: dict[str, Any] = {
        "document_type": "assembly" if is_assembly else "part",
        "volume_mm3": None,
        "bounding_box_mm": None,
        "bounding_box_method": None,
        "solid_body_count": None,
    }
    if is_assembly:
        summary["component_count"] = len(self._components)
        summary["mate_count"] = len(self._mates)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=summary,
        execution_time=self._delays["model_operation"] / 2,
    )

get_model_info `async` ¶

get_model_info() -> AdapterResult[dict[str, Any]]

Mock metadata for the currently active model.

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
    """Mock metadata for the currently active model.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    model = self._current_model
    feature_count = len(self._features)
    info = {
        "title": model.name,
        "path": model.path,
        "type": model.type,
        "configuration": model.configuration or "Default",
        "is_dirty": False,
        "feature_count": feature_count,
        "rebuild_status": 0,
    }

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=info,
        execution_time=self._delays["model_operation"] / 2,
    )

get_selected_entities `async` ¶

get_selected_entities() -> AdapterResult[list[dict[str, Any]]]

Mock UI selection — always reports one canned face and one canned edge.

There's no real UI to read a selection from in mock mode, so this returns a stable, plausible-shaped fixture rather than an empty list, so callers exercising this tool in tests get realistic field names.

Returns:

Type	Description
`AdapterResult[list[dict[str, Any]]]`	AdapterResult[list[dict[str, Any]]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_selected_entities(self) -> AdapterResult[list[dict[str, Any]]]:
    """Mock UI selection — always reports one canned face and one canned edge.

    There's no real UI to read a selection from in mock mode, so this
    returns a stable, plausible-shaped fixture rather than an empty list,
    so callers exercising this tool in tests get realistic field names.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )
    await asyncio.sleep(self._delays["feature_operation"] / 4)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=[
            {
                "index": 1,
                "type": "FACE",
                "bounding_box_mm": {
                    "min": [0.0, 0.0, 0.0],
                    "max": [30.0, 30.0, 0.0],
                },
                "center_mm": [15.0, 15.0, 0.0],
                "area_mm2": 900.0,
                "normal": [0.0, 0.0, 1.0],
            },
            {
                "index": 2,
                "type": "EDGE",
                "start_mm": [0.0, 0.0, -15.0],
                "end_mm": [30.0, 0.0, -15.0],
                "length_mm": 30.0,
            },
        ],
        execution_time=self._delays["feature_operation"] / 4,
    )

health_check `async` ¶

health_check() -> AdapterHealth

Get mock health status.

Returns:

Name	Type	Description
`AdapterHealth`	`AdapterHealth`	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def health_check(self) -> AdapterHealth:
    """Get mock health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    error_count = int(self._metrics["errors_count"])
    success_count = int(
        self._metrics["operations_count"] - self._metrics["errors_count"]
    )
    return AdapterHealth(
        healthy=self._connected,
        last_check=datetime.now(),
        error_count=error_count,
        success_count=success_count,
        average_response_time=self._metrics["average_response_time"],
        connection_status="connected" if self._connected else "disconnected",
        metrics={
            "adapter_type": "mock",
            "operations_count": self._operation_count,
            "models_count": len(self._models),
            "features_count": len(self._features),
            "sketches_count": len(self._sketches),
        },
    )

insert_bom_table `async` ¶

insert_bom_table(view_name: str, template_path: str | None = None, bom_type: str = 'top_level_only', x_mm: float | None = None, y_mm: float | None = None) -> AdapterResult[dict[str, Any]]

Mock inserting a BOM table.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def insert_bom_table(
    self,
    view_name: str,
    template_path: str | None = None,
    bom_type: str = "top_level_only",
    x_mm: float | None = None,
    y_mm: float | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock inserting a BOM table."""
    guard = self._mock_doc_error({"Drawing"}, "insert_bom_table")
    if guard is not None:
        return guard
    if bom_type not in {"top_level_only", "parts_only", "indented"}:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="bom_type must be top_level_only, parts_only or indented",
        )
    if view_name not in self._drawing_views:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {view_name!r}. Views: "
                f"{', '.join(self._drawing_views) or 'none'}"
            ),
        )
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "view": view_name,
            "bom_type": bom_type,
            "template": template_path,
            "row_count": 2,
            "table_box_mm": [0.0, 0.0, 60.0, 15.0],
            "moved_onto_sheet": False,
        },
    )

insert_component `async` ¶

insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Mock inserting a component into the active assembly.

Records the component in self._components so repeated inserts accumulate and list_components reflects them.

Parameters:

Name	Type	Description	Default
`file_path`	`str`	Path to the part or sub-assembly to insert.	required
`x`	`float`	X position in millimetres. Defaults to 0.0.	`0.0`
`y`	`float`	Y position in millimetres. Defaults to 0.0.	`0.0`
`z`	`float`	Z position in millimetres. Defaults to 0.0.	`0.0`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Mock inserting a component into the active assembly.

    Records the component in ``self._components`` so repeated inserts
    accumulate and ``list_components`` reflects them.

    Args:
        file_path (str): Path to the part or sub-assembly to insert.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    self._components.append(f"component-{len(self._components) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "component": self._components[-1],
            "file_path": file_path,
            "position": {"x": x, "y": y, "z": z},
            "components_before": len(self._components) - 1,
            "components_after": len(self._components),
        },
        execution_time=self._delays["model_operation"],
    )

insert_model_dimensions `async` ¶

insert_model_dimensions(view_name: str | None = None, include_hole_wizard: bool = True) -> AdapterResult[dict[str, Any]]

Mock importing model dimensions: three per view, never twice.

Mirrors the live result shape (views, dimensions_added, unique_dimensions, skipped_pictorial_views, method, autodimension_status) and its refusals.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def insert_model_dimensions(
    self, view_name: str | None = None, include_hole_wizard: bool = True
) -> AdapterResult[dict[str, Any]]:
    """Mock importing model dimensions: three per view, never twice.

    Mirrors the live result shape (``views``, ``dimensions_added``,
    ``unique_dimensions``, ``skipped_pictorial_views``, ``method``,
    ``autodimension_status``) and its refusals.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)
    guard = self._mock_doc_error({"Drawing"}, "insert_model_dimensions")
    if guard is not None:
        return guard
    names = [view_name] if view_name else list(self._drawing_views)
    unknown = [n for n in names if n not in self._drawing_views]
    if unknown or not names:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {unknown[0]!r}. Views: "
                f"{', '.join(self._drawing_views) or 'none'}"
                if unknown
                else "No drawing views found to dimension; add views with "
                "create_technical_drawing or create_drawing_view"
            ),
        )
    if not hasattr(self, "_view_dimensions"):
        self._view_dimensions: dict[str, int] = {}
    per_view = []
    for name in names:
        before = self._view_dimensions.get(name, 0)
        after = before or 3
        self._view_dimensions[name] = after
        per_view.append(
            {
                "view": name,
                "dimensions_before": before,
                "dimensions_after": after,
                "dimensions_added": after - before,
                "duplicates_removed": 0,
            }
        )
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "views": per_view,
            "dimensions_added": sum(v["dimensions_added"] for v in per_view),
            "unique_dimensions": sum(self._view_dimensions.values()),
            "skipped_pictorial_views": [],
            "method": "insert_model_annotations",
            "autodimension_status": None,
        },
    )

is_connected ¶

is_connected() -> bool

Check if mock connection is active.

Returns:

Name	Type	Description
`bool`	`bool`	True if connected, otherwise False.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def is_connected(self) -> bool:
    """Check if mock connection is active.

    Returns:
        bool: True if connected, otherwise False.
    """
    return self._connected

list_available_materials `async` ¶

list_available_materials(search: str | None = None) -> AdapterResult[list[dict[str, str]]]

Mock listing the material library, with the live metadata.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_available_materials(
    self, search: str | None = None
) -> AdapterResult[list[dict[str, str]]]:
    """Mock listing the material library, with the live ``metadata``."""
    needle = (search or "").strip().lower()
    items = [
        dict(m)
        for m in self._MOCK_MATERIALS
        if not needle
        or needle in m["name"].lower()
        or needle in m["classification"].lower()
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=items,
        metadata={
            "folders": [self._MOCK_MATERIAL_FOLDER],
            "total": len(self._MOCK_MATERIALS),
        },
    )

list_components `async` ¶

list_components() -> AdapterResult[list[str]]

Mock listing the top-level components of the active assembly.

Returns:

Type	Description
`AdapterResult[list[str]]`	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_components(self) -> AdapterResult[list[str]]:
    """Mock listing the top-level components of the active assembly.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=list(self._components),
        execution_time=self._delays["model_operation"] / 2,
    )

list_configurations `async` ¶

list_configurations() -> AdapterResult[list[str]]

Mock configuration listing for the active model.

Returns:

Type	Description
`AdapterResult[list[str]]`	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_configurations(self) -> AdapterResult[list[str]]:
    """Mock configuration listing for the active model.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    active = self._current_model.configuration or "Default"
    configs = [active] if active == "Default" else ["Default", active]

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=configs,
        execution_time=self._delays["model_operation"] / 2,
    )

list_drawing_views `async` ¶

list_drawing_views() -> AdapterResult[list[str]]

Mock listing the views on the active drawing.

Returns:

Type	Description
`AdapterResult[list[str]]`	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_drawing_views(self) -> AdapterResult[list[str]]:
    """Mock listing the views on the active drawing.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=list(self._drawing_views),
        execution_time=self._delays["model_operation"] / 2,
    )

list_features `async` ¶

list_features(include_suppressed: bool = False, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, Any]]]

Mock feature tree listing for the active model.

For an Assembly model, flattens in every configured component's features (see _assembly_components) alongside the document's own features, tagged with component/component_path the same way the real adapter does. Falls back to a small canned two-component fixture (plus one nested sub-assembly) when no components have been configured, mirroring the existing "seed realistic feature names" behavior for an empty Part.

Parameters:

Name	Type	Description	Default
`include_suppressed`	`bool`	The include suppressed value. Defaults to False.	`False`
`max_assembly_depth`	`int`	Sub-assembly recursion budget. Ignored for non-Assembly models. Defaults to 2.	`2`

Returns:

Type	Description
`AdapterResult[list[dict[str, Any]]]`	AdapterResult[list[dict[str, Any]]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, Any]]]:
    """Mock feature tree listing for the active model.

    For an Assembly model, flattens in every configured component's
    features (see ``_assembly_components``) alongside the document's own
    features, tagged with ``component``/``component_path`` the same way
    the real adapter does. Falls back to a small canned two-component
    fixture (plus one nested sub-assembly) when no components have been
    configured, mirroring the existing "seed realistic feature names"
    behavior for an empty Part.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
        max_assembly_depth (int): Sub-assembly recursion budget. Ignored
            for non-Assembly models. Defaults to 2.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["feature_operation"] / 2)
    self._operation_count += 1

    is_assembly = self._current_model.type == "Assembly"

    # Seed realistic feature names for empty mock state.
    if not self._features:
        seeded: list[dict[str, Any]] = [
            {
                "name": "Origin",
                "type": "OriginProfileFeature",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Front Plane",
                "type": "RefPlane",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Right Plane",
                "type": "RefPlane",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Top Plane",
                "type": "RefPlane",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Sketch1",
                "type": "ProfileFeature",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
        ]
        if is_assembly:
            components = self._assembly_components or _DEFAULT_ASSEMBLY_COMPONENTS
            seeded.extend(
                self._flatten_assembly_components(
                    components, include_suppressed, max_assembly_depth - 1, None
                )
            )
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data=seeded,
            execution_time=self._delays["feature_operation"] / 2,
        )

    feature_rows: list[dict[str, Any]] = []
    for i, feature in enumerate(self._features.values()):
        row = {
            "name": feature.name,
            "type": feature.type,
            "suppressed": bool((feature.properties or {}).get("suppressed", False)),
            "position": i,
            "component": None,
            "component_path": None,
            "component_parent": None,
        }
        if include_suppressed or not row["suppressed"]:
            feature_rows.append(row)

    if is_assembly:
        components = self._assembly_components or _DEFAULT_ASSEMBLY_COMPONENTS
        feature_rows.extend(
            self._flatten_assembly_components(
                components,
                include_suppressed,
                max_assembly_depth - 1,
                None,
            )
        )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature_rows,
        execution_time=self._delays["feature_operation"] / 2,
    )

list_model_dimensions `async` ¶

list_model_dimensions(feature_name: str | None = None) -> AdapterResult[list[dict[str, Any]]]

Mock listing model dimensions from the tracked dimension table.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_model_dimensions(
    self, feature_name: str | None = None
) -> AdapterResult[list[dict[str, Any]]]:
    """Mock listing model dimensions from the tracked dimension table."""
    await asyncio.sleep(self._delays["model_operation"] / 2)
    guard = self._mock_doc_error({"Part", "Assembly"}, "list_model_dimensions")
    if guard is not None:
        return guard
    self._operation_count += 1
    dims = []
    for full_name, value in self._dimensions.items():
        feature = full_name.split("@", 1)[1] if "@" in full_name else ""
        if feature_name and feature.lower() != feature_name.lower():
            continue
        dims.append(
            {
                "full_name": full_name,
                "feature": feature,
                "value": value,
                "system_value": value / 1000.0,
                "read_only": False,
            }
        )
    if feature_name and not dims:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"No dimensions found on feature {feature_name!r}",
        )
    return AdapterResult(status=AdapterResultStatus.SUCCESS, data=dims)

list_open_documents `async` ¶

list_open_documents() -> AdapterResult[list[dict[str, Any]]]

Mock enumerating the currently open documents.

Returns every model the mock has created or opened this session, with is_active reflecting self._current_model.

Returns:

Type	Description
`AdapterResult[list[dict[str, Any]]]`	AdapterResult[list[dict[str, Any]]]: The result produced by the
`AdapterResult[list[dict[str, Any]]]`	operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_open_documents(self) -> AdapterResult[list[dict[str, Any]]]:
    """Mock enumerating the currently open documents.

    Returns every model the mock has created or opened this session, with
    ``is_active`` reflecting ``self._current_model``.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the
        operation.
    """
    await asyncio.sleep(0.05)
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    active_path = (
        self._current_model.path if self._current_model is not None else None
    )
    docs = [
        {
            "title": model.name,
            "path": model.path,
            "type": model.type,
            "is_active": model.path == active_path,
        }
        for model in self._models.values()
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS, data=docs, execution_time=0.05
    )

measure_entities `async` ¶

measure_entities(entities: list[str]) -> AdapterResult[dict[str, Any]]

Mock measuring: nominal values with the live adapter's validation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def measure_entities(
    self, entities: list[str]
) -> AdapterResult[dict[str, Any]]:
    """Mock measuring: nominal values with the live adapter's validation."""
    await asyncio.sleep(self._delays["model_operation"] / 2)
    guard = self._mock_doc_error({"Part", "Assembly"}, "measure_entities")
    if guard is not None:
        return guard
    if not entities or len(entities) > 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="measure_entities takes one or two entity specs",
        )
    self._operation_count += 1
    data: dict[str, Any] = {"selected": list(entities)}
    if len(entities) == 1:
        data.update({"area_m2": 0.0025, "perimeter_m": 0.2})
    else:
        data.update({"distance_m": 0.05, "angle_rad": 0.0, "is_parallel": True})
    return AdapterResult(status=AdapterResultStatus.SUCCESS, data=data)

mirror_feature `async` ¶

mirror_feature(features: list[str], mirror_plane: str, merge: bool = True, mirror_bodies: bool = True) -> AdapterResult[dict[str, Any]]

Mock mirroring solid bodies or features about a plane.

The mock has no geometry engine, so it cannot measure a real volume change - it mirrors the live adapter's refusals instead of fabricating a result it cannot know. An empty source list or plane name is rejected outright (matching _mirror_feature_impl in solidworks/features.py verbatim), and a source or plane name that was never created in this session is rejected the same way _select_named_feature / _select_reference_entity would fail to select it there.

On success, the tracked self._mirror_volume figure (seeded at the live-measured 1819569.1 mm^3 wing volume) is doubled, matching the ~2.0 ratio a correct mirror produces (measured live: 1.998528 for a lofted wing, exactly 2.0 for a boss whose sketch sits on the plane).

Parameters:

Name	Type	Description	Default
`features`	`list[str]`	Body or feature names to mirror.	required
`mirror_plane`	`str`	Plane name to mirror about.	required
`merge`	`bool`	Merge the mirrored result with the original. Defaults to True.	`True`
`mirror_bodies`	`bool`	Mirror whole bodies rather than features. Defaults to True.	`True`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The mirror feature's name, inputs
`AdapterResult[dict[str, Any]]`	and volume before/after, or error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def mirror_feature(
    self,
    features: list[str],
    mirror_plane: str,
    merge: bool = True,
    mirror_bodies: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mock mirroring solid bodies or features about a plane.

    The mock has no geometry engine, so it cannot measure a real volume
    change - it mirrors the live adapter's refusals instead of
    fabricating a result it cannot know. An empty source list or plane
    name is rejected outright (matching ``_mirror_feature_impl`` in
    ``solidworks/features.py`` verbatim), and a source or plane name
    that was never created in this session is rejected the same way
    ``_select_named_feature`` / ``_select_reference_entity`` would fail
    to select it there.

    On success, the tracked ``self._mirror_volume`` figure (seeded at
    the live-measured 1819569.1 mm^3 wing volume) is doubled, matching
    the ~2.0 ratio a correct mirror produces (measured live: 1.998528
    for a lofted wing, exactly 2.0 for a boss whose sketch sits on the
    plane).

    Args:
        features (list[str]): Body or feature names to mirror.
        mirror_plane (str): Plane name to mirror about.
        merge (bool): Merge the mirrored result with the original. Defaults to True.
        mirror_bodies (bool): Mirror whole bodies rather than features. Defaults to True.

    Returns:
        AdapterResult[dict[str, Any]]: The mirror feature's name, inputs
        and volume before/after, or error.
    """
    names = [n for n in (features or []) if n]
    if not names:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="mirror_feature requires at least one body or feature name",
        )
    if not mirror_plane:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="mirror_feature requires a mirror plane name",
        )

    known_sources = {feature.name for feature in self._features.values()} | set(
        self._components
    )
    for name in names:
        if name not in known_sources:
            kind = "body" if mirror_bodies else "feature"
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=f"Failed to select {kind} to mirror: {name}",
            )

    known_planes = self._BUILTIN_PLANES | set(self._reference_planes)
    if mirror_plane not in known_planes:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Failed to select mirror plane: {mirror_plane}",
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    volume_before = self._mirror_volume
    volume_after = volume_before * 2
    self._mirror_volume = volume_after

    self._feature_tree_count += 1
    feature_name = f"Mirror{self._feature_tree_count}"

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": feature_name,
            "mirrored": names,
            "mirror_plane": mirror_plane,
            "merge": bool(merge),
            "mirror_bodies": bool(mirror_bodies),
            "volume_before": volume_before,
            "volume_after": volume_after,
            "volume_change": volume_after - volume_before,
            "volume_ratio": round(volume_after / volume_before, 6),
        },
        execution_time=self._delays["feature_operation"],
    )

open_model `async` ¶

open_model(file_path: str) -> AdapterResult[SolidWorksModel]

Mock opening a SolidWorks model.

Parameters:

Name	Type	Description	Default
`file_path`	`str`	Path to the target file.	required

Returns:

Type	Description
`AdapterResult[SolidWorksModel]`	AdapterResult[SolidWorksModel]: The result produced by the operation.

Raises:

Type	Description
`SolidWorksOperationError`	Simulated adapter failure.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Mock opening a SolidWorks model.

    Args:
        file_path (str): Path to the target file.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.

    Raises:
        SolidWorksOperationError: Simulated adapter failure.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    if self._simulate_errors:
        raise SolidWorksOperationError("Simulated adapter failure")

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    # Determine model type from file extension
    file_path_lower = file_path.lower()
    if file_path_lower.endswith(".sldprt"):
        model_type = "Part"
    elif file_path_lower.endswith(".sldasm"):
        model_type = "Assembly"
    elif file_path_lower.endswith(".slddrw"):
        model_type = "Drawing"
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Unsupported file type: {file_path}",
        )

    # Create mock model
    model_name = file_path.split("/")[-1].split("\\")[-1]
    model = SolidWorksModel(
        path=file_path,
        name=model_name,
        type=model_type,
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "model_id": model_name or f"Part{len(self._models) + 1}",
            "file_size": random.randint(100000, 5000000),
        },
    )

    self._current_model = model
    self._models[file_path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

pack_and_go_assembly `async` ¶

pack_and_go_assembly(source_path: str, target_dir: str) -> AdapterResult[dict]

Mock Pack-and-Go: simulate copying an assembly to a target directory.

Parameters:

Name	Type	Description	Default
`source_path`	`str`	Path to the source .sldasm file.	required
`target_dir`	`str`	Directory to copy files into.	required

Returns:

Type	Description
`AdapterResult[dict]`	AdapterResult[dict]: Simulated pack-and-go result.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def pack_and_go_assembly(
    self,
    source_path: str,
    target_dir: str,
) -> AdapterResult[dict]:
    """Mock Pack-and-Go: simulate copying an assembly to a target directory.

    Args:
        source_path (str): Path to the source .sldasm file.
        target_dir (str): Directory to copy files into.

    Returns:
        AdapterResult[dict]: Simulated pack-and-go result.
    """
    import pathlib

    await asyncio.sleep(0.05)
    self._operation_count += 1

    source = pathlib.Path(source_path)
    out_dir = pathlib.Path(target_dir)
    mock_parts = [f"MockPart{i}.SLDPRT" for i in range(1, 3)]
    source_files = [str(source)] + [str(source.parent / p) for p in mock_parts]
    copied_files = [str(out_dir / source.name)] + [
        str(out_dir / p) for p in mock_parts
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "source_assembly": str(source),
            "target_dir": str(out_dir),
            "copied_files": copied_files,
            "source_files": source_files,
            "unsaved_changes": [],
        },
        execution_time=0.05,
        metadata={"mock": True},
    )

pattern_circular `async` ¶

pattern_circular(features: list[str], axis: str, count: int, angle: float = 360.0, equal_spacing: bool = True) -> AdapterResult[dict[str, Any]]

Mock patterning features around an axis.

The mock has no geometry engine, so it cannot measure a real volume change - it mirrors the live adapter's refusals instead of fabricating a result it cannot know (matching _pattern_circular_impl in solidworks/features.py verbatim for the three argument checks below). An axis name that was never created via create_axis in this session is rejected the same way SelectByID2 would fail to select it there.

On success, the tracked self._pattern_volume figure (seeded at the live-measured 48431.5 mm^3 hub+blade volume) grows by _PATTERN_BLADE_VOLUME * (count - 1), the live-derived per-instance volume, so volume_before/volume_after/volume_ratio stay self-consistent and scale with count roughly the way adding more blades to the hub would - reproducing the live 48431.5 -> 75916.4 mm^3 measurement exactly for count=4.

Parameters:

Name	Type	Description	Default
`features`	`list[str]`	Names of the features to pattern.	required
`axis`	`str`	Name of the axis to rotate about.	required
`count`	`int`	Total number of instances including the original.	required
`angle`	`float`	Total angle in degrees to spread them over. Defaults to 360.0.	`360.0`
`equal_spacing`	`bool`	Space instances evenly across `angle`. Defaults to True.	`True`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The pattern's name, inputs and
`AdapterResult[dict[str, Any]]`	volume before/after, or error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def pattern_circular(
    self,
    features: list[str],
    axis: str,
    count: int,
    angle: float = 360.0,
    equal_spacing: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mock patterning features around an axis.

    The mock has no geometry engine, so it cannot measure a real volume
    change - it mirrors the live adapter's refusals instead of
    fabricating a result it cannot know (matching
    ``_pattern_circular_impl`` in ``solidworks/features.py`` verbatim
    for the three argument checks below). An axis name that was never
    created via ``create_axis`` in this session is rejected the same
    way ``SelectByID2`` would fail to select it there.

    On success, the tracked ``self._pattern_volume`` figure (seeded at
    the live-measured 48431.5 mm^3 hub+blade volume) grows by
    ``_PATTERN_BLADE_VOLUME * (count - 1)``, the live-derived
    per-instance volume, so volume_before/volume_after/volume_ratio
    stay self-consistent and scale with ``count`` roughly the way
    adding more blades to the hub would - reproducing the live
    48431.5 -> 75916.4 mm^3 measurement exactly for ``count=4``.

    Args:
        features (list[str]): Names of the features to pattern.
        axis (str): Name of the axis to rotate about.
        count (int): Total number of instances including the original.
        angle (float): Total angle in degrees to spread them over. Defaults to 360.0.
        equal_spacing (bool): Space instances evenly across ``angle``. Defaults to True.

    Returns:
        AdapterResult[dict[str, Any]]: The pattern's name, inputs and
        volume before/after, or error.
    """
    names = [n for n in (features or []) if n]
    if not names:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="pattern_circular requires at least one feature name",
        )
    if not axis:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="pattern_circular requires an axis name to rotate about",
        )
    if int(count) < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"pattern_circular needs a count of at least 2 (got {count}); "
                "a pattern of one is just the original feature"
            ),
        )

    known_axes = set(self._axes)
    if axis not in known_axes:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Failed to select axis '{axis}'. Create one with "
                "create_axis first, and pass the name it returns."
            ),
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    volume_before = self._pattern_volume
    volume_after = volume_before + self._PATTERN_BLADE_VOLUME * (int(count) - 1)
    self._pattern_volume = volume_after

    self._feature_tree_count += 1
    pattern_name = f"CirPattern{self._feature_tree_count}"

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": pattern_name,
            "patterned": names,
            "axis": axis,
            "count": int(count),
            "angle": float(angle),
            "equal_spacing": bool(equal_spacing),
            "volume_before": volume_before,
            "volume_after": volume_after,
            "volume_change": volume_after - volume_before,
            "volume_ratio": round(volume_after / volume_before, 6),
        },
        execution_time=self._delays["feature_operation"],
    )

rebuild_model `async` ¶

rebuild_model(top_level_only: bool = False) -> AdapterResult[dict[str, Any]]

Mock rebuild with the real adapter's diagnostics contract.

Clean by default; issues placed in injected_rebuild_issues are explained with the same rebuild_diagnostics logic the real adapter uses, so ERROR-with-data / warnings-only behave identically.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def rebuild_model(
    self, top_level_only: bool = False
) -> AdapterResult[dict[str, Any]]:
    """Mock rebuild with the real adapter's diagnostics contract.

    Clean by default; issues placed in ``injected_rebuild_issues`` are
    explained with the same ``rebuild_diagnostics`` logic the real
    adapter uses, so ERROR-with-data / warnings-only behave identically.
    """
    from .solidworks.rebuild_diagnostics import explain, summarize

    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    await asyncio.sleep(self._delays["model_operation"] / 4)
    entries = [explain(i) for i in self.injected_rebuild_issues]
    error_count, warning_count, summary = summarize(entries)
    data = {
        "rebuilt": True,
        "top_level_only": top_level_only,
        "errors": entries,
        "error_count": error_count,
        "warning_count": warning_count,
        "summary": summary,
    }
    return AdapterResult(
        status=(
            AdapterResultStatus.ERROR
            if error_count
            else AdapterResultStatus.SUCCESS
        ),
        data=data,
        error=summary if error_count else None,
        execution_time=self._delays["model_operation"] / 4,
    )

rename_feature `async` ¶

rename_feature(old_name: str, new_name: str) -> AdapterResult[dict[str, Any]]

Mock renaming a named feature in the active model.

Mirrors the real adapter: an empty target name, an unknown feature, or a target name already in use are all errors; renaming to the current name is a no-op success.

Parameters:

Name	Type	Description	Default
`old_name`	`str`	Current feature name.	required
`new_name`	`str`	New feature name.	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def rename_feature(
    self, old_name: str, new_name: str
) -> AdapterResult[dict[str, Any]]:
    """Mock renaming a named feature in the active model.

    Mirrors the real adapter: an empty target name, an unknown feature, or
    a target name already in use are all errors; renaming to the current
    name is a no-op success.

    Args:
        old_name (str): Current feature name.
        new_name (str): New feature name.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])

    new = new_name.split("@", 1)[0].strip()
    if not new:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="new_name must not be empty"
        )

    if old_name in self._sketches and new != old_name:
        return self._mock_rename_sketch(old_name, new)
    key = next((k for k, f in self._features.items() if f.name == old_name), None)
    if key is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Feature not found: {old_name}",
        )
    if new == old_name:
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data={
                "renamed": False,
                "old_name": old_name,
                "new_name": new,
                "reason": "old and new names are the same",
            },
            execution_time=self._delays["model_operation"],
        )
    if any(f.name == new for f in self._features.values()):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Cannot rename to '{new}': a feature with that name already exists"
            ),
        )

    self._features[key].name = new
    if old_name in self._suppressed_features:
        self._suppressed_features.discard(old_name)
        self._suppressed_features.add(new)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"renamed": True, "old_name": old_name, "new_name": new},
        execution_time=self._delays["model_operation"],
    )

save_body_as_part `async` ¶

save_body_as_part(body_name: str, file_path: str) -> AdapterResult[dict[str, Any]]

Mock extracting a solid body from the active part to a new file.

The mock has no bodies, so it cannot validate body_name against real geometry - it mirrors the live adapter's other refusals (no model, not a part, blank arguments, missing parent directory) and, on a valid request, writes an empty placeholder file so callers and tests can observe the side effect.

Parameters:

Name	Type	Description	Default
`body_name`	`str`	Name of a solid body in the active part.	required
`file_path`	`str`	Absolute path for the new `.sldprt`.	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The body, the written path, and a
`AdapterResult[dict[str, Any]]`	single-element body list, or an error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def save_body_as_part(
    self, body_name: str, file_path: str
) -> AdapterResult[dict[str, Any]]:
    """Mock extracting a solid body from the active part to a new file.

    The mock has no bodies, so it cannot validate ``body_name`` against
    real geometry - it mirrors the live adapter's other refusals (no
    model, not a part, blank arguments, missing parent directory) and, on
    a valid request, writes an empty placeholder file so callers and
    tests can observe the side effect.

    Args:
        body_name (str): Name of a solid body in the active part.
        file_path (str): Absolute path for the new ``.sldprt``.

    Returns:
        AdapterResult[dict[str, Any]]: The body, the written path, and a
        single-element body list, or an error.
    """
    import os as _os

    await asyncio.sleep(self._delays["model_operation"])

    model = self._current_model
    if model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if getattr(model, "type", None) != "Part":
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="save_body_as_part requires an active part document",
        )
    if not str(body_name or "").strip():
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="body_name is required"
        )
    target = str(file_path or "").strip()
    if not target:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="file_path is required"
        )
    target = _os.path.abspath(target)
    parent = _os.path.dirname(target)
    if not _os.path.isdir(parent):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Parent directory does not exist: {parent}",
        )

    with open(target, "w", encoding="utf-8"):
        pass
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "body": body_name,
            "file_path": target,
            "feature": f"Save Bodies{self._operation_count}",
            "solid_bodies": [body_name],
        },
        execution_time=self._delays["model_operation"],
    )

save_file `async` ¶

save_file(file_path: str | None = None) -> AdapterResult[dict[str, Any]]

Legacy compatibility save operation for tests.

Parameters:

Name	Type	Description	Default
`file_path`	`str \| None`	Path to the target file. Defaults to None.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def save_file(
    self, file_path: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Legacy compatibility save operation for tests.

    Args:
        file_path (str | None): Path to the target file. Defaults to None.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )
    await asyncio.sleep(0.02)
    self._operation_count += 1
    resolved_path = file_path or self._current_model.path
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"file_path": resolved_path, "saved": True},
        execution_time=0.02,
    )

select_face_edges `async` ¶

select_face_edges(point: list[float] | None = None, side: str | None = None, plane: str | None = None, edge_type: str = 'all', append: bool = False) -> AdapterResult[dict[str, Any]]

Mock face-edge multi-selection on a canned 10 mm block.

Mirrors the real adapter's contract: the same input validation, the same payload shape, and the same failure cases. The block spans 0..10 mm on every axis; the +Z/-Z faces carry a 2 mm radius hole rim once any circle has been sketched, so edge_type="circular" behaves like a real drilled part. Front Plane (z = 0) is the only reference plane with a face on it.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def select_face_edges(
    self,
    point: list[float] | None = None,
    side: str | None = None,
    plane: str | None = None,
    edge_type: str = "all",
    append: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Mock face-edge multi-selection on a canned 10 mm block.

    Mirrors the real adapter's contract: the same input validation, the
    same payload shape, and the same failure cases. The block spans
    0..10 mm on every axis; the +Z/-Z faces carry a 2 mm radius hole rim
    once any circle has been sketched, so ``edge_type="circular"``
    behaves like a real drilled part. ``Front Plane`` (z = 0) is the only
    reference plane with a face on it.
    """
    from .solidworks.face_selection import side_vector, validate_face_query

    problem = validate_face_query(point, side, plane, edge_type)
    if problem:
        return AdapterResult(status=AdapterResultStatus.ERROR, error=problem)
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if getattr(self._current_model, "type", "Part") != "Part":
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="select_face_edges requires an active part document.",
        )
    await asyncio.sleep(self._delays["feature_operation"] / 4)

    if point is not None:
        normal = self._mock_face_at(point)
        if normal is None:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=f"No face found at point {list(point)} mm.",
            )
    elif side is not None:
        normal = side_vector(side)
    elif plane == "Front Plane":
        normal = (0.0, 0.0, -1.0)
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"No body face lies on {plane!r}.",
        )

    center = [5.0 + 5.0 * c for c in normal]
    has_hole = any(e.startswith("Circle") for e in self._sketch_entity_ids)
    edges: list[dict[str, Any]] = [
        {"curve": "linear", "length_mm": 10.0, "face_index": 0} for _ in range(4)
    ]
    if has_hole and normal[2] != 0:
        edges.append(
            {
                "curve": "circular",
                "center_mm": [5.0, 5.0, center[2]],
                "axis": [0.0, 0.0, 1.0],
                "radius_mm": 2.0,
                "face_index": 0,
            }
        )
    edges = [e for e in edges if edge_type == "all" or e["curve"] == edge_type]
    if not edges:
        kind = "" if edge_type == "all" else f"{edge_type} "
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"The selected face has no {kind}edges (face centre {center} mm).",
        )

    if not append:
        self._selection.clear()
    self._selection.extend(f"Edge{i}" for i in range(len(edges)))
    face = {
        "index": 0,
        "center_mm": center,
        "normal": [float(c) for c in normal],
        "area_mm2": 100.0,
        "planar": True,
    }
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "face": face,
            "faces": [face],
            "edge_type": edge_type,
            "edges": edges,
            "selected_edges": len(edges),
            "selection_count": len(self._selection),
        },
        execution_time=self._delays["feature_operation"] / 4,
    )

select_feature `async` ¶

select_feature(feature_name: str, append: bool = False) -> AdapterResult[dict[str, Any]]

Mock feature selection, mirroring the real adapter's contract.

Succeeds only for names the mock is tracking for the active model (created features, sketches, default planes); anything else is an ERROR naming the feature - never SUCCESS with selected: False.

Parameters:

Name	Type	Description	Default
`feature_name`	`str`	The feature name, optionally `@doc` qualified.	required
`append`	`bool`	Add to the current selection. Defaults to False.	`False`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def select_feature(
    self, feature_name: str, append: bool = False
) -> AdapterResult[dict[str, Any]]:
    """Mock feature selection, mirroring the real adapter's contract.

    Succeeds only for names the mock is tracking for the active model
    (created features, sketches, default planes); anything else is an
    ERROR naming the feature - never SUCCESS with ``selected: False``.

    Args:
        feature_name (str): The feature name, optionally ``@doc`` qualified.
        append (bool): Add to the current selection. Defaults to False.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )
    await asyncio.sleep(self._delays["feature_operation"] / 4)
    self._operation_count += 1

    bare = feature_name.split("@", 1)[0].strip()
    known = (
        {f.name for f in self._features.values()}
        | set(self._sketches)
        | set(self._DEFAULT_SELECTABLE)
    )
    if bare not in known:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Feature not found or could not be selected: {feature_name}",
        )
    if not append:
        self._selection.clear()
    if bare not in self._selection:
        self._selection.append(bare)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "selected": True,
            "feature_name": feature_name,
            "selected_name": bare,
            "entity_type": "mock",
            "selection_count": len(self._selection),
        },
        execution_time=self._delays["feature_operation"] / 4,
    )

set_component_state `async` ¶

set_component_state(component: str, fixed: bool | None = None, flexible: bool | None = None) -> AdapterResult[dict[str, Any]]

Mock fixing, floating and flexing a component.

Tracks each component's state on self._component_states.

Parameters:

Name	Type	Description	Default
`component`	`str`	Instance name.	required
`fixed`	`bool \| None`	True fixes it, False floats it.	`None`
`flexible`	`bool \| None`	True flexible, False rigid.	`None`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The state before and after.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_component_state(
    self,
    component: str,
    fixed: bool | None = None,
    flexible: bool | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock fixing, floating and flexing a component.

    Tracks each component's state on ``self._component_states``.

    Args:
        component (str): Instance name.
        fixed (bool | None): True fixes it, False floats it.
        flexible (bool | None): True flexible, False rigid.

    Returns:
        AdapterResult[dict[str, Any]]: The state before and after.
    """
    if fixed is None and flexible is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="Nothing to change: give fixed, flexible or both.",
        )
    states = self._component_states
    before = dict(states.get(component, {"fixed": False, "flexible": False}))
    after = dict(before)
    if fixed is not None:
        after["fixed"] = fixed
    if flexible is not None:
        after["flexible"] = flexible
    states[component] = after
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"component": component, "before": before, "after": after},
    )

set_custom_property `async` ¶

set_custom_property(name: str, value: str, configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock writing one custom property.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_custom_property(
    self, name: str, value: str, configuration: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock writing one custom property."""
    if self._current_model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if not name.strip():
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="name is required"
        )
    if not hasattr(self, "_custom_properties"):
        self._custom_properties: dict[tuple[str, str], dict[str, str]] = {}
    key = (self._mock_doc_key(), configuration or "")
    self._custom_properties.setdefault(key, {})[name] = str(value)
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": name,
            "value": str(value),
            "resolved": str(value),
            "configuration": configuration or "",
        },
    )

set_dimension `async` ¶

set_dimension(name: str, value: float) -> AdapterResult[None]

Mock setting a dimension value.

Parameters:

Name	Type	Description	Default
`name`	`str`	The name value.	required
`value`	`float`	The value value.	required

Returns:

Type	Description
`AdapterResult[None]`	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
    """Mock setting a dimension value.

    Args:
        name (str): The name value.
        value (float): The value value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    await asyncio.sleep(0.1)  # Fast operation
    self._operation_count += 1

    self._dimensions[name] = value

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS, data=None, execution_time=0.1
    )

set_material `async` ¶

set_material(material_name: str, database: str | None = None, configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock assigning a material; unknown names fail as they do live.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_material(
    self,
    material_name: str,
    database: str | None = None,
    configuration: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock assigning a material; unknown names fail as they do live."""
    guard = self._mock_doc_error({"Part"}, "set_material")
    if guard is not None:
        return guard
    wanted = material_name.strip().lower()
    match = next(
        (m for m in self._MOCK_MATERIALS if m["name"].lower() == wanted), None
    )
    if match is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Material {material_name!r} not found in "
                f"{database or 'SOLIDWORKS Materials'!r}; use "
                "list_available_materials for the exact name and library."
            ),
        )
    if not hasattr(self, "_materials"):
        self._materials: dict[str, dict[str, str]] = {}
    self._materials[self._mock_doc_key()] = match
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "material": match["name"],
            "database": database or "SOLIDWORKS Materials",
            "configuration": configuration,
        },
    )

set_sheet_scale `async` ¶

set_sheet_scale(numerator: float, denominator: float) -> AdapterResult[dict[str, Any]]

Mock setting the sheet scale.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_sheet_scale(
    self, numerator: float, denominator: float
) -> AdapterResult[dict[str, Any]]:
    """Mock setting the sheet scale."""
    guard = self._mock_doc_error({"Drawing"}, "set_sheet_scale")
    if guard is not None:
        return guard
    if numerator <= 0 or denominator <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Scale values must be positive"
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "sheet": "Sheet1",
            "scale": f"{numerator:g}:{denominator:g}",
            "requested": f"{numerator:g}:{denominator:g}",
        },
    )

set_units `async` ¶

set_units(unit_system: str) -> AdapterResult[dict[str, Any]]

Mock setting the active document's linear unit system.

Mirrors the real adapter: an unrecognised token is an error, and the applied token is recorded on the current model's properties.

Parameters:

Name	Type	Description	Default
`unit_system`	`str`	One of `mm`, `cm`, `m`, `in`, `ft` (aliases such as `inch` / `millimeters` accepted).	required

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_units(self, unit_system: str) -> AdapterResult[dict[str, Any]]:
    """Mock setting the active document's linear unit system.

    Mirrors the real adapter: an unrecognised token is an error, and the
    applied token is recorded on the current model's ``properties``.

    Args:
        unit_system (str): One of ``mm``, ``cm``, ``m``, ``in``, ``ft``
            (aliases such as ``inch`` / ``millimeters`` accepted).

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(0.1)

    token = _normalise_mock_unit_system(unit_system)
    if token is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unrecognised unit system {unit_system!r}. "
                "Expected one of: mm, cm, m, in, ft."
            ),
        )
    if self._current_model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    self._operation_count += 1
    props = dict(self._current_model.properties or {})
    props["units"] = token
    self._current_model.properties = props

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"unit_system": token, "verified": True},
        execution_time=0.1,
    )

sketch_circular_pattern `async` ¶

sketch_circular_pattern(entities: list[str], angle: float, count: int) -> AdapterResult[str]

Mock creating a circular sketch pattern around the sketch origin.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	Seed entity IDs.	required
`angle`	`float`	Total swept angle in degrees.	required
`count`	`int`	Total number of instances (including the seed).	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_circular_pattern(
    self,
    entities: list[str],
    angle: float,
    count: int,
) -> AdapterResult[str]:
    """Mock creating a circular sketch pattern around the sketch origin.

    Args:
        entities (list[str]): Seed entity IDs.
        angle (float): Total swept angle in degrees.
        count (int): Total number of instances (including the seed).

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_circular_pattern requires at least one entity",
        )
    if count < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_circular_pattern requires count >= 2",
        )
    if angle <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_circular_pattern requires angle > 0",
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    pattern_id = f"CircularPattern_{count}x{angle}deg_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=pattern_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

sketch_linear_pattern `async` ¶

sketch_linear_pattern(entities: list[str], direction_x: float, direction_y: float, spacing: float, count: int) -> AdapterResult[str]

Mock creating a linear sketch pattern.

Mirrors the real adapter's validation rules — empty entities, count < 2, non-positive spacing, and a zero direction vector each produce a clear error without "creating" a pattern.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	Seed entity IDs.	required
`direction_x`	`float`	Pattern direction X component.	required
`direction_y`	`float`	Pattern direction Y component.	required
`spacing`	`float`	Distance between instances in millimetres.	required
`count`	`int`	Total number of instances (including the seed).	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_linear_pattern(
    self,
    entities: list[str],
    direction_x: float,
    direction_y: float,
    spacing: float,
    count: int,
) -> AdapterResult[str]:
    """Mock creating a linear sketch pattern.

    Mirrors the real adapter's validation rules — empty entities,
    count < 2, non-positive spacing, and a zero direction vector each
    produce a clear error without "creating" a pattern.

    Args:
        entities (list[str]): Seed entity IDs.
        direction_x (float): Pattern direction X component.
        direction_y (float): Pattern direction Y component.
        spacing (float): Distance between instances in millimetres.
        count (int): Total number of instances (including the seed).

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_linear_pattern requires at least one entity",
        )
    if count < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_linear_pattern requires count >= 2",
        )
    if spacing <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_linear_pattern requires spacing > 0",
        )
    if math.hypot(direction_x, direction_y) < 1e-9:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=("sketch_linear_pattern requires a non-zero direction vector"),
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    pattern_id = f"LinearPattern_{count}x{spacing}_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=pattern_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

sketch_mirror `async` ¶

sketch_mirror(entities: list[str], mirror_line: str) -> AdapterResult[str]

Mock mirroring sketch entities about a centerline.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	IDs of segments to mirror.	required
`mirror_line`	`str`	ID of the centerline to mirror across.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_mirror(
    self, entities: list[str], mirror_line: str
) -> AdapterResult[str]:
    """Mock mirroring sketch entities about a centerline.

    Args:
        entities (list[str]): IDs of segments to mirror.
        mirror_line (str): ID of the centerline to mirror across.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_mirror requires at least one entity",
        )
    if not mirror_line:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "sketch_mirror requires a mirror_line entity ID (add_centerline)"
            ),
        )
    if mirror_line not in self._sketch_entity_ids:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown mirror_line entity '{mirror_line}'. Use the "
                "ID returned by add_centerline."
            ),
        )
    # Mirror the real adapter — IModelDoc2::SketchMirror needs a
    # centreline as the mirror axis; other segments silently no-op.
    if not mirror_line.startswith("Centerline_"):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"mirror_line must be a centerline (from add_centerline), "
                f"got '{mirror_line}'"
            ),
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    mirror_id = f"Mirror_{mirror_line}_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=mirror_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

sketch_offset `async` ¶

sketch_offset(entities: list[str], offset_distance: float, reverse_direction: bool) -> AdapterResult[str]

Mock offsetting sketch entities by a fixed distance.

Parameters:

Name	Type	Description	Default
`entities`	`list[str]`	IDs of segments to offset.	required
`offset_distance`	`float`	Distance in millimetres. Must be > 0.	required
`reverse_direction`	`bool`	Flip the offset direction.	required

Returns:

Type	Description
`AdapterResult[str]`	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_offset(
    self,
    entities: list[str],
    offset_distance: float,
    reverse_direction: bool,
) -> AdapterResult[str]:
    """Mock offsetting sketch entities by a fixed distance.

    Args:
        entities (list[str]): IDs of segments to offset.
        offset_distance (float): Distance in millimetres. Must be > 0.
        reverse_direction (bool): Flip the offset direction.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_offset requires at least one entity",
        )
    if offset_distance <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "sketch_offset requires offset_distance > 0 — use "
                "reverse_direction to flip the side"
            ),
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    direction = "inward" if reverse_direction else "outward"
    offset_id = f"Offset_{offset_distance}_{direction}_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=offset_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

suppress_feature `async` ¶

suppress_feature(name: str, suppress: bool = True) -> AdapterResult[dict[str, Any]]

Mock suppressing or unsuppressing a named feature.

Parameters:

Name	Type	Description	Default
`name`	`str`	Feature name.	required
`suppress`	`bool`	True to suppress, False to unsuppress.	`True`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def suppress_feature(
    self, name: str, suppress: bool = True
) -> AdapterResult[dict[str, Any]]:
    """Mock suppressing or unsuppressing a named feature.

    Args:
        name (str): Feature name.
        suppress (bool): True to suppress, False to unsuppress.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])

    known = any(f.name == name for f in self._features.values())
    if not known:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error=f"Feature not found: {name}"
        )

    was = name in self._suppressed_features
    if suppress:
        self._suppressed_features.add(name)
    else:
        self._suppressed_features.discard(name)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "feature": name,
            "requested": suppress,
            "suppressed": bool(suppress),
            "was_suppressed": was,
        },
        execution_time=self._delays["model_operation"],
    )

undo `async` ¶

undo(count: int = 1) -> AdapterResult[dict[str, Any]]

Mock undoing the last operations in the active model.

Removes the most recently added features, mirroring what an undo of feature-creation steps does to the tree. tree_changed is False when there was nothing left to undo, which is what the real adapter reports too - SolidWorks accepts an undo on an empty stack quietly.

Parameters:

Name	Type	Description	Default
`count`	`int`	Number of steps to undo.	`1`

Returns:

Type	Description
`AdapterResult[dict[str, Any]]`	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def undo(self, count: int = 1) -> AdapterResult[dict[str, Any]]:
    """Mock undoing the last operations in the active model.

    Removes the most recently added features, mirroring what an undo of
    feature-creation steps does to the tree. ``tree_changed`` is ``False``
    when there was nothing left to undo, which is what the real adapter
    reports too - SolidWorks accepts an undo on an empty stack quietly.

    Args:
        count (int): Number of steps to undo.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    steps = max(1, int(count))

    keys = list(self._features)
    before = [self._features[k].name for k in keys]
    doomed = keys[-steps:] if steps <= len(keys) else list(keys)
    removed = [self._features[k].name for k in doomed]
    for key in doomed:
        self._suppressed_features.discard(self._features[key].name)
        del self._features[key]
    self._operation_count += 1
    after = [f.name for f in self._features.values()]

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "requested_steps": steps,
            "features_before": len(before),
            "features_after": len(after),
            "removed_features": removed,
            "tree_changed": before != after,
        },
        execution_time=self._delays["model_operation"],
    )

Snapshot `dataclass` ¶

Snapshot(type_library: str, interfaces: Mapping[str, frozenset[str]])

The type library's interface and method names.

Attributes:

Name	Type	Description
`type_library`	`str`	Where it came from (the gen_py wrapper's name).
`interfaces`	`Mapping[str, frozenset[str]]`	Interface name to its method names.

Methods:¶

from_json `classmethod` ¶

from_json(text: str) -> Snapshot

Read a snapshot written by :meth:to_json.

Parameters:

Name	Type	Description	Default
`text`	`str`	The JSON text.	required

Returns:

Name	Type	Description
`Snapshot`	`Snapshot`	The parsed snapshot.

Source code in src/solidworks_mcp/progress/com_coverage.py

@classmethod
def from_json(cls, text: str) -> Snapshot:
    """Read a snapshot written by :meth:`to_json`.

    Args:
        text: The JSON text.

    Returns:
        Snapshot: The parsed snapshot.
    """
    raw = json.loads(text)
    return cls(
        raw["type_library"],
        {name: frozenset(methods) for name, methods in raw["interfaces"].items()},
    )

load `classmethod` ¶

load(path: Path) -> Snapshot

Read the committed snapshot file.

Parameters:

Name	Type	Description	Default
`path`	`Path`	The snapshot's path.	required

Returns:

Name	Type	Description
`Snapshot`	`Snapshot`	The parsed snapshot.

Source code in src/solidworks_mcp/progress/com_coverage.py

@classmethod
def load(cls, path: Path) -> Snapshot:
    """Read the committed snapshot file.

    Args:
        path: The snapshot's path.

    Returns:
        Snapshot: The parsed snapshot.
    """
    return cls.from_json(path.read_text(encoding="utf-8"))

to_json ¶

to_json() -> str

The snapshot as committed: sorted, one interface per line.

Returns:

Name	Type	Description
`str`	`str`	JSON text ending in a newline.

Source code in src/solidworks_mcp/progress/com_coverage.py

def to_json(self) -> str:
    """The snapshot as committed: sorted, one interface per line.

    Returns:
        str: JSON text ending in a newline.
    """
    lines = [
        f"  {json.dumps(name)}: {json.dumps(sorted(methods))}"
        for name, methods in sorted(self.interfaces.items())
    ]
    body = ",\n".join(lines)
    return (
        f'{{\n "type_library": {json.dumps(self.type_library)},\n'
        f' "interfaces": {{\n{body}\n }}\n}}\n'
    )

SupportLevel ¶

Bases: StrEnum

The four support levels, most trusted first.

ToolRow `dataclass` ¶

ToolRow(name: str, family: str, level: SupportLevel, reason: str, summary: str)

One registered tool, as the progress page lists it.

Attributes:

Name	Type	Description
`name`	`str`	The tool name.
`family`	`str`	Its family (the module that defines it).
`level`	`SupportLevel`	Its support level.
`reason`	`str`	Why it isn't stable (empty when it is).
`summary`	`str`	The first paragraph of its docstring.

Functions:¶

adapter_sources ¶

adapter_sources(adapters_dir: Path) -> list[str]

The text of every Python file under the adapters package.

Parameters:

Name	Type	Description	Default
`adapters_dir`	`Path`	`src/solidworks_mcp/adapters`.	required

Returns:

Type	Description
`list[str]`	list[str]: One string per file, in path order.

Source code in src/solidworks_mcp/progress/com_coverage.py

def adapter_sources(adapters_dir: Path) -> list[str]:
    """The text of every Python file under the adapters package.

    Args:
        adapters_dir: ``src/solidworks_mcp/adapters``.

    Returns:
        list[str]: One string per file, in path order.
    """
    return [p.read_text(encoding="utf-8") for p in sorted(adapters_dir.rglob("*.py"))]

build ¶

build(root: Path) -> dict[str, str]

Every generated file's content, from the code under root.

Parameters:

Name	Type	Description	Default
`root`	`Path`	The repository root.	required

Returns:

Type	Description
`dict[str, str]`	dict[str, str]: File name (in `OUTPUT_DIR`) to content.

Source code in src/solidworks_mcp/progress/generate.py

def build(root: Path) -> dict[str, str]:
    """Every generated file's content, from the code under ``root``.

    Args:
        root: The repository root.

    Returns:
        dict[str, str]: File name (in ``OUTPUT_DIR``) to content.
    """
    rows = asyncio.run(tool_rows())
    coverage = measure(
        Snapshot.load(root / SNAPSHOT_PATH),
        called_names(adapter_sources(root / "src/solidworks_mcp/adapters")),
    )
    counts = Counter(r.level for r in rows)
    return {
        "progress.svg": render(counts, coverage),
        "progress.json": progress_json(rows, coverage),
        "tables.html": tables_html(rows, coverage),
    }

called_names ¶

called_names(sources: Iterable[str]) -> set[str]

Capitalised names the source uses as attributes or string literals.

Parameters:

Name	Type	Description	Default
`sources`	`Iterable[str]`	The text of each source file.	required

Returns:

Type	Description
`set[str]`	set[str]: Candidate COM member names (not yet matched to the API).

Source code in src/solidworks_mcp/progress/com_coverage.py

def called_names(sources: Iterable[str]) -> set[str]:
    """Capitalised names the source uses as attributes or string literals.

    Args:
        sources: The text of each source file.

    Returns:
        set[str]: Candidate COM member names (not yet matched to the API).
    """
    found: set[str] = set()
    for text in sources:
        found.update(_ATTRIBUTE.findall(text))
        found.update(_QUOTED.findall(text))
    return found

main ¶

main(root: Path | None = None) -> list[Path]

Write the generated files under root.

Parameters:

Name	Type	Description	Default
`root`	`Path \| None`	The repository root; the current directory when omitted.	`None`

Returns:

Type	Description
`list[Path]`	list[Path]: The files written.

Source code in src/solidworks_mcp/progress/generate.py

def main(root: Path | None = None) -> list[Path]:
    """Write the generated files under ``root``.

    Args:
        root: The repository root; the current directory when omitted.

    Returns:
        list[Path]: The files written.
    """
    base = root or Path.cwd()
    written = []
    for name, content in build(base).items():
        path = base / OUTPUT_DIR / name
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(content, encoding="utf-8", newline="\n")
        written.append(path)
    return written

measure ¶

measure(snapshot: Snapshot, called: set[str]) -> ComCoverage

Coverage of the core interfaces and the whole API.

Parameters:

Name	Type	Description	Default
`snapshot`	`Snapshot`	The type library's names.	required
`called`	`set[str]`	Names found in the adapter source.	required

Returns:

Name	Type	Description
`ComCoverage`	`ComCoverage`	The counts.

Source code in src/solidworks_mcp/progress/com_coverage.py

def measure(snapshot: Snapshot, called: set[str]) -> ComCoverage:
    """Coverage of the core interfaces and the whole API.

    Args:
        snapshot: The type library's names.
        called: Names found in the adapter source.

    Returns:
        ComCoverage: The counts.
    """
    every = set().union(*snapshot.interfaces.values())
    interfaces = tuple(
        InterfaceCoverage(
            name,
            tuple(sorted(snapshot.interfaces.get(name, frozenset()) & called)),
            len(snapshot.interfaces.get(name, frozenset())),
        )
        for name in CORE_INTERFACES
    )
    return ComCoverage(
        interfaces, len(every & called), len(every), snapshot.type_library
    )

progress_json ¶

progress_json(rows: list[ToolRow], coverage: ComCoverage) -> str

The data behind the image and the page.

Parameters:

Name	Type	Description	Default
`rows`	`list[ToolRow]`	Every tool.	required
`coverage`	`ComCoverage`	The COM coverage.	required

Returns:

Name	Type	Description
`str`	`str`	JSON text ending in a newline.

Source code in src/solidworks_mcp/progress/generate.py

def progress_json(rows: list[ToolRow], coverage: ComCoverage) -> str:
    """The data behind the image and the page.

    Args:
        rows: Every tool.
        coverage: The COM coverage.

    Returns:
        str: JSON text ending in a newline.
    """
    counts = Counter(r.level for r in rows)
    data: dict[str, Any] = {
        "tools": {
            "total": len(rows),
            "by_level": {level.value: counts[level] for level in SupportLevel},
            "list": [
                {
                    "name": r.name,
                    "family": r.family,
                    "level": r.level.value,
                    "reason": r.reason,
                    "summary": r.summary,
                }
                for r in rows
            ],
        },
        "com": {
            "type_library": coverage.type_library,
            "core": {"covered": coverage.core_covered, "total": coverage.core_total},
            "api": {"covered": coverage.api_covered, "total": coverage.api_total},
            "interfaces": [
                {"name": i.name, "covered": list(i.covered), "total": i.total}
                for i in coverage.interfaces
            ],
        },
    }
    return json.dumps(data, indent=1, ensure_ascii=False) + "\n"

register_tools `async` ¶

register_tools(mcp: FastMCP, adapter: Any, config: Any) -> int

Register all SolidWorks MCP tools.

Parameters:

Name	Type	Description	Default
`mcp`	`FastMCP`	The mcp value.	required
`adapter`	`Any`	Adapter instance used for the operation.	required
`config`	`Any`	Configuration values for the operation.	required

Returns:

Name	Type	Description
`int`	`int`	The computed numeric result.

Source code in src/solidworks_mcp/tools/__init__.py

async def register_tools(mcp: FastMCP, adapter: Any, config: Any) -> int:
    """Register all SolidWorks MCP tools.

    Args:
        mcp (FastMCP): The mcp value.
        adapter (Any): Adapter instance used for the operation.
        config (Any): Configuration values for the operation.

    Returns:
        int: The computed numeric result.
    """
    logger.info("Registering SolidWorks MCP tools...")

    # Register tool categories
    await register_modeling_tools(mcp, adapter, config)
    await register_sketching_tools(mcp, adapter, config)
    await register_drawing_tools(mcp, adapter, config)
    await register_drawing_analysis_tools(mcp, adapter, config)
    await register_drawing_automation_tools(mcp, adapter, config)
    await register_engineering_data_tools(mcp, adapter, config)
    await register_analysis_tools(mcp, adapter, config)
    await register_export_tools(mcp, adapter, config)
    await register_automation_tools(mcp, adapter, config)
    await register_file_management_tools(mcp, adapter, config)
    await register_vba_generation_tools(mcp, adapter, config)
    await register_template_management_tools(mcp, adapter, config)
    await register_macro_recording_tools(mcp, adapter, config)
    await register_docs_discovery_tools(mcp, adapter, config)
    await register_server_admin_tools(mcp, adapter, config)

    tool_count = len(await mcp.list_tools())

    logger.info(f"Registered {tool_count} SolidWorks tools")
    return tool_count

render ¶

render(levels: Mapping[SupportLevel, int], coverage: ComCoverage) -> str

The progress image.

Parameters:

Name	Type	Description	Default
`levels`	`Mapping[SupportLevel, int]`	How many tools have each support level.	required
`coverage`	`ComCoverage`	COM coverage of the core interfaces and the whole API.	required

Returns:

Name	Type	Description
`str`	`str`	The SVG document.

Source code in src/solidworks_mcp/progress/svg.py

def render(levels: Mapping[SupportLevel, int], coverage: ComCoverage) -> str:
    """The progress image.

    Args:
        levels: How many tools have each support level.
        coverage: COM coverage of the core interfaces and the whole API.

    Returns:
        str: The SVG document.
    """
    total = sum(levels.values())
    y_tools, y_com = 54, 156
    out = [
        f'<svg xmlns="http://www.w3.org/2000/svg" width="{_WIDTH}" height="{_HEIGHT}" '
        f'viewBox="0 0 {_WIDTH} {_HEIGHT}" role="img" aria-label="Project progress">',
        _DEFS.format(
            x0=_X,
            x1=_X + _BAR_W,
            y1=y_tools,
            y2=y_com,
            w=_BAR_W,
            h=_BAR_H,
            r=_BAR_H / 2,
        ),
        f'<rect x=".5" y=".5" width="{_WIDTH - 1}" height="{_HEIGHT - 1}" rx="14" '
        'fill="url(#panel)" stroke="#30363d"/>',
    ]

    ready = levels.get(SupportLevel.STABLE, 0) + levels.get(SupportLevel.BETA, 0)
    out.append(_text(_X, 40, f"MCP tools: {total}", 16, "#e6edf3", weight="600"))
    out.append(
        _text(
            _X + _BAR_W,
            40,
            f"{_pct(ready, total):.0f}% work on SolidWorks today",
            13,
            "#8b949e",
            "end",
        )
    )
    fills, x = [], float(_X)
    for level in (SupportLevel.STABLE, SupportLevel.BETA, SupportLevel.EXPERIMENTAL):
        width = _BAR_W * levels.get(level, 0) / total if total else 0.0
        fills.append((x, width, LEVEL_COLOURS[level]))
        x += width
    out += _track(y_tools, "track-tools", fills)

    lx = float(_X)
    for level in SupportLevel:
        label = f"{level.value} {levels.get(level, 0)}"
        out.append(
            f'<rect x="{lx:g}" y="{y_tools + 38}" width="10" height="10" rx="2" '
            f'fill="{LEVEL_COLOURS[level]}"/>'
        )
        out.append(_text(lx + 16, y_tools + 47, label, 12, "#c9d1d9"))
        lx += 24 + 7.2 * len(label)

    core_pct = _pct(coverage.core_covered, coverage.core_total)
    out.append(
        _text(
            _X,
            y_com - 14,
            f"Core SolidWorks COM API ({len(CORE_INTERFACES)} interfaces)",
            16,
            "#e6edf3",
            weight="600",
        )
    )
    out.append(
        _text(
            _X + _BAR_W,
            y_com - 14,
            f"{coverage.core_covered:,} of {coverage.core_total:,} methods · {core_pct:.1f}%",
            13,
            "#8b949e",
            "end",
        )
    )
    out += _track(
        y_com, "track-com", [(float(_X), _BAR_W * core_pct / 100, "url(#heat)")]
    )
    api_pct = _pct(coverage.api_covered, coverage.api_total)
    out.append(
        _text(
            _X,
            y_com + 50,
            f"Whole API: {coverage.api_covered:,} of {coverage.api_total:,} method "
            f"names ({api_pct:.1f}%), counted by a text scan of the adapters.",
            11,
            "#6e7681",
        )
    )
    out.append("</svg>")
    return "\n".join(out) + "\n"

tables_html ¶

tables_html(rows: list[ToolRow], coverage: ComCoverage) -> str

The page's two tables, as HTML the docs page includes.

Each tool row carries data-level and data-family for the filter script, and its level as text as well as colour.

Parameters:

Name	Type	Description	Default
`rows`	`list[ToolRow]`	Every tool.	required
`coverage`	`ComCoverage`	The COM coverage.	required

Returns:

Name	Type	Description
`str`	`str`	The HTML.

Source code in src/solidworks_mcp/progress/generate.py

def tables_html(rows: list[ToolRow], coverage: ComCoverage) -> str:
    """The page's two tables, as HTML the docs page includes.

    Each tool row carries ``data-level`` and ``data-family`` for the filter
    script, and its level as text as well as colour.

    Args:
        rows: Every tool.
        coverage: The COM coverage.

    Returns:
        str: The HTML.
    """
    out = [
        _WRAP_OPEN,
        '<table data-progress="tools">',
        "<thead><tr><th>Tool</th><th>Family</th><th>Level</th>"
        "<th>What it does</th></tr></thead>",
        "<tbody>",
    ]
    for r in rows:
        note = f"<br><small>{escape(r.reason)}</small>" if r.reason else ""
        out.append(
            f'<tr data-level="{r.level.value}" data-family="{r.family}">'
            f'<td title="{escape(r.summary)}"><code>{r.name}</code></td>'
            f"<td>{r.family}</td>"
            f'<td><span class="level level-{r.level.value}">{r.level.value}</span>'
            f"{note}</td><td>{escape(r.summary)}</td></tr>"
        )
    out += ["</tbody>", "</table>", _WRAP_CLOSE, ""]
    out += [
        _WRAP_OPEN,
        '<table data-progress="com">',
        "<thead><tr><th>Interface</th><th>Methods called</th><th>Of</th>"
        "<th>Called</th></tr></thead>",
        "<tbody>",
    ]
    for i in coverage.interfaces:
        pct = 100.0 * len(i.covered) / i.total if i.total else 0.0
        names = ", ".join(i.covered)
        out.append(
            f"<tr><td><code>{i.name}</code></td><td>{len(i.covered)}</td>"
            f"<td>{i.total}</td><td><details><summary>{pct:.1f}%</summary>"
            f"<small>{escape(names) or 'none yet'}</small></details></td></tr>"
        )
    out += ["</tbody>", "</table>", _WRAP_CLOSE, ""]
    return "\n".join(out)

tool_family ¶

tool_family(fn: Callable[..., Any]) -> str

The family tag of a tool: the name of the module that defines it.

Parameters:

Name	Type	Description	Default
`fn`	`Callable[..., Any]`	The tool function.	required

Returns:

Name	Type	Description
`str`	`str`	The module's last dotted part, e.g. `"modeling"`.

Source code in src/solidworks_mcp/tools/tool_boundary.py

def tool_family(fn: Callable[..., Any]) -> str:
    """The family tag of a tool: the name of the module that defines it.

    Args:
        fn: The tool function.

    Returns:
        str: The module's last dotted part, e.g. ``"modeling"``.
    """
    return fn.__module__.rsplit(".", 1)[-1]

tool_rows `async` ¶

tool_rows() -> list[ToolRow]

Every registered tool, sorted by name.

Returns:

Type	Description
`list[ToolRow]`	list[ToolRow]: One row per tool.

Source code in src/solidworks_mcp/progress/generate.py

async def tool_rows() -> list[ToolRow]:
    """Every registered tool, sorted by name.

    Returns:
        list[ToolRow]: One row per tool.
    """
    mcp = FastMCP("progress")
    await register_tools(mcp, MockSolidWorksAdapter({}), {})
    rows = []
    for tool in await mcp.list_tools():
        support = SUPPORT_LEVELS[tool.name]
        text = parse_docstring(tool.fn).description or ""
        rows.append(
            ToolRow(
                tool.name,
                tool_family(tool.fn),
                support.level,
                support.reason,
                " ".join(text.split("\n\n", 1)[0].split()),
            )
        )
    return sorted(rows, key=lambda r: r.name)

solidworks_mcp.progress.generate¶