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

solidworks_mcp/adapters/sw_feature_errors.py

@@ -0,0 +1,66 @@
+"""SolidWorks ``swFeatureError_e`` codes (GENERATED - do not edit).
+
+Generated by ``scripts/gen_sw_feature_errors.py`` from ``swconst.tlb``
+(SOLIDWORKS 3DEXPERIENCE R2026x). Regenerate after a SolidWorks upgrade.
+"""
+
+from __future__ import annotations
+
+SW_FEATURE_ERRORS: dict[int, str] = {
+    0: "swFeatureErrorNone",
+    1: "swFeatureErrorUnknown",
+    10: "swFeatureErrorFilletNoLoop",
+    11: "swFeatureErrorFilletNoFace",
+    12: "swFeatureErrorFilletInvalidRadius",
+    13: "swFeatureErrorFilletNoEdge",
+    14: "swFeatureErrorFilletModelGeometry",
+    15: "swFeatureErrorFilletRadiusTooSmall",
+    16: "swFeatureErrorFilletCannotExtend",
+    17: "swFeatureErrorFilletRadiusEliminateElement",
+    18: "swFeatureErrorFilletRadiusTooBig",
+    19: "swFeatureErrorFilletRadiusTooBig2",
+    30: "swFeatureErrorExtrusionDisjoint",
+    31: "swFeatureErrorExtrusionNoEndFound",
+    32: "swFeatureErrorExtrusionBadGeometricConditions",
+    33: "swFeatureErrorExtrusionCutContourOpenAndClosed",
+    34: "swFeatureErrorExtrusionCutContourInvalid",
+    35: "swFeatureErrorExtrusionOpenCutContourInvalid",
+    36: "swFeatureErrorExtrusionBossContourOpenAndClosed",
+    37: "swFeatureErrorExtrusionBossContourInvalid",
+    38: "swFeatureErrorMateInvalidEdge",
+    39: "swFeatureErrorMateInvalidFace",
+    40: "swFeatureErrorMateFailedCreatingSurface",
+    41: "swFeatureErrorMateInvalidEntity",
+    42: "swFeatureErrorMateUnknownTangent",
+    43: "swFeatureErrorMateDanglingGeometry",
+    44: "swFeatureErrorMateEntityNotLinear",
+    45: "swFeatureErrorMateEntityFailed",
+    46: "swFeatureErrorMateOverdefined",
+    47: "swFeatureErrorMateIlldefined",
+    48: "swFeatureErrorMateBroken",
+    49: "swFeatureErrorFeatureDeprecated",
+    50: "swFeatureErrorFeatureObsolete",
+    51: "swSketchErrorExtRefFail",
+    52: "swFeatureErrorPartialEdgeFilletNoIntersection",
+    53: "swFeatureErrorPartialEdgeFilletUpdateFailed",
+    54: "swFeatureErrorPartialEdgeFilletNoPropagateEdges",
+    55: "swFeatureErrorPartialEdgeFilletNoStartEdge",
+    56: "swFeatureErrorPartialEdgeFilletNoEndEdge",
+    57: "swFeatureErrorPartialEdgeFilletNoMainEdge",
+    58: "swFeatureErrorPartialEdgeFilletOffsetTooBig",
+    59: "swFeatureErrorPartialEdgeFilletNoReferenceEntity",
+    60: "swFeatureErrorPartialEdgeFilletTooManyRefEntities",
+    61: "swFeatureErrorPartialEdgeFilletInvalidOffsetValue",
+    62: "swFeatureErrorPartialEdgeFilletCrossOverEndCondition",
+    63: "swFeatureErrorPartialEdgeFilletMissingReferenceEntity",
+    64: "swFeatureErrorPartialEdgeFilletInvalidReferenceEntity",
+    65: "swFeatureErrorPartialEdgeFilletNotSupported",
+    66: "swFeatureErrorPartialEdgeFilletNotSupportedForClosedLoop",
+    67: "swFeatureErrorPartialEdgeFilletMultiProjectionPoint",
+    68: "swFeatureErrorPartialEdgeFilletFailedToRepair",
+    69: "swFeatureErrorSweptFlangeInvalidProfileOrPath",
+    70: "swFeatureErrorSweptFlangeSelfIntersectingGeometry",
+    71: "swFeatureErrorCutNotIntersectModel",
+    72: "swFeatureErrorSketchContainsSelfIntersectingContour",
+    73: "swFeatureErrorMissingItemsInFeature",
+}

