luckyrobots 0.1.68__py3-none-any.whl → 0.1.69__py3-none-any.whl

luckyrobots/{utils → engine}/download.py

@@ -1,42 +1,56 @@
+"""
+Download and update LuckyEngine executable files.
+
+This module handles downloading updates and applying changes to the LuckyEngine binary.
+"""
+
+import logging
 import os
 import platform
-import re
-import sys
-import zipfile
-from datetime import datetime
+from typing import Optional
 
 import requests
-from bs4 import BeautifulSoup
 from tqdm import tqdm
 
 from .check_updates import check_updates
 
-base_url = "https://builds.luckyrobots.xyz/"
+logger = logging.getLogger("luckyrobots.engine.download")
 
+BASE_URL = "https://builds.luckyrobots.xyz/"
 
-def get_base_url():
-    import requests
-    from requests.exceptions import RequestException
 
-    def is_server_active(url):
-        try:
-            response = requests.get(url, timeout=1)
-            return response.status_code == 200
-        except RequestException:
-            return False
+def get_base_url() -> str:
+    """
+    Get the base URL for downloads, checking local server first.
 
+    Returns:
+        Base URL string (local or remote).
+    """
     local_url = "http://192.168.1.148/builds"
     remote_url = "https://builds.luckyrobots.xyz"
 
-    if is_server_active(local_url):
-        print("Using local server:", local_url)
-        return local_url
-    else:
-        print("Using remote server:", remote_url)
-        return remote_url
+    try:
+        response = requests.get(local_url, timeout=1)
+        if response.status_code == 200:
+            logger.info(f"Using local server: {local_url}")
+            return local_url
+    except requests.RequestException:
+        pass
+
+    logger.info(f"Using remote server: {remote_url}")
+    return remote_url
+
+
+def get_os_type() -> str:
+    """
+    Get the operating system type as a string.
 
+    Returns:
+        "mac", "win", or "linux"
 
-def get_os_type():
+    Raises:
+        ValueError: If the OS is not supported.
+    """
     os_type = platform.system().lower()
     if os_type == "darwin":
         return "mac"
@@ -48,32 +62,40 @@ def get_os_type():
         raise ValueError(f"Unsupported operating system: {os_type}")
 
 
-def apply_changes(changes):
-    # Iterate through changes and handle each change type
+def apply_changes(changes: list[dict], binary_path: str = "./Binary") -> None:
+    """
+    Apply changes by downloading new/modified files and deleting removed files.
+
+    Args:
+        changes: List of change dictionaries with 'change_type', 'path', etc.
+        binary_path: Base path where binary files are stored.
+    """
+    base_url = get_base_url()
+    os_type = get_os_type()
+
     for item in changes:
-        if item["change_type"] in ["modified", "new_file"]:
-            # Check if the item is a directory
+        change_type = item.get("change_type")
+        item_path = os.path.join(binary_path, item["path"])
+
+        if change_type in ["modified", "new_file"]:
             if item.get("type") == "directory":
                 # Create the directory
-                item_path = os.path.join("./Binary", item["path"])
                 os.makedirs(item_path, exist_ok=True)
-                print(f"Created directory: {item_path}")
+                logger.debug(f"Created directory: {item_path}")
             else:
                 # Handle file download with progress bar
-                os_type = get_os_type()
                 file_url = f"{base_url}{os_type}/{item['path']}"
 
                 # Ensure the directory exists
-                item_path = os.path.join("./Binary", item["path"])
                 item_dir = os.path.dirname(item_path)
                 os.makedirs(item_dir, exist_ok=True)
 
                 # Download the file with progress bar
                 try:
-                    response = requests.get(file_url, stream=True)
+                    response = requests.get(file_url, stream=True, timeout=30)
                     response.raise_for_status()
                     total_size = int(response.headers.get("content-length", 0))
