sw2robot 0.4.1__py3-none-any.whl

sw2robot/__init__.py

@@ -0,0 +1,37 @@
+"""SolidWorks assembly -> URDF, plus a browser editor.
+
+Sub-packages:
+- ``sw2robot.exporter``  -- the exporter (SolidWorks .sldasm -> graph.json -> URDF)
+- ``sw2robot.editor``   -- the browser editor on top of the graph
+"""
+
+
+def _detect_version() -> str:
+    """The running version, single-sourced from ``pyproject.toml``.
+
+    Order: installed package metadata (works in a wheel/pip install AND in the
+    frozen .exe, which bundles the dist-info via build_exe.py's
+    ``--copy-metadata sw2robot``) -> the repo's pyproject.toml (a bare source
+    checkout that was never installed, e.g. the test run with pythonpath=".")
+    -> a sentinel.  The self-update check (``sw2robot.editor.update``) compares
+    this against the latest GitHub Release tag, so it must reflect the build."""
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+        try:
+            return version("sw2robot")
+        except PackageNotFoundError:
+            pass
+    except Exception:
+        pass
+    try:
+        import os
+        import tomllib
+        pp = os.path.join(os.path.dirname(os.path.dirname(__file__)),
+                          "pyproject.toml")
+        with open(pp, "rb") as f:
+            return tomllib.load(f)["project"]["version"]
+    except Exception:
+        return "0.0.0+unknown"
+
+
+__version__ = _detect_version()

sw2robot/editor/__init__.py

@@ -0,0 +1,21 @@
+"""sw2robot.editor -- the headless core bridging sw2robot.exporter
+(CAD->module) and the ROS config export.
+
+Design (a standing directive):
+- **State**: ``RobotCompilerState`` (Pydantic) is the single source of truth for
+  a CAD-derived module being configured.  It serializes to JSON, so it moves to
+  a REST/WebSocket payload unchanged.
+- **Core API** (``core``): pure functions that mutate State / produce artifacts.
+  A web-editor handler or a FastAPI endpoint is a *thin* wrapper over these.
+- **Headless**: the whole pipeline (CAD build -> edit -> ROS export) runs from
+  the CLI (``python -m sw2robot.editor``) with no GUI and no SolidWorks.
+
+It uses the *pure* halves: ``sw2robot.exporter.export.build`` (no SolidWorks)
+and the vendored ``sw2robot.editor._vendor.rc_config`` (ROS/MoveIt/Gazebo
+config generators).
+"""
+
+from . import core
+from .state import JointEdit, RobotCompilerState
+
+__all__ = ["JointEdit", "RobotCompilerState", "core"]

sw2robot/editor/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

sw2robot/editor/_autolimits_cli.py