solidworks_mcp/adapters/sw_type_info.py

@@ -0,0 +1,317 @@
+"""
+SolidWorks type-library introspection for robust COM method resolution.
+
+Background: pywin32's late-binding (``CDispatch``) sometimes resolves SW
+zero-argument methods (``GetType``, ``GetTitle``, ``GetPathName``,
+``RevisionNumber`` …) as *properties* instead of methods. Calling them raises
+``TypeError: 'int'/'str' object is not callable`` because the property getter
+returns the value, and Python tries to call the value.
+
+Fix: call ``CDispatch._FlagAsMethod(name)`` for each method name **that actually
+belongs to the object's COM interface**. The calls tell pywin32 to resolve
+``name`` via method invocation (IDispatch ``Invoke``), not property access.
+
+This module:
+
+1. Loads the makepy-generated wrapper for ``sldworks.tlb`` (``gen_py``).
+2. Builds per-interface sets of method names (``ISldWorks``, ``IModelDoc2``,
+   ``IAssemblyDoc``, ``IPartDoc``, ``IDrawingDoc`` …).
+3. Exposes ``flag_methods(obj, *interfaces)`` to flag a dispatch in one shot.
+
+Why per-interface rather than flagging everything: flagging an unknown name
+triggers a COM ``GetIDsOfNames`` round-trip that fails with ``Unknown name.``.
+Those round-trips are ~5 ms each; the full SW TLB has ~6 000 method names
+across 482 interfaces, so a naive flag-everything approach costs ~30 s per
+object. Per-interface flagging is ~1-3 s.
+
+Fallback: if the gen_py wrapper is missing (e.g. fresh install on a new box),
+we attempt lazy generation via ``gencache.EnsureModule``. If that also fails,
+``flag_methods`` silently becomes a no-op; callers will fall back to the
+original ``TypeError`` symptom on affected methods, but everything else still
+works.
+"""
+
+from __future__ import annotations
+
+import inspect
+import weakref
+from typing import Any
+
+from loguru import logger
+
+try:
+    import win32com.client  # noqa: F401 — optional Windows dep
+    from win32com.client import DispatchBaseClass, gencache
+
+    PYWIN32_AVAILABLE = True
+except ImportError:
+    PYWIN32_AVAILABLE = False
+
+
+# SolidWorks type library IID (stable across SW versions).
+SW_TLB_IID = "{83A33D31-27C5-11CE-BFD4-00400513BB57}"
+
+# Module state: populated by _load_wrapper() the first time it's needed.
+_wrapper_module: Any | None = None
+_interface_methods: dict[str, frozenset[str]] = {}
+# Per-object record of which interfaces have already been flagged. Keyed by
+# id(obj) so ``flag_methods(doc, 'IModelDoc2')`` followed by
+# ``flag_methods(doc, 'IAssemblyDoc')`` does incremental work, not a no-op.
+# Value is (weak reference to the object, interfaces already flagged). The
+# weakref is what makes the id() key safe to trust — see _flagged_interfaces.
+_flag_cache: dict[int, tuple[weakref.ref[Any] | None, set[str]]] = {}
+
+
+def _load_wrapper() -> None:
+    """Load the gen_py wrapper and extract per-interface method names.
+
+    Tries ``GetModuleForTypelib`` first (fast path, no COM work), falls back
+    to ``EnsureModule`` (may trigger makepy generation), then gives up and
+    logs a warning. Probes common SW major versions (33..30) because the
+    minor/major numbers change per SW year.
+    """
+    global _wrapper_module, _interface_methods
+
+    # Try version numbers from newest to oldest. SW 3DEXPERIENCE R2026x = 34,
+    # SW 2025 = 33, SW 2024 = 32, SW 2023 = 31, SW 2022 = 30.
+    for major in (35, 34, 33, 32, 31, 30):
+        try:
+            mod = gencache.GetModuleForTypelib(SW_TLB_IID, 0, major, 0)
+        except Exception:
+            mod = None
+        if mod is not None:
+            _wrapper_module = mod
+            break
+
+    if _wrapper_module is None:
+        # Gen_py wrapper not generated yet — try to generate now.
+        for major in (35, 34, 33, 32, 31, 30):
+            try:
+                gencache.EnsureModule(SW_TLB_IID, 0, major, 0)
+                _wrapper_module = gencache.GetModuleForTypelib(SW_TLB_IID, 0, major, 0)
+                if _wrapper_module is not None:
+                    break
+            except Exception:
+                continue
+
+    if _wrapper_module is None:
+        logger.warning(
+            "SolidWorks gen_py wrapper not available; method flagging "
+            "disabled. Zero-arg SW methods may raise TypeError. To fix, "
+            "run: python -m win32com.client.makepy "
+            '"C:\\Program Files\\SOLIDWORKS Corp\\SOLIDWORKS\\sldworks.tlb"'
+        )
+        return
+
+    # Build per-interface method sets by inspecting each DispatchBaseClass
+    # subclass in the wrapper module.
+    for name in dir(_wrapper_module):
+        cls = getattr(_wrapper_module, name, None)
+        if not (inspect.isclass(cls) and issubclass(cls, DispatchBaseClass)):
+            continue
+        method_names: set[str] = set()
+        for attr_name, attr in vars(cls).items():
+            if attr_name.startswith("_"):
+                continue
+            if callable(attr):
+                method_names.add(attr_name)
+        if method_names:
+            _interface_methods[name] = frozenset(method_names)
+
+    logger.info(
+        f"SolidWorks type info loaded: {len(_interface_methods)} interfaces, "
+        f"wrapper={_wrapper_module.__name__}"
+    )
+
+
+def _ensure_loaded() -> None:
+    """Lazy-load the wrapper on first use."""
+    if _wrapper_module is None and PYWIN32_AVAILABLE:
+        _load_wrapper()
+
+
+def interface_method_names(interface: str) -> frozenset[str]:
+    """Return the set of method names declared by the given SW interface.
+
+    Args:
+        interface: Interface name as it appears in the type library
+            (e.g. ``"ISldWorks"``, ``"IModelDoc2"``).
+
+    Returns:
+        Immutable set of method names, or an empty set if the interface is
+        unknown or the wrapper isn't loaded.
+    """
+    _ensure_loaded()
+    return _interface_methods.get(interface, frozenset())
+
+
+# Interface sets most tool operations need to flag. When acquiring a doc
+# dispatch, always flag IModelDoc2 (base) plus the subclass that matches the
+# doc type. For the app root, flag ISldWorks.
+DOC_TYPE_TO_INTERFACES: dict[int, tuple[str, ...]] = {
+    # Values match swDocumentTypes_e: 1=Part, 2=Assembly, 3=Drawing
+    1: ("IModelDoc2", "IPartDoc"),
+    2: ("IModelDoc2", "IAssemblyDoc"),
+    3: ("IModelDoc2", "IDrawingDoc"),
+}
+
+
+def _flagged_interfaces(obj: Any) -> set[str]:
+    """Return the set of interfaces already flagged on ``obj``.
+
+    The entry is keyed by ``id(obj)`` for speed, but is only trusted when the
+    stored weak reference still resolves to *this same object*. Without that
+    check the cache is unsound: ids are only unique among live objects, and
+    CPython reuses addresses eagerly. A fresh dispatch landing on a dead one's
+    address was judged "already flagged", so ``flag_methods`` returned without
+    flagging anything and its members then resolved as properties — surfacing
+    from SolidWorks as "Member not found".
+
+    Objects that do not support weak references (some test doubles) simply are
+    not cached; they are flagged every time, which is correct if slower.
+    """
+    key = id(obj)
+    entry = _flag_cache.get(key)
+    if entry is not None:
+        ref, names = entry
+        if ref is None or ref() is obj:
+            return names
+        # Stale: the object this entry described is gone and its address has
+        # been recycled. Drop it and start fresh for the new occupant.
+        del _flag_cache[key]
+
+    names = set()
+    try:
+        _flag_cache[key] = (weakref.ref(obj), names)
+    except TypeError:
+        # Not weak-referenceable, so we cannot detect a later address reuse.
+        # Skip caching rather than risk the stale-entry bug.
+        pass
+    return names
+
+
+def flag_methods(obj: Any, *interfaces: str) -> int:
+    """Flag SW methods on ``obj`` so pywin32 dispatches them as methods,
+    not properties.
+
+    Safe to call repeatedly on the same object — results are cached by
+    ``id(obj)``. Unknown method names are silently skipped (those are
+    the ones that don't belong to the object's real interface).
+
+    Args:
+        obj: A pywin32 ``CDispatch`` wrapping a SolidWorks COM object.
+        *interfaces: One or more interface names whose methods to flag.
+            Common values: ``"ISldWorks"``, ``"IModelDoc2"``,
+            ``"IAssemblyDoc"``, ``"IPartDoc"``, ``"IDrawingDoc"``.
+
+    Returns:
+        Number of methods successfully flagged.
+    """
+    _ensure_loaded()
+
+    if not _interface_methods or obj is None:
+        return 0
+
+    already = _flagged_interfaces(obj)
+
+    # Only flag methods from interfaces we haven't already processed for
+    # this object. Repeats are a no-op; novel interfaces add incrementally.
+    new_interfaces = [i for i in interfaces if i not in already]
+    if not new_interfaces:
+        return 0
+
+    names: set[str] = set()
+    for iface in new_interfaces:
+        names.update(_interface_methods.get(iface, ()))
+
+    flagged = 0
+    for name in names:
+        try:
+            obj._FlagAsMethod(name)
+            flagged += 1
+        except Exception:
+            # Name not on this dispatch's real interface — skip silently.
+            pass
+
+    already.update(new_interfaces)
+    return flagged
+
+
+def flag_members(obj: Any, *names: str) -> int:
+    """Flag a specific handful of method names on ``obj``.
+
+    ``flag_methods`` flags *every* method of an interface — around 100 names
+    for ``IFeature`` — and its cache is keyed by ``id(obj)``, so a loop over
+    many short-lived dispatches (walking a feature tree, iterating components)
+    pays that cost once per object and never hits the cache.
+
+    When the caller knows exactly which members it is about to read, flagging
+    just those is far cheaper and behaves identically for them.
+
+    Args:
+        obj: A pywin32 ``CDispatch`` wrapping a SolidWorks COM object.
+        *names: Method names to flag.
+
+    Returns:
+        int: Number of names flagged.
+    """
+    if obj is None:
+        return 0
+
+    flagged_count = 0
+    for name in names:
+        try:
+            obj._FlagAsMethod(name)
+            flagged_count += 1
+        except Exception:
+            # Not on this dispatch's real interface — skip silently.
+            pass
+    return flagged_count
+
+
+def flagged(obj: Any, *interfaces: str) -> Any:
+    """Flag ``obj``'s methods then return ``obj`` — call-chain friendly.
+
+    Useful for inline flagging of short-lived dispatches::
+
+        config = sw_type_info.flagged(
+            model.GetActiveConfiguration(), "IConfiguration"
+        )
+        name = config.GetName()
+
+    If ``obj`` is ``None`` (e.g. SW returned Nothing), passes through
+    unchanged.
+    """
+    if obj is not None:
+        flag_methods(obj, *interfaces)
+    return obj
+
+
+def flag_doc(obj: Any, doc_type: int) -> int:
+    """Flag methods for a SolidWorks document dispatch given its type.
+
+    Convenience wrapper around ``flag_methods`` that looks up the correct
+    interface list for the document type.
+
+    Args:
+        obj: ``CDispatch`` wrapping the document.
+        doc_type: Value returned by ``swDoc.GetType()`` — 1=Part, 2=Assembly,
+            3=Drawing.
+
+    Returns:
+        Number of methods flagged.
+    """
+    interfaces = DOC_TYPE_TO_INTERFACES.get(doc_type, ("IModelDoc2",))
+    return flag_methods(obj, *interfaces)
+
+
+def invalidate_flag_cache(obj: Any | None = None) -> None:
+    """Forget that ``obj`` has been flagged, or clear the cache entirely.
+
+    Needed when a dispatch is closed / re-acquired; the new object at the
+    same address would otherwise be treated as already-flagged.
+    """
+    if obj is None:
+        _flag_cache.clear()
+    else:
+        _flag_cache.pop(id(obj), None)

