luckyrobots 0.1.66__py3-none-any.whl → 0.1.72__py3-none-any.whl

luckyrobots/models/observation.py

@@ -0,0 +1,135 @@
+"""
+RL observation models for LuckyRobots.
+
+These are the primary return types for the simplified API:
+- ObservationResponse: returned by get_observation()
+- StateSnapshot: returned by get_state()
+"""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class ObservationResponse(BaseModel):
+    """RL observation data from an agent.
+
+    This is the return type for LuckyEngineClient.get_observation() and
+    LuckyRobots.get_observation(). It contains the RL observation vector
+    with optional named access for debugging.
+
+    Usage:
+        obs = client.get_observation()
+
+        # Flat vector for RL training
+        obs.observation  # [0.1, 0.2, 0.3, ...]
+
+        # Named access (if schema was fetched)
+        obs["proj_grav_x"]  # 0.1
+        obs.to_dict()  # {"proj_grav_x": 0.1, "proj_grav_y": 0.2, ...}
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    observation: List[float] = Field(
+        description="Flat observation vector from the agent's observation spec"
+    )
+    actions: List[float] = Field(description="Last applied actions")
+    timestamp_ms: int = Field(description="Wall-clock timestamp in milliseconds")
+    frame_number: int = Field(description="Monotonic frame counter")
+    agent_name: str = Field(description="Agent identifier")
+
+    # Optional named access (populated if schema is available)
+    observation_names: Optional[List[str]] = Field(
+        default=None,
+        description="Observation names from agent schema (enables named access)",
+    )
+    action_names: Optional[List[str]] = Field(
+        default=None,
+        description="Action names from agent schema",
+    )
+
+    def __getitem__(self, key: str) -> float:
+        """Access observation value by name.
+
+        Args:
+            key: Observation name (e.g., "proj_grav_x", "joint_pos_0").
+
+        Returns:
+            The observation value.
+
+        Raises:
+            KeyError: If names not available or key not found.
+        """
+        if self.observation_names is None:
+            raise KeyError(
+                f"No observation names available. "
+                f"Ensure client has fetched schema via get_agent_schema()."
+            )
+        try:
+            idx = self.observation_names.index(key)
+            return self.observation[idx]
+        except ValueError:
+            raise KeyError(
+                f"Unknown observation name: '{key}'. "
+                f"Available: {self.observation_names}"
+            )
+
+    def get(self, key: str, default: Optional[float] = None) -> Optional[float]:
+        """Get observation value by name with optional default.
+
+        Args:
+            key: Observation name.
+            default: Value to return if key not found.
+
+        Returns:
+            The observation value or default.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def to_dict(self) -> Dict[str, float]:
+        """Convert observations to a name->value dictionary.
+
+        Returns:
+            Dict mapping observation names to values. If names not available,
+            uses "obs_0", "obs_1", etc.
+        """
+        if self.observation_names is not None:
+            return dict(zip(self.observation_names, self.observation))
+        return {f"obs_{i}": v for i, v in enumerate(self.observation)}
+
+    def actions_to_dict(self) -> Dict[str, float]:
+        """Convert actions to a name->value dictionary.
+
+        Returns:
+            Dict mapping action names to values. If names not available,
+            uses "action_0", "action_1", etc.
+        """
+        if self.action_names is not None:
+            return dict(zip(self.action_names, self.actions))
+        return {f"action_{i}": v for i, v in enumerate(self.actions)}
+
+
+class StateSnapshot(BaseModel):
+    """Bundled snapshot of multiple data sources.
+
+    Use LuckyEngineClient.get_state() to get a bundled snapshot when you need
+    multiple data types in one efficient call. For streaming data like telemetry,
+    use the dedicated streaming methods instead.
+    """
+
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+
+    observation: Optional[ObservationResponse] = Field(
+        default=None, description="RL observation data (if include_observation=True)"
+    )
+    joint_state: Optional[Any] = Field(
+        default=None, description="Joint positions/velocities (if include_joint_state=True)"
+    )
+    camera_frames: Optional[List[Any]] = Field(
+        default=None, description="Camera frames (if camera_names provided)"
+    )
+    timestamp_ms: int = Field(default=0, description="Wall-clock timestamp in milliseconds")
+    frame_number: int = Field(default=0, description="Monotonic frame counter")

