lang2sim 2.0.0__py3-none-any.whl

lang2sim/world_gen/map_slicer.py

@@ -0,0 +1,131 @@
+"""
+Zero-SLAM 2D Occupancy Map Slicer.
+File: lang2sim/world_gen/map_slicer.py
+
+Converts 3D world geometric bounds and Shapely object polygons directly into
+standard Nav2 P5 Portable Gray Map (map.pgm) and YAML metadata (map.yaml)
+in < 2 seconds, completely eliminating Cartographer / SLAM overhead.
+"""
+
+import math
+from pathlib import Path
+from typing import List, Tuple, Optional
+from shapely.geometry import Polygon, Point
+
+from lang2sim.core.models import Vector3D, ObjectSpec
+from lang2sim.core.config import MAP_RESOLUTION
+
+
+class ZeroSlamMapSlicer:
+    """
+    Direct geometric rasterizer converting room and obstacle polygons
+    into 2D occupancy grids for Nav2.
+    """
+
+    def __init__(self, resolution: float = MAP_RESOLUTION):
+        self.resolution = resolution  # 0.05 m/pixel
+
+    def slice_and_export(
+        self,
+        room_dim: Vector3D,
+        objects: List[ObjectSpec],
+        output_dir: Path,
+        map_name: str = "map",
+    ) -> Tuple[Path, Path]:
+        """
+        Rasters the 2D floorplan and writes map.pgm + map.yaml.
+        """
+        output_dir.mkdir(parents=True, exist_ok=True)
+        pgm_path = output_dir / f"{map_name}.pgm"
+        yaml_path = output_dir / f"{map_name}.yaml"
+
+        width_m = room_dim.x
+        height_m = room_dim.y
+
+        cols = int(math.ceil(width_m / self.resolution))
+        rows = int(math.ceil(height_m / self.resolution))
+
+        origin_x = -(width_m / 2.0)
+        origin_y = -(height_m / 2.0)
+
+        # 254 = Free space (white), 0 = Occupied (black)
+        # Using a flat bytearray of size rows * cols
+        grid = bytearray([254] * (rows * cols))
+
+        def set_pixel(c: int, r: int, val: int):
+            if 0 <= c < cols and 0 <= r < rows:
+                grid[r * cols + c] = val
+
+        # 1. Draw outer walls (wall thickness = 0.2m -> 4 pixels)
+        wall_px = max(2, int(0.20 / self.resolution))
+        for r in range(rows):
+            for c in range(cols):
+                if (
+                    r < wall_px
+                    or r >= rows - wall_px
+                    or c < wall_px
+                    or c >= cols - wall_px
+                ):
+                    set_pixel(c, r, 0)
+
+        # 2. Rasterize each obstacle
+        for obj in objects:
+            cx = obj.pose.x
+            cy = obj.pose.y
+            dx = obj.dimensions.x
+            dy = obj.dimensions.y
+            yaw = obj.pose.yaw
+
+            # Create Shapely OBB for precise polygon point-in-polygon containment
+            from lang2sim.world_gen.shapely_solver import ShapelySpatialSolver
+            solver = ShapelySpatialSolver()
+            poly = solver.create_obb(cx, cy, dx, dy, yaw)
+            min_x, min_y, max_x, max_y = poly.bounds
+
+            c_min = max(0, int((min_x - origin_x) / self.resolution))
+            c_max = min(cols, int(math.ceil((max_x - origin_x) / self.resolution)))
+            r_min = max(0, int((min_y - origin_y) / self.resolution))
+            r_max = min(rows, int(math.ceil((max_y - origin_y) / self.resolution)))
+
+            for r in range(r_min, r_max):
+                for c in range(c_min, c_max):
+                    world_x = origin_x + (c + 0.5) * self.resolution
+                    world_y = origin_y + (r + 0.5) * self.resolution
+                    if poly.contains(Point(world_x, world_y)):
+                        set_pixel(c, r, 0)
+
+        # 3. Write P5 Grayscale PGM file directly
+        # Standard P5 format: Header\n<cols> <rows>\n<max_val>\n<raw_bytes>
+        header = f"P5\n{cols} {rows}\n255\n".encode("ascii")
+        with open(pgm_path, "wb") as f:
+            f.write(header)
+            # PGM rows run top to bottom and Nav2's map_server puts the first row at
+            # the map's max y; grid row 0 is min y (origin), so write rows in reverse.
+            for r in range(rows - 1, -1, -1):
+                f.write(grid[r * cols:(r + 1) * cols])
+
+        # 4. Write Nav2 map.yaml metadata
+        yaml_content = f"""image: {map_name}.pgm
+mode: trinary
+resolution: {self.resolution}
+origin: [{origin_x:.3f}, {origin_y:.3f}, 0.000]
+negate: 0
+occupied_thresh: 0.65
+free_thresh: 0.25
+"""
+        with open(yaml_path, "w", encoding="utf-8") as f:
+            f.write(yaml_content)
+
+        return pgm_path, yaml_path
+
+
+def slice_map_from_layout(
+    room_dim: Vector3D,
+    objects: List[ObjectSpec],
+    output_dir: Path,
+    map_name: str = "map",
+    resolution: float = MAP_RESOLUTION,
+) -> Tuple[Path, Path]:
+    """Convenience function to generate zero-SLAM map assets."""
+    slicer = ZeroSlamMapSlicer(resolution=resolution)
+    return slicer.slice_and_export(room_dim, objects, output_dir, map_name)

