GraspGen generator with docker dimos module integration (#1119)

* working graspgen with footer docker conversion

* Add GraspGen model checkpoints to LFS

* refactor: reorganize grasping module to dimos/manipulation/grasping

- Move grasping module from dimos/grasping/ to dimos/manipulation/grasping/
- Rename docker_module.py to docker_runner.py with simplified implementation- Isolated the docker container not to have any langchain dependency
- Add proper docstrings with Args for OpenAI function calling
- Simplify visualize_grasps.py to minimal debug tool
- Add get_object_pointcloud_by_object_id RPC for object ID lookups

* fix: resolve mypy type errors and cleanup unused files

Type fixes:
- Add type annotations for ndarray, list, dict parameters
- Add type: ignore comments for Docker-only imports (torch, grasp_gen)
- Fix RPC call args from tuple to list in docker_runner.py
- Add Iterator return type to PoseArray.__iter__
- Fix import order for ruff compliance

Cleanup:
- Delete unused objscene_registreation_myversion.py
- Update .dockerignore to only allow data/.lfs/

* fix: CI failures - test fixes, blueprints update, and formatting

Fixes:
- Update test_classmethods to expect 10 RPCs (matches current Module base class)
- Regenerate all_blueprints.py to include new grasping_module

Formatting (ruff/pre-commit auto-fixes):
- Apply import ordering and TYPE_CHECKING patterns across grasping modules
- Fix whitespace and blank line formatting
- Update JSON indentation in calibration.json
- Regenerate uv.lock

* fix: move type ignore comment to correct line for multi-line import

* ci: trigger CI run

---------

Co-authored-by: Jalaj Shukla <shuklajalaj98@gmail.com>

Author: JalajShuklaSS

.dockerignore

@@ -43,7 +43,7 @@ build/
 .env.local
 .env.*.local
 
-# Large data files
+# Large data files (LFS archives only)
 data/*
 !data/.lfs/
 

data/.lfs/models_graspgen.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:058ff764c043dccc516c1519a1e23207500c20a10c432c15eb5e30104477c0a4
+size 2117602984

dimos/core/__init__.py

@@ -100,6 +100,16 @@ def deploy(  # type: ignore[no-untyped-def]
         *args,
         **kwargs,
     ) -> ModuleProxy:
+        from dimos.core.docker_runner import DockerModule, is_docker_module
+
+        # Check if this module should run in Docker (based on its default_config)
+        if is_docker_module(actor_class):
+            logger.info("Deploying module in Docker.", module=actor_class.__name__)
+            dm = DockerModule(actor_class, *args, **kwargs)
+            dm.start()  # Explicit start - follows create -> configure -> start lifecycle
+            dask_client._docker_modules.append(dm)  # type: ignore[attr-defined]
+            return dm  # type: ignore[return-value]
+
         logger.info("Deploying module.", module=actor_class.__name__)
         actor = dask_client.submit(  # type: ignore[no-untyped-call]
             actor_class,
@@ -175,6 +185,14 @@ def close_all() -> None:
             return
         dask_client._closed = True  # type: ignore[attr-defined]
 
+        # Stop all Docker modules (in reverse order of deployment)
+        for dm in reversed(dask_client._docker_modules):  # type: ignore[attr-defined]
+            try:
+                dm.stop()
+            except Exception:
+                pass
+        dask_client._docker_modules.clear()  # type: ignore[attr-defined]
+
         # Stop all SharedMemory transports before closing Dask
         # This prevents the "leaked shared_memory objects" warning and hangs
         try:
@@ -226,6 +244,7 @@ def close_all() -> None:
         # This is needed, solves race condition in CI thread check
         time.sleep(0.1)
 
+    dask_client._docker_modules = []  # type: ignore[attr-defined]
     dask_client.deploy = deploy  # type: ignore[attr-defined]
     dask_client.check_worker_memory = check_worker_memory  # type: ignore[attr-defined]
     dask_client.stop = lambda: dask_client.close()  # type: ignore[attr-defined, no-untyped-call]

dimos/core/docker_build.py

@@ -0,0 +1,120 @@
+# Copyright 2025-2026 Dimensional Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Docker image building and Dockerfile conversion utilities.
+Converts any Dockerfile into a DimOS module container by appending a footer
+that installs DimOS and creates the module entrypoint.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from typing import TYPE_CHECKING
+
+from dimos.utils.logging_config import setup_logger
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from dimos.core.docker_runner import DockerModuleConfig
+
+logger = setup_logger()
+
+# Timeout for quick Docker commands
+DOCKER_CMD_TIMEOUT = 20
+
+# Sentinel value to detect already-converted Dockerfiles (UUID ensures uniqueness)
+DIMOS_SENTINEL = "DIMOS-MODULE-CONVERSION-427593ae-c6e8-4cf1-9b2d-ee81a420a5dc"
+
+# Footer appended to Dockerfiles for DimOS module conversion
+DIMOS_FOOTER = f"""
+# ==== {DIMOS_SENTINEL} ====
+# Copy DimOS source from build context
+COPY dimos /dimos/source/dimos/
+COPY pyproject.toml /dimos/source/
+COPY docker/python/module-install.sh /tmp/module-install.sh
+
+# Install DimOS and create entrypoint
+RUN bash /tmp/module-install.sh /dimos/source && rm /tmp/module-install.sh
+
+ENTRYPOINT ["/dimos/entrypoint.sh"]
+"""
+
+
+def _run(cmd: list[str], *, timeout: float | None = None) -> subprocess.CompletedProcess[str]:
+    """Run a command and return the result."""
+    return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, check=False)
+
+
+def _run_streaming(cmd: list[str]) -> int:
+    """Run command and stream output to terminal. Returns exit code."""
+    result = subprocess.run(cmd, text=True)
+    return result.returncode
+
+
+def _docker_bin(cfg: DockerModuleConfig) -> str:
+    """Get docker binary path."""
+    return cfg.docker_bin or "docker"
+
+
+def _image_exists(docker_bin: str, image_name: str) -> bool:
+    """Check if a Docker image exists locally."""
+    r = _run([docker_bin, "image", "inspect", image_name], timeout=DOCKER_CMD_TIMEOUT)
+    return r.returncode == 0
+
+
+def _convert_dockerfile(dockerfile: Path) -> Path:
+    """Append DimOS footer to Dockerfile. Returns path to converted file."""
+    content = dockerfile.read_text()
+
+    # Already converted?
+    if DIMOS_SENTINEL in content:
+        return dockerfile
+
+    logger.info(f"Converting {dockerfile.name} to DimOS format")
+
+    converted = dockerfile.parent / f".{dockerfile.name}.dimos"
+    converted.write_text(content.rstrip() + "\n" + DIMOS_FOOTER.lstrip("\n"))
+    return converted
+
+
+def build_image(cfg: DockerModuleConfig) -> None:
+    """Build Docker image using footer mode conversion."""
+    if cfg.docker_file is None:
+        raise ValueError("docker_file is required for building Docker images")
+    dockerfile = _convert_dockerfile(cfg.docker_file)
+
+    context = cfg.docker_build_context or cfg.docker_file.parent
+    cmd = [_docker_bin(cfg), "build", "-t", cfg.docker_image, "-f", str(dockerfile)]
+    for k, v in cfg.docker_build_args.items():
+        cmd.extend(["--build-arg", f"{k}={v}"])
+    cmd.append(str(context))
+
+    logger.info(f"Building Docker image: {cfg.docker_image}")
+    exit_code = _run_streaming(cmd)
+    if exit_code != 0:
+        raise RuntimeError(f"Docker build failed with exit code {exit_code}")
+
+
+def image_exists(cfg: DockerModuleConfig) -> bool:
+    """Check if the configured Docker image exists locally."""
+    return _image_exists(_docker_bin(cfg), cfg.docker_image)
+
+
+__all__ = [
+    "DIMOS_FOOTER",
+    "build_image",
+    "image_exists",
+]