lang2sim 2.0.0__py3-none-any.whl

lang2sim/cli/widgets/thought_box.py

@@ -0,0 +1,64 @@
+"""
+Collapsible Thought Box Widget
+File: lang2sim/cli/widgets/thought_box.py
+"""
+
+from textual.widget import Widget
+from textual.widgets import Static
+from textual.reactive import reactive
+from textual.events import Click
+
+class ThoughtBox(Widget):
+    """Collapsible reasoning thought block matching OpenCode UX (+ Thought: 1.2s)."""
+
+    DEFAULT_CSS = """
+    ThoughtBox {
+        height: auto;
+        margin-bottom: 1;
+    }
+    """
+
+    is_collapsed = reactive(True)
+    duration_str = reactive("1.2s")
+    thought_content = reactive("")
+
+    def __init__(self, duration_str: str = "1.2s", content: str = "", **kwargs):
+        super().__init__(classes="thought-box", **kwargs)
+        self.duration_str = duration_str
+        self.thought_content = content or "Evaluating warehouse boundaries and spatial constraints..."
+
+    def compose(self):
+        yield Static(self._format_header(), id="thought-header", classes="thought-header")
+        yield Static(self.thought_content, id="thought-body", classes="thought-content")
+
+    def _format_header(self) -> str:
+        symbol = "+" if self.is_collapsed else "−"
+        hint = "" if self.is_collapsed else " (click to collapse)"
+        return f"{symbol} Thought: {self.duration_str}{hint}"
+
+    def on_click(self, event: Click) -> None:
+        self.toggle()
+
+    def toggle(self) -> None:
+        self.is_collapsed = not self.is_collapsed
+        header = self.query_one("#thought-header", Static)
+        body = self.query_one("#thought-body", Static)
+        header.update(self._format_header())
+        body.display = not self.is_collapsed
+
+    def on_mount(self) -> None:
+        body = self.query_one("#thought-body", Static)
+        body.display = not self.is_collapsed
+
+    def update_content(self, content: str, duration_str: str = "") -> None:
+        """Dynamically update thought text and duration during streaming or completion."""
+        self.thought_content = content
+        if duration_str:
+            self.duration_str = duration_str
+        try:
+            header = self.query_one("#thought-header", Static)
+            body = self.query_one("#thought-body", Static)
+            header.update(self._format_header())
+            body.update(self.thought_content)
+        except Exception:
+            pass

lang2sim/compiler/__init__.py

@@ -0,0 +1,15 @@
+"""
+Simulation world and launch compilers for Sim2Lang.
+"""
+
+from lang2sim.compiler.sdf_compiler import HarmonicSdfCompiler, compile_world_sdf
+from lang2sim.compiler.sir_validator import SIRValidator
+from lang2sim.compiler.sir_generator import SIRGenerator, generate_simulation_ir
+
+__all__ = [
+    "HarmonicSdfCompiler",
+    "compile_world_sdf",
+    "SIRValidator",
+    "SIRGenerator",
+    "generate_simulation_ir",
+]

lang2sim/compiler/sdf_compiler.py