-                    # " ▁▂▃▄▅▆▇█"
+
                     with open(item_path, "wb") as f, tqdm(
                         desc=f"{item['path'][:8]}...{item['path'][-16:]}",
                         total=total_size,
@@ -85,19 +107,19 @@ def apply_changes(changes):
                         for data in response.iter_content(chunk_size=1024):
                             size = f.write(data)
                             progress_bar.update(size)
-                    # print(f"Downloaded: {item_path}")
+
+                    logger.debug(f"Downloaded: {item_path}")
                 except requests.RequestException as e:
-                    print(f"Error downloading {item_path}: {e}")
+                    logger.error(f"Error downloading {item_path}: {e}")
 
-        elif item["change_type"] == "deleted":
+        elif change_type == "deleted":
             # Delete the file or directory
-            item_path = os.path.join("./Binary", item["path"])
             try:
                 if os.path.isdir(item_path):
                     os.rmdir(item_path)
-                    print(f"Deleted directory: {item_path}")
+                    logger.debug(f"Deleted directory: {item_path}")
                 else:
                     os.remove(item_path)
-                    print(f"Deleted file: {item_path}")
+                    logger.debug(f"Deleted file: {item_path}")
             except OSError as e:
-                print(f"Error deleting {item_path}: {e}")
+                logger.error(f"Error deleting {item_path}: {e}")

luckyrobots/engine/manager.py

@@ -0,0 +1,427 @@
+"""
+LuckyEngine engine lifecycle management.
+
+This module handles launching, stopping, and managing the LuckyEngine executable.
+"""
+
+import logging
+import os
+import platform
+import subprocess
+import tempfile
+import threading
+import time
+from typing import Optional
+
+logger = logging.getLogger("luckyrobots.luckyengine")
+
+# Module-level state
+LOCK_FILE = os.path.join(tempfile.gettempdir(), "luckyengine_lock")
+_process: Optional[subprocess.Popen] = None
+_monitor_thread: Optional[threading.Thread] = None
+_shutdown_event = threading.Event()
+
+
+# ============================================================================
+# Public API
+# ============================================================================
+
+
+def find_luckyengine_executable() -> Optional[str]:
+    """
+    Automatically find LuckyEngine executable in common locations.
+
+    Checks in order:
+    1. LUCKYENGINE_PATH environment variable
+    2. LUCKYENGINE_HOME environment variable
+    3. System installation paths
+
+    Returns:
+        Path to executable if found, None otherwise.
+    """
+    is_wsl = "microsoft" in platform.uname().release.lower()
+
+    # 1. Check LUCKYENGINE_PATH environment variable (highest priority)
+    env_path = os.environ.get("LUCKYENGINE_PATH")
+    if env_path:
+        logger.info(f"Using LUCKYENGINE_PATH environment variable: {env_path}")
+        if os.path.exists(env_path):
+            return env_path
+        logger.warning(f"LUCKYENGINE_PATH points to non-existent file: {env_path}")
+
+    # 2. Check LUCKYENGINE_HOME environment variable
+    env_home = os.environ.get("LUCKYENGINE_HOME")
+    if env_home:
+        logger.info(f"Using LUCKYENGINE_HOME environment variable: {env_home}")
+        executable = _get_executable_for_platform(env_home, "LuckyEngine", is_wsl)
+        if executable and os.path.exists(executable):
+            return executable
+        logger.warning(f"LUCKYENGINE_HOME does not contain executable: {executable}")
+
+    # 3. System installation paths
+    system_paths = _get_system_paths(is_wsl)
+    for path in system_paths:
+        if os.path.exists(path):
+            logger.info(f"Found LuckyEngine at: {path}")
+            return path
+
+    return None
+
+
+def is_luckyengine_running() -> bool:
+    """
+    Check if LuckyEngine is currently running.
+
+    Returns:
+        True if lock file exists, False otherwise.
+    """
+    return os.path.exists(LOCK_FILE)
+
+
+def launch_luckyengine(
+    scene: str = "ArmLevel",
+    robot: str = "so100",
+    task: Optional[str] = None,
+    executable_path: Optional[str] = None,
+    headless: bool = False,
+    windowed: bool = True,
+    verbose: bool = False,
+) -> bool:
+    """
+    Launch LuckyEngine with the specified parameters.
+
+    Args:
+        scene: Scene name to load.
+        robot: Robot name to spawn.
+        task: Optional task name.
+        executable_path: Path to executable (auto-detected if None).
+        headless: Run without rendering.
+        windowed: Run in windowed mode (vs fullscreen).
+        verbose: Show engine output.
+
+    Returns:
+        True if launch succeeded, False otherwise.
+    """
+    global _process, _monitor_thread
+
+    # Check if already running
+    if is_luckyengine_running():
+        logger.error(
+            "LuckyEngine is already running. "
+            "Stop the existing instance or remove the lock file at "
+            f"{LOCK_FILE}"
+        )
+        return False
+
+    # Find executable if not provided
+    if executable_path is None:
+        executable_path = find_luckyengine_executable()
+        if executable_path is None:
+            logger.error(
+                "Could not find LuckyEngine executable. "
+                "Please provide the path manually."
+            )
+            logger.info("You can set the path using environment variables:")
+            logger.info("  LUCKYENGINE_PATH=/full/path/to/LuckyEngine.exe")
+            logger.info("  LUCKYENGINE_HOME=/path/to/luckyengine/directory")
+            return False
+
+    if not os.path.exists(executable_path):
+        logger.error(f"Executable not found at: {executable_path}")
+        return False
+
+    try:
+        # Set execute permissions on Unix systems
+        if platform.system() != "Windows":
+            os.chmod(executable_path, 0o755)
+
+        logger.info(f"Launching LuckyEngine: {executable_path}")
+
+        # Build command
+        command = [executable_path]
+        command.append(f"-Scene={scene}")
+        command.append(f"-Robot={robot}")
+
+        if task:
+            command.append(f"-Task={task}")
+
+        if headless:
+            command.append("-Headless")
+        else:
+            if windowed:
+                command.append("-windowed")
+            else:
+                command.append("-fullscreen")
+
+        command.append("-Realtime")
+
+        logger.info(f"Command: {' '.join(command)}")
+
+        # Launch process
+        if platform.system() == "Windows":
+            DETACHED_PROCESS = 0x00000008
+            _process = subprocess.Popen(
+                command,
+                creationflags=DETACHED_PROCESS,
+                close_fds=True,
+                stdout=None if verbose else subprocess.DEVNULL,
+                stderr=None if verbose else subprocess.DEVNULL,
+            )
+        else:
+            _process = subprocess.Popen(
+                command,
+                start_new_session=True,
+                stdout=None if verbose else subprocess.DEVNULL,
+                stderr=None if verbose else subprocess.DEVNULL,
+            )
+
+        # Start monitoring
+        _shutdown_event.clear()
+        _monitor_thread = threading.Thread(target=monitor_process, daemon=True)
+        _monitor_thread.start()
+
+        create_lock_file(_process.pid)
+
+        logger.info(f"LuckyEngine started successfully (PID: {_process.pid})")
+        logger.info(f"Scene: {scene}, Robot: {robot}, Task: {task or 'None'}")
+
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to launch LuckyEngine: {e}")
+        stop_luckyengine()
+        return False
+
+
+def stop_luckyengine() -> bool:
+    """
+    Stop the running LuckyEngine instance.
+
+    Returns:
+        True if stopped successfully, False otherwise.
+    """
+    global _process
+
+    if not is_luckyengine_running():
+        logger.info("LuckyEngine is not running")
+        return True
+
+    try:
+        if _process:
+            logger.info("Stopping LuckyEngine...")
+
+            try:
+                _process.terminate()
+                _process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                logger.info("Graceful termination timeout, using kill_processes...")
+            except Exception:
+                logger.info("Graceful termination failed, using kill_processes...")
+
+            kill_processes()
+
+        remove_lock_file()
+        return True
+    except Exception as e:
+        logger.error(f"Error stopping LuckyEngine: {e}")
+        return False
+
+
+# ============================================================================
+# Private Helpers
+# ============================================================================
+
+
+def _get_executable_for_platform(
+    home_dir: str, base_name: str, is_wsl: bool
+) -> Optional[str]:
+    """Get the executable path for the current platform."""
+    if platform.system() == "Linux" and not is_wsl:
+        return os.path.join(home_dir, f"{base_name}.sh")
+    elif platform.system() == "Darwin":
+        return os.path.join(
+            home_dir, f"{base_name}.app", "Contents", "MacOS", base_name
+        )
+    else:  # Windows or WSL2
+        return os.path.join(home_dir, f"{base_name}.exe")
+
+
+def _get_system_paths(is_wsl: bool) -> list[str]:
+    """Get system installation paths for the current platform."""
+    paths = []
+
+    if platform.system() == "Linux" and not is_wsl:
+        paths.extend(
+            [
+                "/opt/LuckyEngine/LuckyEngine.sh",
+                "/usr/local/bin/LuckyEngine.sh",
+                os.path.expanduser("~/.local/share/LuckyEngine/LuckyEngine.sh"),
+                os.path.expanduser("~/LuckyEngine/LuckyEngine.sh"),
+            ]
+        )
+    elif platform.system() == "Darwin":
+        paths.extend(
+            [
+                "/Applications/LuckyEngine/LuckyEngine.app/Contents/MacOS/LuckyEngine",
+                os.path.expanduser(
+                    "~/Applications/LuckyEngine/LuckyEngine.app/Contents/MacOS/LuckyEngine"
+                ),
+            ]
+        )
+    else:  # Windows or WSL2
+        paths.extend(
+            [
+                "C:\\Program Files\\LuckyEngine\\LuckyEngine.exe",
+                "C:\\Program Files (x86)\\LuckyEngine\\LuckyEngine.exe",
+                os.path.expanduser("~\\AppData\\Local\\LuckyEngine\\LuckyEngine.exe"),
+            ]
+        )
+
+        if is_wsl:
+            paths.extend(
+                [
+                    "/mnt/c/Program Files/LuckyEngine/LuckyEngine.exe",
+                    "/mnt/c/Program Files (x86)/LuckyEngine/LuckyEngine.exe",
+                ]
+            )
+
+    return paths
+
+
+def monitor_process() -> None:
+    """Monitor the LuckyEngine process and handle its termination."""
+    global _process
+    try:
+        while not _shutdown_event.is_set():
+            if _process is None or _process.poll() is not None:
+                logger.info("LuckyEngine process has terminated")
+                break
+            time.sleep(1)
+    except Exception as e:
+        logger.error(f"Error in process monitor: {e}")
+    finally:
+        # Ensure cleanup happens when monitoring stops
+        if not _shutdown_event.is_set():
+            remove_lock_file()
+
+
+def create_lock_file(pid: int) -> None:
+    """Create a lock file with the process ID."""
+    with open(LOCK_FILE, "w") as f:
+        f.write(str(pid))
+
+
+def remove_lock_file() -> None:
+    """Remove the lock file."""
+    try:
+        if os.path.exists(LOCK_FILE):
+            os.remove(LOCK_FILE)
+            logger.debug("Lock file removed successfully")
+        else:
+            logger.debug("Lock file doesn't exist, nothing to remove")
+    except Exception as e:
+        logger.error(f"Error removing lock file: {e}")
+
+
+def kill_processes() -> None:
+    """Kill all LuckyEngine processes."""
+    system = platform.system()
+    is_wsl = "microsoft" in platform.uname().release.lower()
+
+    if is_wsl:
+        _kill_wsl_processes()
+    elif system == "Windows":
+        _kill_windows_processes()
+    elif system == "Darwin":
+        _kill_macos_processes()
+    else:
+        _kill_linux_processes()
+
+
+def _kill_wsl_processes() -> None:
+    """Kill LuckyEngine processes on WSL."""
+    try:
+        result = subprocess.run(
+            [
+                "/mnt/c/Windows/System32/taskkill.exe",
+                "/F",
+                "/IM",
+                "LuckyEngine.exe",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            logger.info("Killed LuckyEngine.exe processes")
+        elif result.returncode == 128:  # Process not found
+            logger.debug("No LuckyEngine processes found running")
+    except Exception as e:
+        logger.debug(f"Error killing WSL processes: {e}")
+
+
+def _kill_windows_processes() -> None:
+    """Kill LuckyEngine processes on Windows."""
+    try:
+        result = subprocess.run(
+            ["taskkill", "/F", "/IM", "LuckyEngine.exe"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            logger.info("Successfully killed LuckyEngine.exe processes")
+        elif result.returncode == 128:  # Process not found
+            logger.info("No LuckyEngine processes found")
+    except Exception as e:
+        logger.debug(f"Error killing Windows processes: {e}")
+
+
+def _kill_macos_processes() -> None:
+    """Kill LuckyEngine processes on macOS."""
+    try:
+        result = subprocess.run(
+            ["pkill", "-f", "LuckyEngine"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode == 0:
+            logger.info("Successfully killed LuckyEngine processes")
+        elif result.returncode == 1:  # No processes found
+            logger.info("No LuckyEngine processes found")
+        else:
+            logger.warning(f"pkill failed: {result.stderr}")
+
+    except subprocess.TimeoutExpired:
+        logger.error("pkill command timed out")
+    except FileNotFoundError:
+        logger.error("pkill command not found")
+    except Exception as e:
+        logger.error(f"Failed to kill macOS processes: {e}")
+
+
+def _kill_linux_processes() -> None:
+    """Kill LuckyEngine processes on Linux."""
+    try:
+        result = subprocess.run(
+            ["pkill", "-f", "LuckyEngine"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode == 0:
+            logger.info("Successfully killed LuckyEngine processes")
+        elif result.returncode == 1:  # No processes found
+            logger.info("No LuckyEngine processes found")
+        else:
+            logger.warning(f"pkill failed: {result.stderr}")
+
+    except subprocess.TimeoutExpired:
+        logger.error("pkill command timed out")
+    except FileNotFoundError:
+        logger.error("pkill command not found")
+    except Exception as e:
+        logger.error(f"Failed to kill Linux processes: {e}")

luckyrobots/grpc/__init__.py

@@ -0,0 +1,6 @@
+"""
+gRPC generated stubs for LuckyEngine.
+
+This module contains the generated protobuf stubs. The client implementation
+is in luckyrobots/client.py.
+"""

luckyrobots/grpc/generated/__init__.py

@@ -0,0 +1,18 @@
+"""Checked-in generated gRPC stubs for the LuckyEngine `.proto` files.
+
+Regenerate with:
+  python -m grpc_tools.protoc -I src/luckyrobots/rpc/proto \
+    --python_out=src/luckyrobots/rpc/generated \
+    --grpc_python_out=src/luckyrobots/rpc/generated \
+    src/luckyrobots/rpc/proto/common.proto \
+    src/luckyrobots/rpc/proto/media.proto \
+    src/luckyrobots/rpc/proto/scene.proto \
+    src/luckyrobots/rpc/proto/mujoco.proto \
+    src/luckyrobots/rpc/proto/telemetry.proto \
+    src/luckyrobots/rpc/proto/agent.proto \
+    src/luckyrobots/rpc/proto/viewport.proto \
+    src/luckyrobots/rpc/proto/camera.proto
+
+Then adjust imports in the generated `*_pb2.py` and `*_pb2_grpc.py` to be
+package-relative (`from . import ...`).
+"""

luckyrobots/grpc/generated/agent_pb2.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: agent.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC, 6, 31, 1, "", "agent.proto"
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from . import common_pb2 as common__pb2
+from . import media_pb2 as media__pb2
+from . import mujoco_pb2 as mujoco__pb2
+from . import telemetry_pb2 as telemetry__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x0b\x61gent.proto\x12\x0chazel.rpc.v1\x1a\x0c\x63ommon.proto\x1a\x0bmedia.proto\x1a\x0cmujoco.proto\x1a\x0ftelemetry.proto"\x81\x01\n\x0b\x41gentSchema\x12\x12\n\nagent_name\x18\x01 \x01(\t\x12\x19\n\x11observation_names\x18\x02 \x03(\t\x12\x14\n\x0c\x61\x63tion_names\x18\x03 \x03(\t\x12\x18\n\x10observation_size\x18\x04 \x01(\r\x12\x13\n\x0b\x61\x63tion_size\x18\x05 \x01(\r"+\n\x15GetAgentSchemaRequest\x12\x12\n\nagent_name\x18\x01 \x01(\t"C\n\x16GetAgentSchemaResponse\x12)\n\x06schema\x18\x01 \x01(\x0b\x32\x19.hazel.rpc.v1.AgentSchema"<\n\x12StreamAgentRequest\x12\x12\n\nagent_name\x18\x01 \x01(\t\x12\x12\n\ntarget_fps\x18\x02 \x01(\r"\'\n\x11ResetAgentRequest\x12\x12\n\nagent_name\x18\x01 \x01(\t"6\n\x12ResetAgentResponse\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x0f\n\x07message\x18\x02 \x01(\t"\x87\x01\n\nAgentFrame\x12\x14\n\x0ctimestamp_ms\x18\x01 \x01(\x04\x12\x14\n\x0c\x66rame_number\x18\x02 \x01(\r\x12\x14\n\x0cobservations\x18\x03 \x03(\x02\x12\x0f\n\x07\x61\x63tions\x18\x04 \x03(\x02\x12\x12\n\nagent_name\x18\x05 \x01(\t\x12\x12\n\ntarget_fps\x18\x06 \x01(\r"\x8a\x01\n\x15GetCameraFrameRequest\x12$\n\x02id\x18\x01 \x01(\x0b\x32\x16.hazel.rpc.v1.EntityIdH\x00\x12\x0e\n\x04name\x18\x02 \x01(\tH\x00\x12\r\n\x05width\x18\x03 \x01(\r\x12\x0e\n\x06height\x18\x04 \x01(\r\x12\x0e\n\x06\x66ormat\x18\x05 \x01(\tB\x0c\n\nidentifier"_\n\x17GetViewportFrameRequest\x12\x15\n\rviewport_name\x18\x01 \x01(\t\x12\r\n\x05width\x18\x02 \x01(\r\x12\x0e\n\x06height\x18\x03 \x01(\r\x12\x0e\n\x06\x66ormat\x18\x04 \x01(\t"\x84\x02\n\x15GetObservationRequest\x12\x12\n\nrobot_name\x18\x01 \x01(\t\x12\x12\n\nagent_name\x18\x02 \x01(\t\x12\x1b\n\x13include_joint_state\x18\x03 \x01(\x08\x12\x1b\n\x13include_agent_frame\x18\x04 \x01(\x08\x12\x19\n\x11include_telemetry\x18\x05 \x01(\x08\x12\x34\n\x07\x63\x61meras\x18\x06 \x03(\x0b\x32#.hazel.rpc.v1.GetCameraFrameRequest\x12\x38\n\tviewports\x18\x07 \x03(\x0b\x32%.hazel.rpc.v1.GetViewportFrameRequest"\xe3\x02\n\x16GetObservationResponse\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x0f\n\x07message\x18\x02 \x01(\t\x12\x14\n\x0ctimestamp_ms\x18\x03 \x01(\x04\x12\x14\n\x0c\x66rame_number\x18\x04 \x01(\r\x12-\n\x0bjoint_state\x18\x05 \x01(\x0b\x32\x18.hazel.rpc.v1.JointState\x12-\n\x0b\x61gent_frame\x18\x06 \x01(\x0b\x32\x18.hazel.rpc.v1.AgentFrame\x12/\n\ttelemetry\x18\x07 \x01(\x0b\x32\x1c.hazel.rpc.v1.TelemetryFrame\x12\x34\n\rcamera_frames\x18\x08 \x03(\x0b\x32\x1d.hazel.rpc.v1.NamedImageFrame\x12\x36\n\x0fviewport_frames\x18\t \x03(\x0b\x32\x1d.hazel.rpc.v1.NamedImageFrame2\xe6\x02\n\x0c\x41gentService\x12[\n\x0eGetAgentSchema\x12#.hazel.rpc.v1.GetAgentSchemaRequest\x1a$.hazel.rpc.v1.GetAgentSchemaResponse\x12[\n\x0eGetObservation\x12#.hazel.rpc.v1.GetObservationRequest\x1a$.hazel.rpc.v1.GetObservationResponse\x12K\n\x0bStreamAgent\x12 .hazel.rpc.v1.StreamAgentRequest\x1a\x18.hazel.rpc.v1.AgentFrame0\x01\x12O\n\nResetAgent\x12\x1f.hazel.rpc.v1.ResetAgentRequest\x1a .hazel.rpc.v1.ResetAgentResponseB\x03\xf8\x01\x01\x62\x06proto3'
+)
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "agent_pb2", _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+    _globals["DESCRIPTOR"]._loaded_options = None
+    _globals["DESCRIPTOR"]._serialized_options = b"\370\001\001"
+    _globals["_AGENTSCHEMA"]._serialized_start = 88
+    _globals["_AGENTSCHEMA"]._serialized_end = 217
+    _globals["_GETAGENTSCHEMAREQUEST"]._serialized_start = 219
+    _globals["_GETAGENTSCHEMAREQUEST"]._serialized_end = 262
+    _globals["_GETAGENTSCHEMARESPONSE"]._serialized_start = 264
+    _globals["_GETAGENTSCHEMARESPONSE"]._serialized_end = 331
+    _globals["_STREAMAGENTREQUEST"]._serialized_start = 333
+    _globals["_STREAMAGENTREQUEST"]._serialized_end = 393
+    _globals["_RESETAGENTREQUEST"]._serialized_start = 395
+    _globals["_RESETAGENTREQUEST"]._serialized_end = 434
+    _globals["_RESETAGENTRESPONSE"]._serialized_start = 436
+    _globals["_RESETAGENTRESPONSE"]._serialized_end = 490
+    _globals["_AGENTFRAME"]._serialized_start = 493
+    _globals["_AGENTFRAME"]._serialized_end = 628
+    _globals["_GETCAMERAFRAMEREQUEST"]._serialized_start = 631
+    _globals["_GETCAMERAFRAMEREQUEST"]._serialized_end = 769
+    _globals["_GETVIEWPORTFRAMEREQUEST"]._serialized_start = 771
+    _globals["_GETVIEWPORTFRAMEREQUEST"]._serialized_end = 866
+    _globals["_GETOBSERVATIONREQUEST"]._serialized_start = 869
+    _globals["_GETOBSERVATIONREQUEST"]._serialized_end = 1129
+    _globals["_GETOBSERVATIONRESPONSE"]._serialized_start = 1132
+    _globals["_GETOBSERVATIONRESPONSE"]._serialized_end = 1487
+    _globals["_AGENTSERVICE"]._serialized_start = 1490
+    _globals["_AGENTSERVICE"]._serialized_end = 1848
+# @@protoc_insertion_point(module_scope)