luckyrobots/models/randomization.py

@@ -0,0 +1,77 @@
+"""
+Domain randomization configuration for physics parameters.
+
+This model maps to the DomainRandomizationConfig proto message in agent.proto.
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class DomainRandomizationConfig(BaseModel):
+    """Domain randomization configuration for physics parameters.
+
+    All range fields are [min, max] tuples. None/empty means "use defaults".
+
+    Usage:
+        randomization_cfg = DomainRandomizationConfig(
+            friction_range=(0.5, 1.5),
+            mass_scale_range=(0.8, 1.2),
+            joint_position_noise=0.05,
+        )
+        client.reset_agent(randomization_cfg=randomization_cfg)
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    # Initial state randomization
+    pose_position_noise: Optional[tuple[float, float, float]] = Field(
+        default=None, description="[x, y, z] position noise std"
+    )
+    pose_orientation_noise: Optional[float] = Field(
+        default=None, description="Orientation noise std (radians)"
+    )
+    joint_position_noise: Optional[float] = Field(
+        default=None, description="Joint position noise std"
+    )
+    joint_velocity_noise: Optional[float] = Field(
+        default=None, description="Joint velocity noise std"
+    )
+
+    # Physics parameters (all [min, max] ranges)
+    friction_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Surface friction coefficient [min, max]"
+    )
+    restitution_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Bounce/restitution coefficient [min, max]"
+    )
+    mass_scale_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Body mass multiplier [min, max]"
+    )
+    com_offset_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Center of mass offset [min, max]"
+    )
+
+    # Motor/actuator randomization
+    motor_strength_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Motor strength multiplier [min, max]"
+    )
+    motor_offset_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Motor position offset [min, max]"
+    )
+
+    # External disturbances
+    push_interval_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Time between pushes [min, max]"
+    )
+    push_velocity_range: Optional[tuple[float, float]] = Field(
+        default=None, description="Push velocity magnitude [min, max]"
+    )
+
+    # Terrain configuration
+    terrain_type: Optional[str] = Field(
+        default=None, description="Terrain type identifier"
+    )
+    terrain_difficulty: Optional[float] = Field(
+        default=None, description="Terrain difficulty level"
+    )

luckyrobots/{utils/helpers.py → utils.py}

@@ -1,18 +1,87 @@
-import yaml
+"""
+Utility functions and classes for LuckyRobots.
+"""
+
 import time
+import yaml
 import importlib.resources
 from collections import deque
 
 