@@ -0,0 +1,65 @@
+"""
+Gazebo Harmonic (SDF 1.9+) World Compiler.
+File: lang2sim/compiler/sdf_compiler.py
+"""
+
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader
+
+from lang2sim.core.models import SimSpec
+from lang2sim.core.config import config
+
+
+class HarmonicSdfCompiler:
+    """
+    Compiles canonical SimSpec models into physically accurate Gazebo Harmonic
+    SDF 1.9+ XML worlds.
+    """
+
+    def __init__(self, templates_dir: Path = config.templates_dir):
+        self.templates_dir = templates_dir
+        self.env = Environment(
+            loader=FileSystemLoader(str(self.templates_dir)),
+            autoescape=False,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+        self.template = self.env.get_template("world_harmonic.sdf.jinja")
+
+    def compile(
+        self,
+        sim_spec: SimSpec,
+        output_path: Path,
+        world_name: str = "default_world",
+        target: str = "harmonic",
+    ) -> Path:
+        """
+        Renders the SDF template for target simulator and writes the result to disk.
+        """
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        context = {
+            "world_name": world_name,
+            "target": target,
+            "ambient_light": sim_spec.environment.ambient_light_luminance,
+            "surface_friction": sim_spec.environment.surface_friction,
+            "sky": sim_spec.environment.sky_weather,
+            "room": sim_spec.environment.room_dimensions,
+            "wall_height": sim_spec.environment.wall_height,
+            "objects": sim_spec.objects,
+        }
+
+        rendered_xml = self.template.render(context)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(rendered_xml)
+
+        return output_path
+
+
+def compile_world_sdf(
+    sim_spec: SimSpec, output_path: Path, world_name: str = "default_world"
+) -> Path:
+    """Convenience helper to compile a SimSpec into a world.sdf file."""
+    compiler = HarmonicSdfCompiler()
+    return compiler.compile(sim_spec, output_path, world_name)

lang2sim/compiler/sir_generator.py

@@ -0,0 +1,46 @@
+"""
+Simulation Intermediate Representation (SIR) Generator.
+File: lang2sim/compiler/sir_generator.py
+"""
+
+from typing import Optional
+from lang2sim.core.models import SimSpec, SimulationIR
+from lang2sim.world_gen.shapely_solver import ShapelySpatialSolver
+from lang2sim.compiler.sir_validator import SIRValidator
+
+
+class SIRGenerator:
+    """
+    Compiles raw SimSpec declarations into validated SimulationIR graphs.
+    """
+
+    def __init__(self):
+        self.solver = ShapelySpatialSolver()
+        self.validator = SIRValidator()
+
+    def generate(self, sim_spec: SimSpec) -> SimulationIR:
+        """
+        Solves placement for unplaced objects and builds the canonical SimulationIR.
+        """
+        placed_objects, corridors = self.solver.solve_layout(
+            environment=sim_spec.environment,
+            objects=sim_spec.objects,
+            spawn_pose=sim_spec.mission.initial_pose,
+            goal_pose=sim_spec.mission.goal_pose,
+        )
+
+        resolved_spec = sim_spec.model_copy(update={"objects": placed_objects})
+        is_valid, validation_messages = self.validator.validate(resolved_spec)
+
+        return SimulationIR(
+            spec=resolved_spec,
+            aisle_corridors=corridors,
+            is_valid=is_valid,
+            validation_messages=validation_messages,
+        )
+
+
+def generate_simulation_ir(sim_spec: SimSpec) -> SimulationIR:
+    """Convenience helper to generate validated SimulationIR."""
+    generator = SIRGenerator()
+    return generator.generate(sim_spec)

lang2sim/compiler/sir_validator.py

@@ -0,0 +1,87 @@
+"""
+Simulation Intermediate Representation (SIR) Validator.
+File: lang2sim/compiler/sir_validator.py
+"""
+
+from typing import List, Tuple
+from shapely.geometry import box, Point
+
+from lang2sim.core.models import SimSpec, SimulationIR
+from lang2sim.core.config import (
+    ROBOT_CIRCUMSCRIBED_RADIUS,
+    MIN_AISLE_CORRIDOR_WIDTH,
+    MIN_WALL_STANDOFF,
+)
+from lang2sim.world_gen.shapely_solver import ShapelySpatialSolver
+
+
+class SIRValidator:
+    """
+    Physical feasibility and safety validator for Simulation Intermediate Representations.
+    """
+
+    def __init__(
+        self,
+        min_corridor_width: float = MIN_AISLE_CORRIDOR_WIDTH,
+        wall_standoff: float = MIN_WALL_STANDOFF,
+        robot_radius: float = ROBOT_CIRCUMSCRIBED_RADIUS,
+    ):
+        self.min_corridor_width = min_corridor_width
+        self.wall_standoff = wall_standoff
+        self.robot_radius = robot_radius
+        self.solver = ShapelySpatialSolver(
+            min_corridor_width=min_corridor_width,
+            wall_standoff=wall_standoff,
+            robot_radius=robot_radius,
+        )
+
+    def validate(self, sim_spec: SimSpec) -> Tuple[bool, List[str]]:
+        """
+        Validates geometric feasibility, bounds, non-intersection, and reachability.
+        """
+        errors: List[str] = []
+        env = sim_spec.environment
+        room_poly = self.solver.create_room_polygon(env.room_dimensions)
+
+        # 1. Validate room dimensions
+        if env.room_dimensions.x <= 0 or env.room_dimensions.y <= 0:
+            errors.append(f"Invalid room dimensions: {env.room_dimensions}")
+
+        # 2. Validate object boundaries and overlaps
+        placed_polygons = []
+        for obj in sim_spec.objects:
+            poly = self.solver.create_obb(
+                obj.pose.x, obj.pose.y, obj.dimensions.x, obj.dimensions.y, obj.pose.yaw
+            )
+
+            # Check inside room
+            if not room_poly.contains(poly):
+                errors.append(f"Object '{obj.id}' is outside room boundaries at ({obj.pose.x}, {obj.pose.y})")
+
+            # Check overlap with existing objects
+            for idx, existing in enumerate(placed_polygons):
+                if poly.intersects(existing):
+                    errors.append(f"Collision detected: Object '{obj.id}' overlaps with object '{sim_spec.objects[idx].id}'")
+
+            placed_polygons.append(poly)
+
+        # 3. Validate robot initial spawn pose
+        spawn_pt = Point(sim_spec.mission.initial_pose.x, sim_spec.mission.initial_pose.y)
+        if not room_poly.contains(spawn_pt):
+            errors.append(f"Spawn pose ({spawn_pt.x}, {spawn_pt.y}) is outside room bounds")
+
+        for idx, poly in enumerate(placed_polygons):
+            if poly.distance(spawn_pt) < (self.robot_radius + 0.1):
+                errors.append(f"Spawn pose in collision with object '{sim_spec.objects[idx].id}'")
+
+        # 4. Validate goal pose
+        goal_pt = Point(sim_spec.mission.goal_pose.x, sim_spec.mission.goal_pose.y)
+        if not room_poly.contains(goal_pt):
+            errors.append(f"Goal pose ({goal_pt.x}, {goal_pt.y}) is outside room bounds")
+
+        for idx, poly in enumerate(placed_polygons):
+            if poly.distance(goal_pt) < (self.robot_radius + 0.1):
+                errors.append(f"Goal pose in collision with object '{sim_spec.objects[idx].id}'")
+
+        is_valid = len(errors) == 0
+        return is_valid, errors

lang2sim/core/__init__.py

@@ -0,0 +1,50 @@
+"""Core data contracts, schemas, and configurations for Sim2Lang."""
+
+from lang2sim.core.models import (
+    Pose2D,
+    Vector3D,
+    SkyWeatherSpec,
+    EnvironmentSpec,
+    ObjectSpec,
+    CameraPerturbation,
+    LidarPerturbation,
+    SensorNoiseSpec,
+    DynamicObstacleTrigger,
+    MissionSpec,
+    SimSpec,
+    SimulationIR,
+    SimStartRequest,
+    RunManifest,
+    SimStopRequest,
+    SimStatusResponse,
+    NavInitialPoseRequest,
+    NavGoalRequest,
+    NavWaypointsRequest,
+    NavStatus,
+)
+from lang2sim.core.config import Config, config
+
+__all__ = [
+    "Pose2D",
+    "Vector3D",
+    "SkyWeatherSpec",
+    "EnvironmentSpec",
+    "ObjectSpec",
+    "CameraPerturbation",
+    "LidarPerturbation",
+    "SensorNoiseSpec",
+    "DynamicObstacleTrigger",
+    "MissionSpec",
+    "SimSpec",
+    "SimulationIR",
+    "SimStartRequest",
+    "RunManifest",
+    "SimStopRequest",
+    "SimStatusResponse",
+    "NavInitialPoseRequest",
+    "NavGoalRequest",
+    "NavWaypointsRequest",
+    "NavStatus",
+    "Config",
+    "config",
+]

lang2sim/core/config.py

@@ -0,0 +1,116 @@
+"""
+Runtime and Workspace Configuration Manager
+File: lang2sim/core/config.py
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+def _env(*names: str, default: str) -> str:
+    """First non-empty env var among `names` (L2S_* names are what the sim container sets)."""
+    for n in names:
+        v = os.getenv(n)
+        if v:
+            return v
+    return default
+
+
+# Root paths. Inside the sim container the entrypoint sets L2S_PROJECTS_DIR /
+# L2S_CATALOG_DIR to the bind-mount targets, so the same code resolves to the
+# host's ~/.lang2sim/projects on both sides.
+DEFAULT_LANG2SIM_ROOT = Path(os.path.expanduser(_env("L2S_ROOT", default="~/.lang2sim")))
+PROJECTS_DIR = Path(_env("L2S_PROJECTS_DIR", default=str(DEFAULT_LANG2SIM_ROOT / "projects")))
+CATALOG_DIR = Path(_env("L2S_CATALOG_DIR", default=str(Path(__file__).resolve().parent.parent.parent / "catalog")))
+
+# Container-side mount points (contract with docker/sim/Dockerfile).
+CONTAINER_PROJECTS_DIR = "/lang2sim/projects"
+CONTAINER_CATALOG_DIR = "/lang2sim/catalog"
+CONTAINER_SRC_DIR = "/opt/lang2sim/src"
+
+# Pinned Container Image and Network Defaults (Dev 3 synced).
+# CI publishes :staging, :main, :sha-<short>, and :<semver> for v* tags; the
+# `-vnc` suffix selects the noVNC variant.
+DEFAULT_SIM_IMAGE = _env("L2S_IMAGE", "LANG2SIM_IMAGE", default="ghcr.io/duttaneel07/lang2sim-sim:staging")
+DEFAULT_CONTROL_PORT = int(_env("L2S_API_PORT", "CONTROL_API_PORT", default="9090"))
+DEFAULT_FOXGLOVE_PORT = int(_env("L2S_FOXGLOVE_PORT", "FOXGLOVE_PORT", default="8765"))
+DEFAULT_NOVNC_PORT = int(_env("L2S_NOVNC_PORT", "NOVNC_PORT", default="6080"))
+
+# Physical Robot Kinematics (TurtleBot3 Waffle standard)
+ROBOT_CIRCUMSCRIBED_RADIUS = 0.22  # meters
+ROBOT_SAFETY_MARGIN = 0.30        # meters
+MIN_AISLE_CORRIDOR_WIDTH = 2.20   # meters
+MIN_WALL_STANDOFF = 0.50          # meters
+MAP_RESOLUTION = 0.05             # meters per pixel
+
+
+def ensure_directories():
+    """Ensure ~/.lang2sim and projects directory exist."""
+    DEFAULT_LANG2SIM_ROOT.mkdir(parents=True, exist_ok=True)
+    PROJECTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_projects_dir() -> Path:
+    """Returns the base projects directory."""
+    ensure_directories()
+    return PROJECTS_DIR
+
+
+def get_active_project_dir(project_name: str = "active_project") -> Path:
+    """Returns an isolated project directory."""
+    ensure_directories()
+    p_dir = PROJECTS_DIR / project_name
+    p_dir.mkdir(parents=True, exist_ok=True)
+    return p_dir
+
+
+def get_run_dir(project_name: str = "active_project", timestamp: Optional[str] = None) -> Path:
+    """
+    Returns an isolated timestamped run directory matching Dev 3 convention:
+    ~/.lang2sim/projects/<project_name>/runs/<timestamp>/
+    """
+    p_dir = get_active_project_dir(project_name)
+    runs_dir = p_dir / "runs"
+    runs_dir.mkdir(parents=True, exist_ok=True)
+    if timestamp is None:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_dir = runs_dir / timestamp
+    run_dir.mkdir(parents=True, exist_ok=True)
+    return run_dir
+
+
+def get_catalog_dir() -> Path:
+    """Returns the catalog directory."""
+    return CATALOG_DIR
+
+
+class Config:
+    """Object-oriented wrapper around configuration settings."""
+
+    def __init__(self, workspace_root: Optional[Path] = None):
+        self.workspace_root = workspace_root or Path(__file__).resolve().parent.parent.parent
+        self.catalog_dir = CATALOG_DIR
+        self.templates_dir = self.workspace_root / "lang2sim" / "compiler" / "templates"
+        self.base_projects_dir = PROJECTS_DIR
+
+        self.sim_image_tag = DEFAULT_SIM_IMAGE
+        self.control_api_port = DEFAULT_CONTROL_PORT
+        self.foxglove_port = DEFAULT_FOXGLOVE_PORT
+        self.novnc_port = DEFAULT_NOVNC_PORT
+
+        self.robot_circumscribed_radius = ROBOT_CIRCUMSCRIBED_RADIUS
+        self.robot_safety_margin = ROBOT_SAFETY_MARGIN
+        self.min_aisle_corridor_width = MIN_AISLE_CORRIDOR_WIDTH
+        self.min_wall_standoff = MIN_WALL_STANDOFF
+        self.map_resolution = MAP_RESOLUTION
+
+    def get_project_dir(self, project_name: str = "active_project") -> Path:
+        return get_active_project_dir(project_name)
+
+    def create_run_dir(self, project_name: str = "active_project", timestamp: Optional[str] = None) -> Path:
+        return get_run_dir(project_name, timestamp)
+
+
+# Global singleton instance
+config = Config()