@@ -0,0 +1,106 @@
+"""Self-collision joint-limit sweep as a standalone subprocess (JSON on stdout).
+
+The webserver shells out to this instead of sweeping in-process: the sweep is
+CPU-bound and releases the GIL (numpy / python-fcl), so running it inside the
+threaded HTTP server makes it thrash the GIL against the browser's idle
+keep-alive connection threads -- the classic CPython convoy, which inflated an
+8 s sweep to ~90 s just by having a page open.  A fresh process has its own GIL
+and no server threads, so it stays at the true ~8 s (+~3 s to load the model).
+
+    python -m sw2robot.editor._autolimits_cli <urdf> <step_deg> <max_deg> \
+        [margin_deg] [margin_mm]
+    -> stdout: {"results": [{"child","lower","upper","continuous"}, ...]}
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import tempfile
+
+
+def _fast_urdf(urdf):
+    """Return a URDF path whose mesh refs prefer the ``.3dxml.glb`` caches.
+
+    skrobot loads the SolidWorks ``.3dxml`` (mm, slow XML parse -- the heavy
+    ones are ~135 ms each and dominate load) and scales mm->m.  The web server
+    already converts each to a ``.3dxml.glb`` (metres) on package open; loading
+    those is ~5x faster and skrobot reads them at native scale, so the geometry
+    is identical.  We rewrite the URDF to point at the .glb wherever the cache
+    exists (falling back to .3dxml otherwise) and write it beside the original
+    so the ``../meshes`` relative paths still resolve.  Returns (path, is_temp).
+    """
+    txt = open(urdf, encoding="utf-8").read()
+    base = os.path.dirname(urdf)
+
+    def repl(m):
+        fn = m.group(1)
+        full = os.path.normpath(os.path.join(base, fn))
+        return f'filename="{fn}.glb"' if os.path.exists(full + ".glb") \
+            else m.group(0)
+
+    txt2 = re.sub(r'filename="([^"]+\.3dxml)"', repl, txt)
+    if txt2 == txt:
+        return urdf, False
+    fd, tmp = tempfile.mkstemp(suffix=".urdf", dir=base)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(txt2)
+    return tmp, True
+
+
+def _emit(**ev):
+    """One progress event as a JSON line on STDERR (stdout is reserved for the
+    final results JSON the caller parses).  The webserver reads these live to
+    drive the UI's per-joint progress bar."""
+    sys.stderr.write(json.dumps(ev) + "\n")
+    sys.stderr.flush()
+
+
+def main():
+    urdf, step_deg, max_deg = sys.argv[1], float(sys.argv[2]), float(sys.argv[3])
+    # optional backoff margins: degrees (revolute), mm (prismatic)
+    margin_deg = float(sys.argv[4]) if len(sys.argv) > 4 else 2.0
+    margin_mm = float(sys.argv[5]) if len(sys.argv) > 5 else 2.0
+    from skrobot.models.urdf import RobotModelFromURDF
+
+    from sw2robot.editor import autoinit
+
+    _emit(event="loading")                    # model load is the slow first ~2 s
+    # skrobot (>=0.3.16) resolves package:// meshes itself, so load the URDF
+    # (glb-accelerated) directly -- no pre-resolved temp copy needed.
+    load_urdf, is_tmp = _fast_urdf(urdf)
+    try:
+        robot = RobotModelFromURDF(urdf_file=load_urdf)
+    finally:
+        if is_tmp:
+            try:
+                os.remove(load_urdf)
+            except OSError:
+                pass
+    meshes = autoinit.link_meshes(robot)
+
+    total = sum(1 for j in robot.joint_list
+                if type(j).__name__ in ("RotationalJoint", "LinearJoint"))
+    _emit(event="start", total=total)
+
+    def on_start(name, i, n):
+        # emit BEFORE each joint's sweep so the bar advances and names the joint
+        # currently being worked (a single joint can take seconds on a big model)
+        _emit(event="joint", i=i, total=n, joint=name)
+
+    results = autoinit.sweep_limits(
+        robot, meshes, step_deg=step_deg, max_deg=max_deg,
+        margin_deg=margin_deg, margin_mm=margin_mm,
+        refine=True, on_start=on_start)
+    out = [{"child": v["child"], "lower": v["lower"], "upper": v["upper"],
+            "continuous": v["continuous"]}
+           for v in results.values() if v.get("child")]
+    # ONLY the JSON goes to stdout (skrobot's URDF warnings go to stderr)
+    sys.stdout.write(json.dumps({"results": out}))
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