solidworks_mcp/adapters/vba_adapter.py

@@ -0,0 +1,318 @@
+"""VBA adapter path for complex operations with generated macro metadata."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from .base import (
+    AdapterResult,
+    ExtrusionParameters,
+    LoftParameters,
+    RevolveParameters,
+    SweepParameters,
+)
+from .vba_macro_executor import MacroExecutionRequest, VbaMacroExecutor
+
+
+class VbaGeneratorAdapter:
+    """Adapter that executes complex operations through VBA-oriented flow.
+
+    This adapter currently uses the wrapped COM adapter for final execution, but annotates
+    responses as VBA-routed and can be extended to execute generated macros directly in
+    future iterations.
+
+    Args:
+        backing_adapter (Any): The backing adapter value.
+        macro_executor (VbaMacroExecutor | None): The macro executor value. Defaults to
+                                                  None.
+
+    Attributes:
+        _backing_adapter (Any): The backing adapter value.
+        _macro_executor (Any): The macro executor value.
+        config (Any): The config value.
+    """
+
+    def __init__(
+        self,
+        backing_adapter: Any,
+        macro_executor: VbaMacroExecutor | None = None,
+    ) -> None:
+        """Initialize the vba generator adapter.
+
+        Args:
+            backing_adapter (Any): The backing adapter value.
+            macro_executor (VbaMacroExecutor | None): The macro executor value. Defaults to
+                                                      None.
+
+        Returns:
+            None: None.
+        """
+        self._backing_adapter = backing_adapter
+        self._macro_executor = macro_executor or VbaMacroExecutor()
+        self.config = getattr(backing_adapter, "config", None)
+
+    def __getattr__(self, item: str) -> Any:
+        """Delegate unknown members to backing adapter.
+
+        Args:
+            item (str): The item value.
+
+        Returns:
+            Any: The result produced by the operation.
+        """
+        return getattr(self._backing_adapter, item)
+
+    async def connect(self) -> None:
+        """Connect to SolidWorks using wrapped adapter.
+
+        Returns:
+            None: None.
+        """
+        await self._backing_adapter.connect()
+
+    async def disconnect(self) -> None:
+        """Disconnect wrapped adapter.
+
+        Returns:
+            None: None.
+        """
+        await self._backing_adapter.disconnect()
+
+    def is_connected(self) -> bool:
+        """Return wrapped adapter connection state.
+
+        Returns:
+            bool: True if connected, otherwise False.
+        """
+        return bool(self._backing_adapter.is_connected())
+
+    async def health_check(self) -> Any:
+        """Return wrapped adapter health with VBA route marker.
+
+        Returns:
+            Any: The result produced by the operation.
+        """
+        health = await self._backing_adapter.health_check()
+        if hasattr(health, "metrics"):
+            metrics = dict(health.metrics or {})
+            metrics["route"] = "vba"
+            health.metrics = metrics
+        return health
+
+    async def create_extrusion(
+        self,
+        params: ExtrusionParameters,
+    ) -> AdapterResult[Any]:
+        """Create the extrusion.
+
+        Args:
+            params (ExtrusionParameters): The params value.
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        return await self._run_with_vba_metadata(
+            operation="create_extrusion",
+            payload=params,
+            com_call=self._backing_adapter.create_extrusion,
+            vba_code=self._generate_extrusion_vba(params),
+        )
+
+    async def create_revolve(
+        self,
+        params: RevolveParameters,
+    ) -> AdapterResult[Any]:
+        """Create the revolve.
+
+        Args:
+            params (RevolveParameters): The params value.
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        return await self._run_with_vba_metadata(
+            operation="create_revolve",
+            payload=params,
+            com_call=self._backing_adapter.create_revolve,
+            vba_code=self._generate_revolve_vba(params),
+        )
+
+    async def create_sweep(
+        self,
+        params: SweepParameters,
+    ) -> AdapterResult[Any]:
+        """Create the sweep.
+
+        Args:
+            params (SweepParameters): The params value.
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        return await self._run_with_vba_metadata(
+            operation="create_sweep",
+            payload=params,
+            com_call=self._backing_adapter.create_sweep,
+            vba_code=self._generate_sweep_vba(params),
+        )
+
+    async def create_loft(
+        self,
+        params: LoftParameters,
+    ) -> AdapterResult[Any]:
+        """Create the loft.
+
+        Args:
+            params (LoftParameters): The params value.
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        return await self._run_with_vba_metadata(
+            operation="create_loft",
+            payload=params,
+            com_call=self._backing_adapter.create_loft,
+            vba_code=self._generate_loft_vba(params),
+        )
+
+    async def _run_with_vba_metadata(
+        self,
+        operation: str,
+        payload: Any,
+        com_call: Any,
+        vba_code: str,
+    ) -> AdapterResult[Any]:
+        """Build internal run with vba metadata.
+
+        Args:
+            operation (str): Callable object executed by the helper.
+            payload (Any): The payload value.
+            com_call (Any): The com call value.
+            vba_code (str): The vba code value.
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        result: AdapterResult[Any] = await com_call(payload)
+        metadata = dict(result.metadata or {})
+        metadata.update(
+            {
+                "route": "vba",
+                "operation": operation,
+                "vba_code": vba_code,
+                "generated_at": datetime.utcnow().isoformat(),
+            }
+        )
+        result.metadata = metadata
+        return result
+
+    def _generate_extrusion_vba(self, params: ExtrusionParameters) -> str:
+        """Generate simple VBA snippet for extrusion operation.
+
+        Args:
+            params (ExtrusionParameters): The params value.
+
+        Returns:
+            str: The resulting text value.
+        """
+        return (
+            "Sub CreateExtrusion()\n"
+            "    ' Auto-generated VBA fallback snippet\n"
+            f"    ' Depth: {params.depth}\n"
+            "End Sub"
+        )
+
+    def _generate_revolve_vba(self, params: RevolveParameters) -> str:
+        """Generate simple VBA snippet for revolve operation.
+
+        Args:
+            params (RevolveParameters): The params value.
+
+        Returns:
+            str: The resulting text value.
+        """
+        return (
+            "Sub CreateRevolve()\n"
+            "    ' Auto-generated VBA fallback snippet\n"
+            f"    ' Angle: {params.angle}\n"
+            "End Sub"
+        )
+
+    def _generate_sweep_vba(self, params: SweepParameters) -> str:
+        """Generate simple VBA snippet for sweep operation.
+
+        Args:
+            params (SweepParameters): The params value.
+
+        Returns:
+            str: The resulting text value.
+        """
+        return (
+            "Sub CreateSweep()\n"
+            "    ' Auto-generated VBA fallback snippet\n"
+            f"    ' Path: {params.path}\n"
+            "End Sub"
+        )
+
+    async def execute_macro(
+        self,
+        macro_code: str,
+        macro_name: str = "GeneratedMacro",
+        subroutine: str = "Main",
+    ) -> AdapterResult[Any]:
+        """Provide execute macro support for the vba generator adapter.
+
+        Args:
+            macro_code (str): The macro code value.
+            macro_name (str): The macro name value. Defaults to "GeneratedMacro".
+            subroutine (str): The subroutine value. Defaults to "Main".
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        request = MacroExecutionRequest(
+            macro_code=macro_code,
+            macro_name=macro_name,
+            subroutine=subroutine,
+        )
+        return await self._macro_executor.execute_macro(
+            request=request,
+            backing_adapter=self._backing_adapter,
+        )
+
+    def get_macro_execution_history(
+        self, macro_name: str | None = None
+    ) -> dict[
+        str,
+        Any,
+    ]:
+        """Retrieve VBA macro execution history.
+
+        Args:
+            macro_name (str | None): The macro name value. Defaults to None.
+
+        Returns:
+            dict[
+                str,
+                Any,
+            ]: A dictionary containing the resulting values.
+        """
+        history = self._macro_executor.get_execution_history(macro_name)
+        return {key: value.__dict__ for key, value in history.items()}
+
+    def _generate_loft_vba(self, params: LoftParameters) -> str:
+        """Generate simple VBA snippet for loft operation.
+
+        Args:
+            params (LoftParameters): The params value.
+
+        Returns:
+            str: The resulting text value.
+        """
+        return (
+            "Sub CreateLoft()\n"
+            "    ' Auto-generated VBA fallback snippet\n"
+            f"    ' Profiles: {len(params.profiles)}\n"
+            "End Sub"
+        )