+class FPS:
+    """Utility for measuring frames per second with a rolling window.
+
+    Usage:
+        fps = FPS(frame_window=30)
+        while running:
+            # ... do work ...
+            current_fps = fps.measure()
+    """
+
+    def __init__(self, frame_window: int = 30):
+        """Initialize FPS counter.
+
+        Args:
+            frame_window: Number of frames to average over.
+        """
+        self.frame_window = frame_window
+        self.frame_times: deque[float] = deque(maxlen=frame_window)
+        self.last_frame_time = time.perf_counter()
+
+    def measure(self) -> float:
+        """Record a frame and return current FPS.
+
+        Returns:
+            Current frames per second (averaged over window).
+        """
+        current_time = time.perf_counter()
+        frame_delta = current_time - self.last_frame_time
+        self.last_frame_time = current_time
+
+        self.frame_times.append(frame_delta)
+
+        if len(self.frame_times) >= 2:
+            avg_frame_time = sum(self.frame_times) / len(self.frame_times)
+            return 1.0 / avg_frame_time if avg_frame_time > 0 else 0.0
+        return 0.0
+
+
+def get_robot_config(robot: str = None) -> dict:
+    """Get the configuration for a robot from robots.yaml.
+
+    Args:
+        robot: Robot name. If None, returns entire config.
+
+    Returns:
+        Robot configuration dict, or full config if robot is None.
+    """
+    with importlib.resources.files("luckyrobots").joinpath("config/robots.yaml").open(
+        "r"
+    ) as f:
+        config = yaml.safe_load(f)
+        if robot is not None:
+            return config[robot]
+        else:
+            return config
+
+
 def validate_params(
     scene: str = None,
     robot: str = None,
     task: str = None,
     observation_type: str = None,
-) -> bool:
-    """Validate the parameters passed into Lucky World"""
-    robot_config = get_robot_config(robot)
+) -> None:
+    """Validate parameters for launching LuckyEngine.
+
+    Args:
+        scene: Scene name.
+        robot: Robot name.
+        task: Task name.
+        observation_type: Observation type.
 
+    Raises:
+        ValueError: If any parameter is invalid.
+    """
     if scene is None:
         raise ValueError("Scene is required")
     if robot is None:
@@ -22,6 +91,8 @@ def validate_params(
     if observation_type is None:
         raise ValueError("Observation type is required")
 
+    robot_config = get_robot_config(robot)
+
     if scene not in robot_config["available_scenes"]:
         raise ValueError(f"Scene {scene} not available in {robot} config")
     if task not in robot_config["available_tasks"]:
@@ -30,39 +101,3 @@ def validate_params(
         raise ValueError(
             f"Observation type {observation_type} not available in {robot} config"
         )
-
-
-def get_robot_config(robot: str = None) -> dict:
-    """Get the configuration for the robot"""
-    with importlib.resources.files("luckyrobots").joinpath("config/robots.yaml").open(
-        "r"
-    ) as f:
-        config = yaml.safe_load(f)
-        if robot is not None:
-            return config[robot]
-        else:
-            return config
-
-
-class FPS:
-    def __init__(self, frame_window: int = 30):
-        self.frame_window = frame_window
-        self.frame_times = deque(maxlen=frame_window)
-        self.last_frame_time = time.perf_counter()
-
-    def measure(self) -> float:
-        current_time = time.perf_counter()
-        frame_delta = current_time - self.last_frame_time
-        self.last_frame_time = current_time
-
-        # Add frame time to rolling window
-        self.frame_times.append(frame_delta)
-
-        # Calculate FPS from average frame time
-        if len(self.frame_times) >= 2:  # Need at least 2 samples
-            avg_frame_time = sum(self.frame_times) / len(self.frame_times)
-            fps = 1.0 / avg_frame_time if avg_frame_time > 0 else 0
-        else:
-            fps = 0
-
-        print(f"FPS: {fps}")

luckyrobots-0.1.72.dist-info/METADATA

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: luckyrobots
+Version: 0.1.72
+Summary: Robotics-AI Training in Hyperrealistic Game Environments
+Project-URL: Homepage, https://github.com/luckyrobots/luckyrobots
+Project-URL: Documentation, https://luckyrobots.readthedocs.io
+Project-URL: Repository, https://github.com/luckyrobots/luckyrobots
+Project-URL: Issues, https://github.com/luckyrobots/luckyrobots/issues
+Author-email: Devrim Yasar <braces.verbose03@icloud.com>, Ethan Clark <ethan@luckyrobots.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: grpcio>=1.60.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: packaging>=23.0
+Requires-Dist: protobuf>=4.25.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: watchdog>=3.0.0
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img width="384" alt="Default_Logo_Horizontal@2x" src="https://github.com/user-attachments/assets/ae6ad53a-741e-4e7a-94cb-5a46a8e81398" />
+</p>
+
+<p align="center">
+   Infinite synthetic data generation for embodied AI
+</p>
+
+<div align="center">
+
+[![PyPI version](https://img.shields.io/pypi/v/luckyrobots.svg)](https://pypi.org/project/luckyrobots/)
+[![Documentation](https://img.shields.io/badge/docs-read%20the%20docs-blue)](https://luckyrobots.readthedocs.io)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/pypi/pyversions/luckyrobots)](https://pypi.org/project/luckyrobots/)
+[![Status](https://img.shields.io/badge/Status-Alpha-orange)](https://pypi.org/project/luckyrobots/)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Server-5865F2?logo=discord&logoColor=white)](https://discord.gg/5CH3wx3tAs)
+
+</div>
+
+https://github.com/user-attachments/assets/0ab2953d-b188-4af7-a225-71decdd2378c
+
+# Lucky Robots
+
+Hyperrealistic robotics simulation framework with Python API for embodied AI training and testing.
+
+<p align="center">
+  <img width="49%" alt="Bedroom environment in LuckyEngine" src="https://github.com/user-attachments/assets/279a7864-9a8b-453e-8567-3a174f5db8ab" />
+  <img width="49%" alt="Open floor plan in LuckyEngine" src="https://github.com/user-attachments/assets/68c72b97-98ab-42b0-a065-8a4247b014c7" />
+</p>
+
+## Quick Start
+
+1. **Download LuckyEngine** from our [releases page](https://github.com/luckyrobots/luckyrobots/releases/latest) and set the path:
+   ```bash
+   # Set environment variable (choose one method):
+
+   # Method 1: Set LUCKYENGINE_PATH directly to the executable
+   export LUCKYENGINE_PATH=/path/to/LuckyEngine      # Linux/Mac
+   export LUCKYENGINE_PATH=/path/to/LuckyEngine.exe  # Windows
+
+   # Method 2: Set LUCKYENGINE_HOME to the directory containing the executable
+   export LUCKYENGINE_HOME=/path/to/luckyengine/directory
+   ```
+
+2. **Install**
+   ```bash
+   pip install luckyrobots
+   ```
+
+3. **Run Example**
+   ```bash
+   git clone https://github.com/luckyrobots/luckyrobots.git
+   cd luckyrobots/examples
+   python controller.py --skip-launch  # If LuckyEngine is already running
+   ```
+
+## Basic Usage
+
+```python
+from luckyrobots import LuckyEngineClient
+
+# Connect to LuckyEngine
+client = LuckyEngineClient(
+    host="127.0.0.1",
+    port=50051,
+    robot_name="unitreego1",
+)
+client.wait_for_server()
+
+# Optional: Fetch schema for named observation access
+client.fetch_schema()
+
+# Get RL observation
+obs = client.get_observation()
+print(f"Observation: {obs.observation[:5]}...")  # Flat vector for RL
+print(f"Timestamp: {obs.timestamp_ms}")
+
+# Named access (if schema fetched)
+# obs["proj_grav_x"]  # Access by name
+# obs.to_dict()       # Convert to dict
+
+# Send controls
+client.send_control(controls=[0.1, 0.2, -0.1, ...])
+
+# Get joint state (separate from RL observation)
+joints = client.get_joint_state()
+print(f"Positions: {joints.positions}")
+print(f"Velocities: {joints.velocities}")
+```
+
+## API Overview
+
+### Core Classes
+
+**`LuckyEngineClient`** - Low-level gRPC client
+- `wait_for_server(timeout)` - Wait for LuckyEngine connection
+- `get_observation()` - Get RL observation vector
+- `get_joint_state()` - Get joint positions/velocities
+- `send_control(controls)` - Send actuator commands
+- `get_agent_schema()` - Get observation/action names and sizes
+- `reset_agent()` - Reset agent state
+
+**`LuckyRobots`** - High-level wrapper (launches LuckyEngine)
+- `start(scene, robot, task)` - Launch and connect
+- `get_observation()` - Get observation
+- `step(controls)` - Send controls and get next observation
+
+### Models
+
+```python
+from luckyrobots import ObservationResponse, StateSnapshot
+
+# ObservationResponse - returned by get_observation()
+obs.observation      # List[float] - flat RL observation vector
+obs.actions          # List[float] - last applied actions
+obs.timestamp_ms     # int - wall-clock timestamp
+obs.frame_number     # int - monotonic counter
+obs["name"]          # Named access (if schema fetched)
+obs.to_dict()        # Convert to name->value dict
+```
+
+## Available Robots & Environments
+
+### Robots
+- **unitreego1**: Quadruped robot
+- **so100**: 6-DOF manipulator with gripper
+- **stretch_v1**: Mobile manipulator
+
+### Scenes
+- **velocity**: Velocity control training
+- **kitchen**: Residential kitchen environment
+
+### Tasks
+- **locomotion**: Walking/movement
+- **pickandplace**: Object manipulation
+
+## Development
+
+### Setup with uv (recommended)
+
+```bash
+# Clone and enter repo
+git clone https://github.com/luckyrobots/luckyrobots.git
+cd luckyrobots
+
+# Install uv if you haven't
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Create venv and install deps
+uv sync
+
+# Run tests
+uv run pytest
+
+# Run example
+uv run python examples/controller.py --skip-launch
+```
+
+### Setup with pip
+
+```bash
+git clone https://github.com/luckyrobots/luckyrobots.git
+cd luckyrobots
+pip install -e ".[dev]"
+```
+
+### Regenerating gRPC Stubs
+
+The Python gRPC stubs are in `src/luckyrobots/grpc/generated/` and are
+generated from protos in `src/luckyrobots/grpc/proto/`.
+
+```bash
+python -m grpc_tools.protoc \
+  -I "src/luckyrobots/grpc/proto" \
+  --python_out="src/luckyrobots/grpc/generated" \
+  --grpc_python_out="src/luckyrobots/grpc/generated" \
+  src/luckyrobots/grpc/proto/*.proto
+```
+
+### Project Structure
+
+```
+src/luckyrobots/
+├── client.py            # LuckyEngineClient (main API)
+├── luckyrobots.py       # LuckyRobots high-level wrapper
+├── models/              # Pydantic models
+│   ├── observation.py   # ObservationResponse, StateSnapshot
+│   └── camera.py        # CameraData, CameraShape
+├── engine/              # Engine management
+├── grpc/                # gRPC internals
+│   ├── generated/       # Protobuf stubs
+│   └── proto/           # .proto files
+└── config/              # Robot configurations
+```
+
+### Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make changes and add tests
+4. Run `uv run ruff check .` and `uv run ruff format .`
+5. Submit a pull request
+
+## Architecture
+
+Lucky Robots uses gRPC for communication:
+
+- **LuckyEngine**: Physics + rendering backend (Unreal Engine + MuJoCo)
+- **Python client**: Connects via gRPC (default `127.0.0.1:50051`)
+
+### gRPC Services
+
+| Service | Status | Description |
+|---------|--------|-------------|
+| MujocoService | ✅ Working | Joint state, controls |
+| AgentService | ✅ Working | Observations, reset |
+| SceneService | 🚧 Placeholder | Scene inspection |
+| TelemetryService | 🚧 Placeholder | Telemetry streaming |
+| CameraService | 🚧 Placeholder | Camera frames |
+| ViewportService | 🚧 Placeholder | Viewport pixels |
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+## Support
+
+- **Issues**: [GitHub Issues](https://github.com/luckyrobots/luckyrobots/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/luckyrobots/luckyrobots/discussions)
+- **Discord**: [Community Server](https://discord.gg/5CH3wx3tAs)

luckyrobots-0.1.72.dist-info/RECORD

@@ -0,0 +1,47 @@
+luckyrobots/__init__.py,sha256=VWewiYhYbYCs1ZSD0KxozmG2jH2uLlBxsVgFIRivKTM,824
+luckyrobots/client.py,sha256=3F0p46FndJv02D_pSZkOn4j2tkjV6RX1ziCFFEaJsr4,36129
+luckyrobots/luckyrobots.py,sha256=-XkIt9h7si4GK_j5Wpknb7_h56CCWi8_d1woVMuIvxU,8957
+luckyrobots/utils.py,sha256=62BqpSRBFykVRMZ5Ti2F-yKRDoyU3UNHeesDF_PVCFc,2958
+luckyrobots/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+luckyrobots/config/robots.yaml,sha256=Wu2AgwhZxo9F-RLcqPJXHnqzjT8a0wR-rFBcecck_eE,5164
+luckyrobots/engine/__init__.py,sha256=-3r7aLueDF7eyumqIhTvYqS8ZNnVSJUJEHG4ybsKrjc,546
+luckyrobots/engine/check_updates.py,sha256=KGQHrj1LB0_vexktO01xx-ZvPOYKkto4VBb3H1KV7uI,7593
+luckyrobots/engine/download.py,sha256=vIb5T40Jk2BnfjPo0f4KgW14Om6P4_mvPpZ9JAlkVvg,4029
+luckyrobots/engine/manager.py,sha256=8vxSevaoXo-lw2G6y74lVc-Ms8xIELK0yLswydMiOQY,13388
+luckyrobots/grpc/__init__.py,sha256=hPh-X_FEus2sxrfQB2fQjD754X5bMaUFTWm3mZmUhe0,153
+luckyrobots/grpc/generated/__init__.py,sha256=u69M4E_2LwRQSD_n4wvQyMX7dryBCrIdsho59c52Crk,732
+luckyrobots/grpc/generated/agent_pb2.py,sha256=5rXekXme6u5KCtEtwjkhHkUyxrfxpMKutG4KPZqNr1U,7195
+luckyrobots/grpc/generated/agent_pb2_grpc.py,sha256=M9ZsjS1qhBm57-DVy6il_u_XeTpb6Qbntm45Rqp_f1k,10909
+luckyrobots/grpc/generated/camera_pb2.py,sha256=2UDkgzMYdDZ53euPfLAndeI7k4wI9QH_Dvwkay6TAB4,2623
+luckyrobots/grpc/generated/camera_pb2_grpc.py,sha256=hUXzsf2qCE-ffZzkF8El2UuuLu6nxjKSYPukId2uFP8,5278
+luckyrobots/grpc/generated/common_pb2.py,sha256=0eZTxqlsZdTrgp2hgLy-hdDNtac5U3kkS_D9UbVy0e8,2045
+luckyrobots/grpc/generated/common_pb2_grpc.py,sha256=MWix04c710srn9BtjDxa9-UkZz0wa-w8tB0EmYndSgg,886
+luckyrobots/grpc/generated/hazel_rpc_pb2.py,sha256=XB1nGSVTYhpulRpS8Ja44KaCV5s-l1t_FPV4DJ5_ak8,1716
+luckyrobots/grpc/generated/hazel_rpc_pb2_grpc.py,sha256=5bhVh5DmVDl2ZsdgN7mTnElDbgU142TOI1qm8a8eblw,889
+luckyrobots/grpc/generated/media_pb2.py,sha256=TtGdBub2Pj1vG_jJJIZnIZealLD0s98wZ4KgGIrcn2c,1827
+luckyrobots/grpc/generated/media_pb2_grpc.py,sha256=szeOZzqDnIBFEyjAtXEHNxytTb9hTvOkQj0PhvXumMM,885
+luckyrobots/grpc/generated/mujoco_pb2.py,sha256=Oq1AdZ0h-svs7ntlaDZ-zvQdTPsulnaE7YaINvBIBpM,3476
+luckyrobots/grpc/generated/mujoco_pb2_grpc.py,sha256=Rz8hyPvhB2nR-0Mej4Ly9ixbrdpPCxDafmL8H4x43Nk,8603
+luckyrobots/grpc/generated/scene_pb2.py,sha256=ZQyv_csWjB42WLfHNe8aQVMB5U9nQnJ7fY9enac9VGQ,5382
+luckyrobots/grpc/generated/scene_pb2_grpc.py,sha256=I7G2LqkKZwEPZV-gxWo_45ecBey-wuGZ26pwxlH0mGQ,12118
+luckyrobots/grpc/generated/telemetry_pb2.py,sha256=LgVtxJv7ovtqlrgxG375aXADGt3qXwgpsIhIkJ3pLKE,2790
+luckyrobots/grpc/generated/telemetry_pb2_grpc.py,sha256=8TuCSc7rnQZFNqhEPXUoJsWAnwvEvyyEI5GaqQUCSSs,5463
+luckyrobots/grpc/generated/viewport_pb2.py,sha256=Z_5gBD23z7He_OACYkaIsi0o4LIESzOG7o_rO1lRLVs,3093
+luckyrobots/grpc/generated/viewport_pb2_grpc.py,sha256=BkJqREcjIa3ZdNgZUxH_MvBWOte9VJJGi-KlFgYepog,5436
+luckyrobots/grpc/proto/agent.proto,sha256=SUVR9EqNz5gB5FNt3n54sNXv3SkvYgXKywlZmZh5vio,8506
+luckyrobots/grpc/proto/camera.proto,sha256=unLowpk4d0AGJgyKrbzTr1F_CxOV9dXRoXn-gO8eJVw,1097
+luckyrobots/grpc/proto/common.proto,sha256=zQPj-Z8b8mAE2_eHlJ0L2_-JH-CYY_OJcv8046fAtQM,772
+luckyrobots/grpc/proto/hazel_rpc.proto,sha256=gtFukd1B9WRbY2kWBgd5YQWSw4cobYf1YRYX6VEaULE,1229
+luckyrobots/grpc/proto/media.proto,sha256=3Rhmiaw1zceQBFdwxX1ViFgH-cSr7mBjNEGHPaFmTsk,836
+luckyrobots/grpc/proto/mujoco.proto,sha256=b7tBvYqqvcSjmqrEax6_75-P3fIHHZq63A1HVJKjx0U,1873
+luckyrobots/grpc/proto/scene.proto,sha256=ZypWsUzpgplGsQPP0FXJpyY4rSxgWYGsniM4vofhnak,3075
+luckyrobots/grpc/proto/telemetry.proto,sha256=PZiUoA0bpwuvsBUdoQQdBNGWOuhlBMKAiBpwqPZiJgY,1481
+luckyrobots/grpc/proto/viewport.proto,sha256=gunF8cIrVgvoAX8FNER6gw_u-IlRWAR1Q6ts0zUuqr8,1324
+luckyrobots/models/__init__.py,sha256=assqJIKZXvDGwCVM0grNLJCBWyHtKRBAaxdJb2dON10,332
+luckyrobots/models/camera.py,sha256=e-CftAndHASfokhtUtU7ujGb2q_kcXZ6-2KKvY42CKg,3682
+luckyrobots/models/observation.py,sha256=jbRiUTjOP2ZiSobsnNcks3aMPAJA6oPoKqiXwvrNQK0,4758
+luckyrobots/models/randomization.py,sha256=AicqHovzG97Ge33wtNQE-_EvKxndjEHguTjCiHfhAV8,2753
+luckyrobots-0.1.72.dist-info/METADATA,sha256=-liPc6bNv78N5A-PgTJ8YeiD5YIIU8BTO60zE-zV87Y,8379
+luckyrobots-0.1.72.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+luckyrobots-0.1.72.dist-info/licenses/LICENSE,sha256=xsPYvRJPH_fW_sofTUknI_KvZOsD4-BqjSOTZqI6Nmw,1069
+luckyrobots-0.1.72.dist-info/RECORD,,

{luckyrobots-0.1.66.dist-info → luckyrobots-0.1.72.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any