lang2sim/world_gen/shapely_solver.py

@@ -0,0 +1,256 @@
+"""
+Shapely 2.0 Spatial Placement & Oriented Bounding Box (OBB) Solver.
+File: lang2sim/world_gen/shapely_solver.py
+"""
+
+import math
+from typing import List, Optional, Tuple
+from shapely.geometry import Polygon, Point, box
+from shapely import affinity
+
+from lang2sim.core.models import (
+    Pose2D,
+    Vector3D,
+    EnvironmentSpec,
+    ObjectSpec,
+    AisleCorridor,
+)
+from lang2sim.core.config import (
+    ROBOT_CIRCUMSCRIBED_RADIUS,
+    MIN_AISLE_CORRIDOR_WIDTH,
+    MIN_WALL_STANDOFF,
+)
+
+
+class ShapelySpatialSolver:
+    """
+    Computational geometry solver ensuring 100% collision-free placement
+    and guaranteed Nav2 navigation corridors (> 2.2m).
+    """
+
+    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
+
+    def create_room_polygon(self, room_dim: Vector3D) -> Polygon:
+        """
+        Creates outer room boundary centered at world origin (0, 0).
+        X in [-W/2, W/2], Y in [-H/2, H/2].
+        """
+        half_w = room_dim.x / 2.0
+        half_h = room_dim.y / 2.0
+        return box(-half_w, -half_h, half_w, half_h)
+
+    def create_obb(
+        self, x: float, y: float, size_x: float, size_y: float, yaw: float = 0.0
+    ) -> Polygon:
+        """
+        Creates an Oriented Bounding Box (OBB) polygon for an obstacle.
+        """
+        half_x = size_x / 2.0
+        half_y = size_y / 2.0
+        unrotated = box(x - half_x, y - half_y, x + half_x, y + half_y)
+        if abs(yaw) > 1e-4:
+            return affinity.rotate(unrotated, yaw, use_radians=True, origin=(x, y))
+        return unrotated
+
+    def is_valid_placement(
+        self,
+        candidate_poly: Polygon,
+        placed_polygons: List[Polygon],
+        room_poly: Polygon,
+        reserved_points: Optional[List[Point]] = None,
+        enforce_corridor: bool = True,
+    ) -> bool:
+        """
+        Checks if candidate polygon satisfies:
+        1. Inside room with minimum wall standoff (>= 0.5m).
+        2. Non-intersecting with all existing placed obstacles.
+        3. Maintains minimum corridor buffer (>= 2.2m / 2 from boundaries).
+        4. Does not collide with reserved points (robot spawn pose, goal target).
+        """
+        # 1. Must be completely within room
+        if not room_poly.contains(candidate_poly):
+            return False
+
+        # 2. Check wall standoff
+        if room_poly.boundary.distance(candidate_poly) < self.wall_standoff:
+            return False
+
+        # 3. Check direct collision with existing obstacles
+        for p in placed_polygons:
+            if candidate_poly.intersects(p):
+                return False
+
+        # 4. Check reserved points (e.g. initial spawn pose and goal)
+        if reserved_points:
+            clearance_radius = self.robot_radius + 0.30
+            for pt in reserved_points:
+                if candidate_poly.distance(pt) < clearance_radius:
+                    return False
+
+        # 5. Check corridor buffer between objects
+        if enforce_corridor and placed_polygons:
+            buffer_dist = self.min_corridor_width / 2.0
+            buffered_candidate = candidate_poly.buffer(buffer_dist)
+            for p in placed_polygons:
+                # If buffered candidate overlaps with existing obstacle, corridor is < min_corridor
+                if buffered_candidate.intersects(p):
+                    return False
+
+        return True
+
+    def solve_layout(
+        self,
+        environment: EnvironmentSpec,
+        objects: List[ObjectSpec],
+        spawn_pose: Optional[Pose2D] = None,
+        goal_pose: Optional[Pose2D] = None,
+    ) -> Tuple[List[ObjectSpec], List[AisleCorridor]]:
+        """
+        Solves placement for a list of objects in the given environment.
+        Preserves specified poses if collision-free, otherwise packs them
+        in structured rows ensuring >= 2.2m navigation corridors.
+        """
+        room_poly = self.create_room_polygon(environment.room_dimensions)
+        placed_specs: List[ObjectSpec] = []
+        placed_polygons: List[Polygon] = []
+
+        reserved_points: List[Point] = []
+        if spawn_pose:
+            reserved_points.append(Point(spawn_pose.x, spawn_pose.y))
+        if goal_pose:
+            reserved_points.append(Point(goal_pose.x, goal_pose.y))
+
+        # Separate items with predetermined valid poses vs unplaced items
+        unplaced_items: List[ObjectSpec] = []
+
+        for obj in objects:
+            candidate_poly = self.create_obb(
+                obj.pose.x,
+                obj.pose.y,
+                obj.dimensions.x,
+                obj.dimensions.y,
+                obj.pose.yaw,
+            )
+            # If default (0, 0), we treat it as requiring procedural placement
+            if abs(obj.pose.x) < 1e-3 and abs(obj.pose.y) < 1e-3:
+                unplaced_items.append(obj)
+            elif self.is_valid_placement(
+                candidate_poly,
+                placed_polygons,
+                room_poly,
+                reserved_points,
+                enforce_corridor=False,
+            ):
+                placed_specs.append(obj)
+                placed_polygons.append(candidate_poly)
+            else:
+                unplaced_items.append(obj)
+
+        # Place remaining items in structured rows
+        half_w = environment.room_dimensions.x / 2.0 - self.wall_standoff
+        half_h = environment.room_dimensions.y / 2.0 - self.wall_standoff
+
+        # Multi-row search grid
+        y_step = self.min_corridor_width + 1.2
+        y_positions = [-y_step, y_step, -y_step / 1.5, y_step / 1.5, 0.0]
+
+        for obj in unplaced_items:
+            placed = False
+            dx = obj.dimensions.x
+            dy = obj.dimensions.y
+
+            for y_candidate in y_positions:
+                if abs(y_candidate) + dy / 2.0 > half_h:
+                    continue
+
+                # Search X with fine granularity to navigate around reserved points (spawn/goal)
+                min_x = -half_w + dx / 2.0
+                max_x = half_w - dx / 2.0
+                curr_x = min_x
+
+                while curr_x <= max_x:
+                    candidate_poly = self.create_obb(curr_x, y_candidate, dx, dy, 0.0)
+
+                    if self.is_valid_placement(
+                        candidate_poly,
+                        placed_polygons,
+                        room_poly,
+                        reserved_points,
+                        enforce_corridor=True,
+                    ):
+                        updated_obj = obj.model_copy(
+                            update={"pose": Pose2D(x=round(curr_x, 2), y=round(y_candidate, 2), yaw=0.0)}
+                        )
+                        placed_specs.append(updated_obj)
+                        placed_polygons.append(candidate_poly)
+                        placed = True
+                        break
+                    curr_x += 0.5
+
+                if placed:
+                    break
+
+            # Fallback placement: try rotated orientations along perimeter walls
+            if not placed:
+                for angle in [0.0, math.pi / 2.0]:
+                    dim_x = dx if angle == 0.0 else dy
+                    dim_y = dy if angle == 0.0 else dx
+                    min_x = -half_w + dim_x / 2.0
+                    max_x = half_w - dim_x / 2.0
+
+                    for y_candidate in [-half_h + dim_y / 2.0, half_h - dim_y / 2.0]:
+                        curr_x = min_x
+                        while curr_x <= max_x:
+                            candidate_poly = self.create_obb(curr_x, y_candidate, dim_x, dim_y, angle)
+                            if self.is_valid_placement(
+                                candidate_poly,
+                                placed_polygons,
+                                room_poly,
+                                reserved_points,
+                                enforce_corridor=False,
+                            ):
+                                updated_obj = obj.model_copy(
+                                    update={"pose": Pose2D(x=round(curr_x, 2), y=round(y_candidate, 2), yaw=round(angle, 4))}
+                                )
+                                placed_specs.append(updated_obj)
+                                placed_polygons.append(candidate_poly)
+                                placed = True
+                                break
+                            curr_x += 0.5
+                        if placed:
+                            break
+                    if placed:
+                        break
+
+        # Calculate verified main navigation corridors
+        corridors: List[AisleCorridor] = []
+        half_w_corr = environment.room_dimensions.x / 2.0 - 1.0
+        corridors.append(
+            AisleCorridor(
+                corridor_id="central_main_aisle",
+                width=self.min_corridor_width,
+                start_point=Pose2D(x=-half_w_corr, y=0.0, yaw=0.0),
+                end_point=Pose2D(x=half_w_corr, y=0.0, yaw=0.0),
+            )
+        )
+
+        return placed_specs, corridors
+
+
+def solve_spatial_layout(
+    environment: EnvironmentSpec,
+    objects: List[ObjectSpec],
+    spawn_pose: Optional[Pose2D] = None,
+    goal_pose: Optional[Pose2D] = None,
+) -> Tuple[List[ObjectSpec], List[AisleCorridor]]:
+    """Convenience wrapper for the Shapely spatial solver."""
+    solver = ShapelySpatialSolver()
+    return solver.solve_layout(environment, objects, spawn_pose, goal_pose)