sw2robot/editor/_vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendored third-party code (kept verbatim)."""

sw2robot/editor/_vendor/rc_config/__init__.py

@@ -0,0 +1,26 @@
+"""
+Configuration file generators for robot URDFs.
+
+This module provides generators for:
+- MoveIt2 configuration (SRDF, controllers, etc.)
+- Gazebo configuration (world, plugins, etc.)
+- Imitation Learning configuration (observation/action spaces)
+- Servo mapping configuration (joint to servo ID mapping)
+"""
+
+from .export import export_all_configs
+from .gazebo_generator import generate_gazebo_config
+from .imitation_generator import generate_il_config
+from .moveit_generator import generate_controllers_yaml, generate_srdf
+from .servo_mapping import generate_servo_mapping_yaml
+from .urdf_parser import parse_urdf_content
+
+__all__ = [
+    "export_all_configs",
+    "generate_controllers_yaml",
+    "generate_gazebo_config",
+    "generate_il_config",
+    "generate_servo_mapping_yaml",
+    "generate_srdf",
+    "parse_urdf_content",
+]

sw2robot/editor/_vendor/rc_config/export.py

@@ -0,0 +1,188 @@
+"""
+Configuration export utilities.
+
+Creates ZIP archives containing all configuration files.
+"""
+
+import io
+import zipfile
+from typing import Any
+
+from .gazebo_generator import generate_gazebo_config, generate_ros2_control_xacro
+from .imitation_generator import generate_il_config
+from .moveit_generator import generate_controllers_yaml, generate_srdf
+from .servo_mapping import generate_servo_mapping_yaml
+
+
+def export_all_configs(
+    urdf_content: str,
+    joints: list[dict[str, Any]],
+    servo_mappings: list[dict[str, Any]],
+    planning_groups: list[dict[str, Any]],
+    controllers: list[dict[str, Any]],
+    disabled_collision_pairs: list[tuple[str, str]],
+    gazebo_physics: dict[str, Any],
+    gazebo_plugins: list[dict[str, Any]],
+    il_observation: dict[str, Any],
+    il_action: dict[str, Any],
+    robot_name: str = "robot",
+    export_options: dict[str, bool] | None = None,
+) -> bytes:
+    """
+    Export all configuration files as a ZIP archive.
+
+    Parameters
+    ----------
+    urdf_content : str
+        Original URDF content.
+    joints : list
+        Parsed joint information.
+    servo_mappings : list
+        Servo mapping configurations.
+    planning_groups : list
+        MoveIt planning group configurations.
+    controllers : list
+        Controller configurations.
+    disabled_collision_pairs : list
+        List of disabled collision link pairs.
+    gazebo_physics : dict
+        Gazebo physics settings.
+    gazebo_plugins : list
+        Gazebo plugin configurations.
+    il_observation : dict
+        IL observation space configuration.
+    il_action : dict
+        IL action space configuration.
+    robot_name : str
+        Name of the robot for file naming.
+
+    Returns
+    -------
+    bytes
+        ZIP file contents as bytes.
+    """
+    # Default export options if not provided
+    if export_options is None:
+        export_options = {
+            "includeUrdf": True,
+            "includeServoMapping": True,
+            "includeMoveIt": True,
+            "includeGazebo": True,
+            "includeImitationLearning": True,
+        }
+
+    # Create in-memory ZIP file
+    zip_buffer = io.BytesIO()
+
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+        # URDF (original)
+        if export_options.get("includeUrdf", True):
+            zf.writestr(f"{robot_name}/urdf/{robot_name}.urdf", urdf_content)
+
+        # Servo mapping
+        if export_options.get("includeServoMapping", True):
+            servo_yaml = generate_servo_mapping_yaml(servo_mappings)
+            zf.writestr(f"{robot_name}/config/servo_mapping.yaml", servo_yaml)
+
+        # MoveIt SRDF and controllers
+        if export_options.get("includeMoveIt", True):
+            srdf_content = generate_srdf(
+                robot_name=robot_name,
+                planning_groups=planning_groups,
+                disabled_collision_pairs=[tuple(p) for p in disabled_collision_pairs],
+            )
+            zf.writestr(f"{robot_name}/config/{robot_name}.srdf", srdf_content)
+
+            controllers_yaml = generate_controllers_yaml(controllers)
+            zf.writestr(f"{robot_name}/config/controllers.yaml", controllers_yaml)
+
+        # Gazebo config
+        if export_options.get("includeGazebo", True):
+            gazebo_config = generate_gazebo_config(gazebo_physics, gazebo_plugins)
+            zf.writestr(f"{robot_name}/config/gazebo.xml", gazebo_config)
+
+            ros2_control_xacro = generate_ros2_control_xacro(joints)
+            zf.writestr(f"{robot_name}/urdf/ros2_control.xacro", ros2_control_xacro)
+
+        # IL config
+        if export_options.get("includeImitationLearning", True):
+            il_config = generate_il_config(il_observation, il_action, joints)
+            zf.writestr(f"{robot_name}/config/il_config.yaml", il_config)
+
+        # README (always include)
+        readme = _generate_readme(robot_name, export_options)
+        zf.writestr(f"{robot_name}/README.md", readme)
+
+    return zip_buffer.getvalue()
+
+
+def _generate_readme(robot_name: str, export_options: dict[str, bool]) -> str:
+    """Generate a README file for the configuration package."""
+    contents = []
+    usage_sections = []
+
+    if export_options.get("includeUrdf", True):
+        contents.append(f"- `urdf/{robot_name}.urdf` - Robot URDF description")
+
+    if export_options.get("includeGazebo", True):
+        contents.append("- `urdf/ros2_control.xacro` - ros2_control hardware interface configuration")
+        contents.append("- `config/gazebo.xml` - Gazebo physics and plugin configuration")
+        usage_sections.append(f"""### Gazebo
+
+Include the ros2_control xacro in your robot description:
+
+```xml
+<xacro:include filename="$(find {robot_name})/urdf/ros2_control.xacro" />
+```""")
+
+    if export_options.get("includeServoMapping", True):
+        contents.append("- `config/servo_mapping.yaml` - Joint to servo ID mapping")
+
+    if export_options.get("includeMoveIt", True):
+        contents.append(f"- `config/{robot_name}.srdf` - MoveIt2 SRDF (semantic robot description)")
+        contents.append("- `config/controllers.yaml` - ros2_control controller configuration")
+        usage_sections.append(f"""### MoveIt2
+
+Include the SRDF in your MoveIt2 launch files:
+
+```python
+srdf_file = os.path.join(pkg_share, 'config', '{robot_name}.srdf')
+```
+
+### Controllers
+
+Load the controller configuration:
+
+```yaml
+ros2_control_node:
+  ros__parameters:
+    robot_description: $(command 'cat $(find {robot_name})/urdf/{robot_name}.urdf')
+```""")
+
+    if export_options.get("includeImitationLearning", True):
+        contents.append("- `config/il_config.yaml` - Imitation Learning configuration")
+        usage_sections.append("""### Imitation Learning
+
+Load the IL configuration in your training script:
+
+```python
+import yaml
+with open('config/il_config.yaml') as f:
+    config = yaml.safe_load(f)
+```""")
+
+    contents_str = "\n".join(contents)
+    usage_str = "\n\n".join(usage_sections)
+
+    return f"""# {robot_name} Configuration Package
+
+Generated by Robot Compiler.
+
+## Contents
+
+{contents_str}
+
+## Usage
+
+{usage_str}
+"""

sw2robot/editor/_vendor/rc_config/gazebo_generator.py

@@ -0,0 +1,121 @@
+"""
+Gazebo configuration file generators.
+
+Generates world and plugin configuration files.
+"""
+
+from typing import Any
+
+
+def generate_gazebo_config(
+    physics: dict[str, Any],
+    plugins: list[dict[str, Any]],
+) -> str:
+    """
+    Generate Gazebo world configuration snippet.
+
+    Parameters
+    ----------
+    physics : dict
+        Physics configuration with:
+        - solver: Physics engine (ode, bullet, simbody, dart)
+        - stepSize: Simulation step size in seconds
+        - realTimeFactor: Real-time factor
+    plugins : list
+        List of plugin configurations with:
+        - name: Plugin name
+        - filename: Plugin library filename
+        - enabled: Whether plugin is enabled
+        - parameters: Dict of plugin parameters
+
+    Returns
+    -------
+    str
+        Gazebo SDF/world configuration snippet.
+    """
+    solver = physics.get("solver", "ode")
+    step_size = physics.get("stepSize", 0.001)
+    rtf = physics.get("realTimeFactor", 1.0)
+
+    lines = [
+        "<!-- Gazebo Configuration Generated by Robot Compiler -->",
+        "",
+        f'<physics name="default_physics" type="{solver}">',
+        f"  <max_step_size>{step_size}</max_step_size>",
+        f"  <real_time_factor>{rtf}</real_time_factor>",
+        f"  <real_time_update_rate>{int(1 / step_size)}</real_time_update_rate>",
+        "</physics>",
+        "",
+    ]
+
+    # Plugins
+    for plugin in plugins:
+        if not plugin.get("enabled", True):
+            continue
+
+        name = plugin["name"]
+        filename = plugin["filename"]
+        params = plugin.get("parameters", {})
+
+        lines.append(f'<plugin filename="{filename}" name="{name}">')
+        for key, value in params.items():
+            lines.append(f"  <{key}>{value}</{key}>")
+        lines.append("</plugin>")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_ros2_control_xacro(
+    joints: list[dict[str, Any]],
+    hardware_interface: str = "gazebo_ros2_control/GazeboSystem",
+) -> str:
+    """
+    Generate ros2_control URDF/Xacro snippet for Gazebo.
+
+    Parameters
+    ----------
+    joints : list
+        List of joint configurations with:
+        - name: Joint name
+        - type: Joint type (revolute, prismatic, etc.)
+    hardware_interface : str
+        Hardware interface plugin name.
+
+    Returns
+    -------
+    str
+        ros2_control Xacro snippet.
+    """
+    lines = [
+        "<!-- ros2_control Configuration for Gazebo -->",
+        "<!-- Generated by Robot Compiler -->",
+        "",
+        '<ros2_control name="GazeboSystem" type="system">',
+        "  <hardware>",
+        f"    <plugin>{hardware_interface}</plugin>",
+        "  </hardware>",
+    ]
+
+    for joint in joints:
+        if joint.get("type") == "fixed":
+            continue
+
+        name = joint["name"]
+        lines.append(f'  <joint name="{name}">')
+        lines.append('    <command_interface name="position"/>')
+        lines.append('    <command_interface name="velocity"/>')
+        lines.append('    <state_interface name="position"/>')
+        lines.append('    <state_interface name="velocity"/>')
+        lines.append('    <state_interface name="effort"/>')
+        lines.append("  </joint>")
+
+    lines.append("</ros2_control>")
+    lines.append("")
+    lines.append("<gazebo>")
+    lines.append('  <plugin filename="libgazebo_ros2_control.so" name="gazebo_ros2_control">')
+    lines.append("    <parameters>$(find robot_config)/config/controllers.yaml</parameters>")
+    lines.append("  </plugin>")
+    lines.append("</gazebo>")
+
+    return "\n".join(lines)

sw2robot/editor/_vendor/rc_config/imitation_generator.py

@@ -0,0 +1,123 @@
+"""
+Imitation Learning configuration generators.
+
+Generates configuration files for RL/IL training.
+"""
+
+from typing import Any
+
+
+def generate_il_config(
+    observation: dict[str, Any],
+    action: dict[str, Any],
+    joints: list[dict[str, Any]],
+) -> str:
+    """
+    Generate Imitation Learning configuration YAML.
+
+    Parameters
+    ----------
+    observation : dict
+        Observation space configuration with:
+        - includeJointPositions: bool
+        - includeJointVelocities: bool
+        - includeEndEffectorPose: bool
+        - customObservations: list of custom observation names
+    action : dict
+        Action space configuration with:
+        - actionType: 'joint_positions', 'joint_velocities', or 'end_effector_delta'
+        - selectedJoints: list of joint names
+        - actionScale: float multiplier for actions
+    joints : list
+        List of joint configurations for dimension calculation.
+
+    Returns
+    -------
+    str
+        YAML configuration content.
+    """
+    # Calculate dimensions
+    actuated_joints = [j for j in joints if j.get("type") != "fixed"]
+    n_joints = len(actuated_joints)
+
+    obs_dim = 0
+    if observation.get("includeJointPositions", True):
+        obs_dim += n_joints
+    if observation.get("includeJointVelocities", True):
+        obs_dim += n_joints
+    if observation.get("includeEndEffectorPose", False):
+        obs_dim += 7  # position (3) + quaternion (4)
+
+    custom_obs = observation.get("customObservations", [])
+    obs_dim += len(custom_obs)
+
+    action_joints = action.get("selectedJoints", [])
+    action_dim = len(action_joints)
+
+    lines = [
+        "# Imitation Learning Configuration",
+        "# Generated by Robot Compiler",
+        "",
+        "robot:",
+        "  observation_space:",
+        f"    dim: {obs_dim}",
+        f"    include_joint_positions: {str(observation.get('includeJointPositions', True)).lower()}",
+        f"    include_joint_velocities: {str(observation.get('includeJointVelocities', True)).lower()}",
+        f"    include_end_effector_pose: {str(observation.get('includeEndEffectorPose', False)).lower()}",
+    ]
+
+    if custom_obs:
+        lines.append("    custom_observations:")
+        for obs in custom_obs:
+            lines.append(f"      - {obs}")
+
+    lines.extend(
+        [
+            "",
+            "  action_space:",
+            f"    dim: {action_dim}",
+            f"    type: {action.get('actionType', 'joint_positions')}",
+            f"    scale: {action.get('actionScale', 1.0)}",
+            "    joints:",
+        ]
+    )
+
+    for joint in action_joints:
+        lines.append(f"      - {joint}")
+
+    # Add joint limits for reference
+    lines.extend(
+        [
+            "",
+            "  joint_limits:",
+        ]
+    )
+
+    for joint in actuated_joints:
+        if joint["name"] in action_joints:
+            lines.append(f"    {joint['name']}:")
+            lines.append(f"      lower: {joint.get('lowerLimit', 0.0)}")
+            lines.append(f"      upper: {joint.get('upperLimit', 0.0)}")
+            lines.append(f"      velocity: {joint.get('velocityLimit', 0.0)}")
+
+    # Add training hints
+    lines.extend(
+        [
+            "",
+            "# Training Configuration",
+            "training:",
+            "  horizon: 1000",
+            "  batch_size: 256",
+            "  learning_rate: 3.0e-4",
+            "  gamma: 0.99",
+            "  clip_range: 0.2",
+            "",
+            "# Normalization",
+            "normalization:",
+            "  normalize_observations: true",
+            "  normalize_rewards: true",
+            "  clip_observations: 10.0",
+        ]
+    )
+
+    return "\n".join(lines)