lang2sim-2.0.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: lang2sim
+Version: 2.0.0
+Summary: Natural Language to Executable Robot Simulation with Dynamic Stress Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.6.0
+Requires-Dist: shapely>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: textual>=0.70.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: openai>=1.14.0
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mss>=9.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: pytest>=7.4.0
+Provides-Extra: sim
+Requires-Dist: fastapi<1,>=0.110; extra == "sim"
+Requires-Dist: uvicorn[standard]<1,>=0.29; extra == "sim"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# Lang2Sim
+
+> Natural Language to Executable Robot Simulation with Dynamic Stress Testing.
+
+## Overview
+Sim2Lang provides an interactive, full-screen Terminal User Interface (TUI) copilot (`lang2sim`) powered by NVIDIA Nemotron 3 Ultra 550B A55B. It autonomously compiles natural language into procedurally generated Gazebo `.sdf` worlds, zero-SLAM 2D occupancy navigation grids, containerized native desktop Gazebo/RViz2 GUI launches with X11 pass-through, and closed-loop telemetry benchmark scoring ($NQI$).
+
+## Installation
+```bash
+pip install -e .
+```
+
+## Launch
+```bash
+lang2sim
+```
+
+## Run a simulation (Part 3)
+```bash
+pip install -e ".[sim,dev]"
+python scripts/run_sim.py --fixture small_warehouse --mission
+```
+Per-OS setup, the run-folder contract, the control API and troubleshooting:
+[docs/part3-runtime.md](docs/part3-runtime.md).
+

lang2sim-2.0.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+lang2sim/__init__.py,sha256=4wsy-YNkEBJrINg9c7VoL9Db3jqyqYLCYRqUOQXTTFI,1490
+lang2sim/agent/__init__.py,sha256=W-rMJgY6OH7sBuX7C3kaHVCKhMXzdTEFBivhShj_eSs,213
+lang2sim/agent/nemotron_client.py,sha256=a-u-s3na5EOqzm7j4oTACwXqtg1mwmzG2VL_-rBZ6b4,3883
+lang2sim/agent/react_loop.py,sha256=CP3Td2lNYQUOL281eXMJKaYEAWZceZ2boihiI-e0zcY,40481
+lang2sim/agent/tools.py,sha256=oTpgM7h-n0NiYrlgEDJ7_eH0MOXZE7GOThEL0qtwml4,40746
+lang2sim/cli/app.py,sha256=A6LRwLGtmeY06DbDjS_R_He9mefpibitxypmZC0uR4c,7554
+lang2sim/cli/screens/__init__.py,sha256=5v3rzuOANUHKQV6vJiAjHTMmgQBfkdJeaRJDfmNraY8,275
+lang2sim/cli/screens/command_palette_modal.py,sha256=-UyTj2-1ZHVUTYRNnAKAAIUtA75OMUGSnZGwNQKLkl4,6245
+lang2sim/cli/screens/landing_screen.py,sha256=m-bUYQeoDHHU0SSR9Ai1hWP5b2GNLLWT39A2rJeVfgA,3747
+lang2sim/cli/screens/sessions_modal.py,sha256=gnfXa-Iz567zfn2BH25kJHD2B0oWYhFYS8iOUaaXNWU,8633
+lang2sim/cli/screens/workspace_screen.py,sha256=vUsHxU5nnmGHSAro6Dl2aq5UT3aNmNEZ3k4jzeSpF9k,32243
+lang2sim/cli/widgets/__init__.py,sha256=iFpbhwWOUSLliJUD1Ys4CtdxeVzwzusHKRAkM-Sf2EM,355
+lang2sim/cli/widgets/action_pill.py,sha256=hJOEZJDOencAfkL4Bc5l0Ml-7-Re73FZFXv2Ojx5IR8,2151
+lang2sim/cli/widgets/command_card.py,sha256=kN9dxg5_R2QbScLzQwfvAa7-ZR2_mleI4v7w7nm4RZQ,8581
+lang2sim/cli/widgets/plan_card.py,sha256=7DhNV0wYER7QxrPd0fORT5fIclT4diGiKcbQNlvA82o,3396
+lang2sim/cli/widgets/prompt_card.py,sha256=4-S1EXEeXhPeBC3QYJp0n89XRJYD3geFJrFdQT7vpjM,2414
+lang2sim/cli/widgets/telemetry_sidebar.py,sha256=wPKGp3yviGS2HJgj1L3dbAiSHCsf_jVf4yFcMUnyqVE,5133
+lang2sim/cli/widgets/thought_box.py,sha256=-V7XdDaRqZL9uJ7uM7FbFQh5eJYd4_UZqeOS9SXiHOw,2288
+lang2sim/compiler/__init__.py,sha256=cquaTxY0dJQs3XyOQfY_sGDOfwcPOUqdkAZ-bP9l0_k,418
+lang2sim/compiler/sdf_compiler.py,sha256=NWWv9ym69oW1JC3OsEUN1Ensvac5D9lwZfV2WcPGwXQ,2048
+lang2sim/compiler/sir_generator.py,sha256=uun8NTF6Y-GDUkmC0Q8qTPB3wjQ0vYrRjYxyGS10dr8,1520
+lang2sim/compiler/sir_validator.py,sha256=2OAQDfdR2-toElKTsKjbBJaspF2fe8iB3IgI41Tn9Ow,3404
+lang2sim/core/__init__.py,sha256=B2Z6mTcp_7wnsaXgxxlG9lOuuO4KAXDfDKAkImLFPCM,1028
+lang2sim/core/config.py,sha256=CrPj8lC--DiPm80RNjQoURRwgXrBIbOdhqtbCg41b08,4425
+lang2sim/core/models.py,sha256=ITk1KPH8smrgpWsXfYhE_p6Ei6JTElc2odBfM1rq55E,13468
+lang2sim/core/session_manager.py,sha256=mIN-Psh_U7zUcD3iMf-tyJyzoWO_y20x8_S_1CopS-4,6546
+lang2sim/perturbation/__init__.py,sha256=EoDgx_g9YJ5UTBy9Cls0Sx7ubxXVZdyVxTseBOiTNuk,1109
+lang2sim/perturbation/_compat.py,sha256=Km0MlEjLrk2oxpRLXwNt1IW4je2w2tpCWocaIqH6bRE,653
+lang2sim/perturbation/gazebo_bridge.py,sha256=SBoe2zQ2oxc4XDtNdxrBg8ncifWD0A5apHYLPdijYdI,21094
+lang2sim/perturbation/mcp_server.py,sha256=8Qb_mGlewxRMlwJY46NyYXiGp4XugUhCPF2Ig0ZZf6w,4692
+lang2sim/perturbation/sdf_snippets.py,sha256=5KwRI2iluUrDMGLMIQTHIx2bBYBARW0Qd-EkmYUU9AU,2992
+lang2sim/perturbation/routers/__init__.py,sha256=BZi3_h7RcDE0oSKxhgbH0dYLcLQhKm1Nf9HWCrXjHX0,408
+lang2sim/perturbation/routers/world.py,sha256=_yONosMk7KEqteW0wHPGhhEjcLFoL03LT4qdQEhQ6Jw,4230
+lang2sim/runtime/__init__.py,sha256=qER5-OyjkYDV4O9mPaSpoKl8A_Rh8bOjrT1E8Uu5scQ,317
+lang2sim/runtime/display.py,sha256=aISU4WQ9zv6gU_T34AIFg7i0I7r7OL8Z8hjmfx3YWWI,5573
+lang2sim/runtime/docker_runner.py,sha256=SK5cBwtXnv9UuYW7kCyplxVERyu5o3ozHIXAwNXqQb0,11035
+lang2sim/runtime/doctor.py,sha256=CdjLC37Se9TMCF1e87IG7nzFFKEHZZByJhhOY1L3AdY,9756
+lang2sim/runtime/hardware_probe.py,sha256=5rE4X0jBBxF6QzmjsHaCMv0Sk1pPoGKh049YtGQCF-U,4684
+lang2sim/runtime/health_monitor.py,sha256=Cy-Lt1SX7imHD809eJaw3BHVZ1E-V2YlwBzVDI_m6lw,2825
+lang2sim/runtime/launch_builder.py,sha256=OHqcnZLPgJe-tca6jk2m1sfUhLWj19o0HtXIDsSiS0o,6205
+lang2sim/runtime/nav2_dispatcher.py,sha256=6RuXjlrlYg2HQpyJlJGE-tCKCrjQ5ARKxmvmkgXKu5g,8692
+lang2sim/runtime/platform.py,sha256=KgnOsoBH98Z729678J1SG9D5GgMsZVWar0jATqeUhQk,4991
+lang2sim/runtime/ros_bridge.py,sha256=8akxjMvgtx4PfSCPotj3Lg1tnFivXo1UZqcqm24BrW8,7702
+lang2sim/runtime/run_folder.py,sha256=tSdRH9jcEj6guc1innSbS-az5wiXNJX_ojcCnXLUnyM,3452
+lang2sim/runtime/self_healing.py,sha256=pxXxZhs55qFIWUKfgZ2kDzs0lzoqX49Ne9KEv-oEQWI,17529
+lang2sim/runtime/session.py,sha256=InbipEQlRMPC64kj0RYCyXftkBwScdeYm9CcKzhWZWA,6126
+lang2sim/runtime/world_check.py,sha256=lfhWjEUEtkvuQUDWs5hfQZPVsafGjVcXD40IQ-5rmCA,8108
+lang2sim/runtime/control_api/__init__.py,sha256=kHogjfpqCAfsE4fBaiNlt64XIOTcZACDrNOAF8ntUsI,245
+lang2sim/runtime/control_api/client.py,sha256=6wqeqrWVr9BYzHC10fsjp7kZpeXqLqIgF26TXZg2ooM,7804
+lang2sim/runtime/control_api/server.py,sha256=9u3orHR4pq4pemeeW1JGGZrOUW-PVv3j8KBZDxgwGXY,20313
+lang2sim/telemetry/__init__.py,sha256=llBfVQqUspUoN1YHC7WoXINpEi2tpmhYRGHLqpKRuts,1966
+lang2sim/telemetry/nqi_scorer.py,sha256=IN3cPDfKDraoHvpNPrLlNRUcd-rgClpheaaZG3ZPiVg,26953
+lang2sim/telemetry/ros_subscribers.py,sha256=zAO49AwDwP8Coi9hMtUr-H2Jy562wwofdk0Tk9fS9Vc,19124
+lang2sim/telemetry/trajectory.py,sha256=5-i5l0Q2IdiO0N2zxoG2BRXRDQckHJcuEac5Ydgqk5I,10078
+lang2sim/telemetry/vision.py,sha256=EWz2mhDPw8pLf8tzSc7smD_-5B7q0lSNMVPM3ZSuyRQ,17155
+lang2sim/world_gen/__init__.py,sha256=7Fcl4lVE402UjFnd6rGz-o_wECeEn9wajZ3GLMm0_MM,476
+lang2sim/world_gen/catalog_loader.py,sha256=irArZgjeyCB_-JvzPN2EEHOQZTl4j3F-cP_zG68uqDo,3331
+lang2sim/world_gen/map_slicer.py,sha256=4P5f9-4EO9pBqPxRv9xzBKqGKxWNLqXymXiWH_Fyuhw,4659
+lang2sim/world_gen/shapely_solver.py,sha256=ehzJvOQ89z1qtfK2VHuDCLdYeSdkW_XjMQx6cGUR6-s,9626
+lang2sim-2.0.0.dist-info/licenses/LICENSE,sha256=obd9QomNbPEL6QYz5RsBqc2LhZc9ja3n4023r1b5MOg,1067
+lang2sim-2.0.0.dist-info/METADATA,sha256=3MZhOig1m_Fhhsjj3Thv1kMqnkn48GUNE9tPNbYgLjs,1722
+lang2sim-2.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+lang2sim-2.0.0.dist-info/entry_points.txt,sha256=UHbZPiD0vqV3XBH3st2-QWg8f24yrFNikScs0inX8nw,51
+lang2sim-2.0.0.dist-info/top_level.txt,sha256=uYNJ4yakAafOAf4K_m2b_xVxJ1cQCvxUR3nkR8qH6XY,9
+lang2sim-2.0.0.dist-info/RECORD,,

lang2sim-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lang2sim-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lang2sim = lang2sim.cli.app:main

lang2sim-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neel Dutta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lang2sim-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lang2sim