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

luckyrobots/models/observation.py

@@ -1,12 +1,6 @@
-"""
-RL observation models for LuckyRobots.
+"""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 typing import Dict, List, Optional
 from pydantic import BaseModel, Field, ConfigDict
 
 
@@ -14,11 +8,11 @@ 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
+    LuckyEngineClient.step(). It contains the RL observation vector
     with optional named access for debugging.
 
     Usage:
-        obs = client.get_observation()
+        obs = client.step(actions)
 
         # Flat vector for RL training
         obs.observation  # [0.1, 0.2, 0.3, ...]
@@ -110,26 +104,3 @@ class ObservationResponse(BaseModel):
         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/utils.py

@@ -1,49 +1,7 @@
-"""
-Utility functions and classes for LuckyRobots.
-"""
+"""Utility functions 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:

{luckyrobots-0.1.72.dist-info → luckyrobots-0.1.74.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luckyrobots
-Version: 0.1.72
+Version: 0.1.74
 Summary: Robotics-AI Training in Hyperrealistic Game Environments
 Project-URL: Homepage, https://github.com/luckyrobots/luckyrobots
 Project-URL: Documentation, https://luckyrobots.readthedocs.io

luckyrobots-0.1.74.dist-info/RECORD

@@ -0,0 +1,46 @@
+luckyrobots/__init__.py,sha256=cjma4V6iH-1QWWkt9n9Y9JD8LZJgmTIXP7eE9RT2ylw,469
+luckyrobots/client.py,sha256=ueaJAZbr5mTMwVA5WPV8yNP0aBbQEdkmFWjB5S5Qv_o,22697
+luckyrobots/luckyrobots.py,sha256=-XkIt9h7si4GK_j5Wpknb7_h56CCWi8_d1woVMuIvxU,8957
+luckyrobots/utils.py,sha256=deh0OV3I6Tr6V1s0yWs4jtchsZK1vKySpUohLjqOF1I,1769
+luckyrobots/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+luckyrobots/config/robots.yaml,sha256=-O39zJ_6lVfNnqdeVLpeY0no8EMlUQ2LpAopNc98XX4,6792
+luckyrobots/engine/__init__.py,sha256=OsyOgAnLtOfpRDHXa3Gzc1fRhJA8EfKvRkzijF6iRc8,403
+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=_aLCb8E5k66XX4RLqU-YgJ7uEvyDSmZLkMmm3Vkn4K4,7167
+luckyrobots/grpc/generated/agent_pb2_grpc.py,sha256=C6qSQMkxrERJsd5Rh_IHbOdURlgKlke8fKZ85edQa4I,10902
+luckyrobots/grpc/generated/camera_pb2.py,sha256=qs436_cLtRx4OPV1WsUMvaJ7NvRnRkQUrDDIr1wmoAY,2609
+luckyrobots/grpc/generated/camera_pb2_grpc.py,sha256=Lx3rmamWMWrkPIDN9tdQU_o4VKd3ETD9Z6h2WHSr7Aw,5264
+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/debug_pb2.py,sha256=1kUalIszt1IA5G3DJzB7nlfQhjdoA9UodPOKFMPmyuM,3525
+luckyrobots/grpc/generated/debug_pb2_grpc.py,sha256=aVlc6AAUuPhqzBOTV6KG5bA_n21eRcXNmTrCKUVvGGI,3310
+luckyrobots/grpc/generated/hazel_rpc_pb2.py,sha256=hcT_OZjzlm1Jz6azZCxfHXn3RlcIXoCoc7CYCgf71RY,1719
+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=xEqQ3jGUcAl2SreJgOPz9nb6We4j84OuIy2CysU0SS8,8596
+luckyrobots/grpc/generated/scene_pb2.py,sha256=Qz31l9ietwNFuqTkmd8GsHc_lO4MacuEycxtsE6gJBc,5375
+luckyrobots/grpc/generated/scene_pb2_grpc.py,sha256=ruawWs3hqZFQ_SoMqu75Sdn-v2YpjF5eajPkkcYUmfU,12111
+luckyrobots/grpc/generated/telemetry_pb2.py,sha256=LgVtxJv7ovtqlrgxG375aXADGt3qXwgpsIhIkJ3pLKE,2790
+luckyrobots/grpc/generated/telemetry_pb2_grpc.py,sha256=hS_ZJeM7DUlUQ4LERHWp704tCQV-0Dwa_M0sscUNxZI,5456
+luckyrobots/grpc/generated/viewport_pb2.py,sha256=MV6QIFJUM-DxpZ8IpnBis4OUAcq8fu7FfROv_iguqb4,3086
+luckyrobots/grpc/generated/viewport_pb2_grpc.py,sha256=xfqmEz_C0_XQl5LRkbxyB4ekyFkup99IbrlrB_S_2aE,5422
+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/debug.proto,sha256=AGo7r3dyYr1Z5h0U5ZFGBn4yZwRAjtew_eyfWgsfvf0,1558
+luckyrobots/grpc/proto/hazel_rpc.proto,sha256=DV_fvdiXkxoiEWnqlrGvfnBCG6TfJ2ei9vZs9pJESCM,1251
+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=h_PFZ1OgJnHXfQBqO8_ULB8szCKrGA4lMfmBGZgtIDc,126
+luckyrobots/models/observation.py,sha256=H45zargSOMR4c-zPupbXNplWBTBfGdG-oQbib203eCY,3620
+luckyrobots-0.1.74.dist-info/METADATA,sha256=oQWvQJoYt3O_C2XQs1-lZbKamuJDAKQZhTIpvQJBq9w,8379
+luckyrobots-0.1.74.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+luckyrobots-0.1.74.dist-info/licenses/LICENSE,sha256=xsPYvRJPH_fW_sofTUknI_KvZOsD4-BqjSOTZqI6Nmw,1069
+luckyrobots-0.1.74.dist-info/RECORD,,

luckyrobots/engine/check_updates.py

@@ -1,264 +0,0 @@
-"""
-Check for LuckyEngine executable updates.
-
-This module compares local and remote file structures to detect changes.
-"""
-
-import json
-import logging
-import mimetypes
-import os
-import platform
-import re
-import sys
-import zlib
-from typing import Optional
-from urllib.parse import urljoin
-
-import requests
-
-logger = logging.getLogger("luckyrobots.engine.check_updates")
-
-BASE_URL = "https://builds.luckyrobots.xyz/"
-
-
-def get_os_type() -> str:
-    """
-    Get the operating system type as a string.
-
-    Returns:
-        "mac", "win", or "linux"
-
-    Raises:
-        ValueError: If the OS is not supported.
-    """
-    os_type = platform.system().lower()
-    if os_type == "darwin":
-        return "mac"
-    elif os_type == "windows":
-        return "win"
-    elif os_type == "linux":
-        return "linux"
-    else:
-        raise ValueError(f"Unsupported operating system: {os_type}")
-
-
-def calculate_crc32(file_path: str) -> int:
-    """
-    Calculate CRC32 checksum for a file.
-
-    Args:
-        file_path: Path to the file.
-
-    Returns:
-        CRC32 checksum as unsigned 32-bit integer.
-    """
-    crc32 = 0
-    with open(file_path, "rb") as file:
-        while True:
-            data = file.read(65536)  # Read in 64kb chunks
-            if not data:
-                break
-            crc32 = zlib.crc32(data, crc32)
-    return crc32 & 0xFFFFFFFF  # Ensure unsigned 32-bit integer
-
-
-def scan_directory(root_path: str) -> list[dict]:
-    """
-    Scan a directory and create a file structure representation.
-
-    Args:
-        root_path: Root directory to scan.
-
-    Returns:
-        List of dictionaries containing file/directory metadata.
-    """
-    file_structure = []
-
-    for dirpath, dirnames, filenames in os.walk(root_path):
-        # Add directories
-        for dirname in dirnames:
-            dir_path = os.path.join(dirpath, dirname)
-            relative_path = os.path.relpath(dir_path, root_path)
-            file_structure.append(
-                {
-                    "path": relative_path,
-                    "type": "directory",
-                    "size": 0,
-                    "mtime": os.path.getmtime(dir_path),
-                    "crc32": 0,
-                    "mime_type": "directory",
-                }
-            )
-
-        # Add files
-        for filename in filenames:
-            file_path = os.path.join(dirpath, filename)
-            relative_path = os.path.relpath(file_path, root_path)
-            file_stat = os.stat(file_path)
-
-            # Guess the file type using mimetypes
-            file_type, _ = mimetypes.guess_type(file_path)
-            if file_type is None:
-                file_type = "application/octet-stream"
-
-            file_structure.append(
-                {
-                    "path": relative_path,
-                    "crc32": calculate_crc32(file_path),
-                    "size": file_stat.st_size,
-                    "mtime": file_stat.st_mtime,
-                    "type": "file",
-                    "mime_type": file_type,
-                }
-            )
-
-    return file_structure
-
-
-def save_json(data: dict, filename: str) -> None:
-    """Save data to a JSON file."""
-    with open(filename, "w") as f:
-        json.dump(data, f, indent=2)
-
-
-def load_json(filename: str) -> dict:
-    """Load data from a JSON file."""
-    with open(filename, "r") as f:
-        return json.load(f)
-
-
-def clean_path(path: str) -> tuple[str, Optional[str]]:
-    """
-    Clean and parse a path string.
-
-    Args:
-        path: Path string to clean.
-
-    Returns:
-        Tuple of (directory_path, attribute_name).
-    """
-    # Remove ['children'] and quotes, replace '][' with '/'
-    cleaned = re.sub(r"\['children'\]", "", path).replace("']['", "/").strip("[]'")
-    # Replace remaining single quotes with nothing
-    cleaned = cleaned.replace("'", "")
-    # Split the path and the attribute that changed
-    parts = cleaned.rsplit("/", 1)
-    return parts[0], parts[1] if len(parts) > 1 else None
-
-
-def compare_structures(
-    client_structure: list[dict], server_structure: list[dict]
-) -> list[dict]:
-    """
-    Compare two file structures and return list of changes.
-
-    Args:
-        client_structure: Local file structure.
-        server_structure: Remote file structure.
-
-    Returns:
-        List of changes (new, modified, deleted files).
-    """
-    dict1 = {item["path"]: item for item in client_structure}
-    dict2 = {item["path"]: item for item in server_structure}
-
-    result = []
-
-    # Check for new and modified items
-    for path, item in dict2.items():
-        if path not in dict1:
-            item["change_type"] = "new_file"
-            result.append(item)
-        elif item["type"] == "file" and item["crc32"] != dict1[path]["crc32"]:
-            item["change_type"] = "modified"
-            result.append(item)
-
-    # Check for deleted items
-    for path, item in dict1.items():
-        if path not in dict2:
-            item["change_type"] = "deleted"
-            result.append(item)
-
-    # Remove hashmap.json from changes (it's metadata)
-    result = [item for item in result if item["path"] != "hashmap.json"]
-
-    return result
-
-
-def scan_server(server_path: str) -> None:
-    """
-    Scan server directory structure and save hashmap files.
-
-    Args:
-        server_path: Path to server root directory.
-    """
-    mac_path = os.path.join(server_path, "mac")
-    win_path = os.path.join(server_path, "win")
-    linux_path = os.path.join(server_path, "linux")
-
-    mac_structure = scan_directory(mac_path)
-    win_structure = scan_directory(win_path)
-    linux_structure = scan_directory(linux_path)
-
-    save_json(mac_structure, os.path.join(server_path, "mac/hashmap.json"))
-    save_json(win_structure, os.path.join(server_path, "win/hashmap.json"))
-    save_json(linux_structure, os.path.join(server_path, "linux/hashmap.json"))
-
-
-def check_updates(root_path: str, base_url: Optional[str] = None) -> list[dict]:
-    """
-    Check for updates by comparing local and remote file structures.
-
-    Args:
-        root_path: Local root directory to check.
-        base_url: Base URL for remote server (uses default if None).
-
-    Returns:
-        List of changes detected.
-    """
-    if base_url is None:
-        base_url = BASE_URL
-
-    os_type = get_os_type()
-    url = urljoin(base_url, f"{os_type}/hashmap.json")
-
-    # Download the JSON file
-    try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        server_structure = response.json()
-    except requests.RequestException as e:
-        logger.warning(f"Error downloading JSON file: {e}")
-        server_structure = None
-
-    if server_structure is None:
-        logger.info("Using local scan as no remote file could be downloaded.")
-        server_structure = {}
-
-    # Scan the directory and create a new file structure
-    client_structure = scan_directory(root_path)
-
-    # Compare and return changes
-    if server_structure:
-        changes = compare_structures(client_structure, server_structure)
-        return changes
-    else:
-        logger.info("No server structure available for comparison.")
-        return []
-
-
-if __name__ == "__main__":
-    # This is used as a cron job on the main server to keep file structures up to date
-    lr_server_root = None
-
-    for arg in sys.argv:
-        if arg.startswith("--lr-server-root="):
-            lr_server_root = arg.split("=", 1)[1]
-            break
-
-    if lr_server_root:
-        logger.info(f"Scanning server at {lr_server_root}")
-        scan_server(lr_server_root)
-    else:
-        logger.error("--lr-server-root argument required")

luckyrobots/engine/download.py

@@ -1,125 +0,0 @@
-"""
-Download and update LuckyEngine executable files.
-
-This module handles downloading updates and applying changes to the LuckyEngine binary.
-"""
-
-import logging
-import os
-import platform
-from typing import Optional
-
-import requests
-from tqdm import tqdm
-
-from .check_updates import check_updates
-
-logger = logging.getLogger("luckyrobots.engine.download")
-
-BASE_URL = "https://builds.luckyrobots.xyz/"
-
-
-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"
-
-    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"
-
-    Raises:
-        ValueError: If the OS is not supported.
-    """
-    os_type = platform.system().lower()
-    if os_type == "darwin":
-        return "mac"
-    elif os_type == "windows":
-        return "win"
-    elif os_type == "linux":
-        return "linux"
-    else:
-        raise ValueError(f"Unsupported operating system: {os_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:
-        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
-                os.makedirs(item_path, exist_ok=True)
-                logger.debug(f"Created directory: {item_path}")
-            else:
-                # Handle file download with progress bar
-                file_url = f"{base_url}{os_type}/{item['path']}"
-
-                # Ensure the directory exists
-                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, 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,
-                        unit="iB",
-                        unit_scale=True,
-                        unit_divisor=1024,
-                        ascii=" ▆",
-                    ) as progress_bar:
-                        for data in response.iter_content(chunk_size=1024):
-                            size = f.write(data)
-                            progress_bar.update(size)
-
-                    logger.debug(f"Downloaded: {item_path}")
-                except requests.RequestException as e:
-                    logger.error(f"Error downloading {item_path}: {e}")
-
-        elif change_type == "deleted":
-            # Delete the file or directory
-            try:
-                if os.path.isdir(item_path):
-                    os.rmdir(item_path)
-                    logger.debug(f"Deleted directory: {item_path}")
-                else:
-                    os.remove(item_path)
-                    logger.debug(f"Deleted file: {item_path}")
-            except OSError as e:
-                logger.error(f"Error deleting {item_path}: {e}")

luckyrobots/models/camera.py

@@ -1,97 +0,0 @@
-"""
-Camera models for LuckyRobots.
-
-These models handle camera frame data from LuckyEngine.
-"""
-
-from typing import Any, Dict, Optional, Union
-from pydantic import BaseModel, Field, ConfigDict
-import numpy as np
-import cv2
-
-
-class CameraShape(BaseModel):
-    """Shape of camera images."""
-
-    width: float = Field(description="Width of the image")
-    height: float = Field(description="Height of the image")
-    channel: int = Field(description="Number of color channels")
-
-
-class CameraData(BaseModel):
-    """Camera frame data."""
-
-    model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True)
-
-    camera_name: str = Field(alias="CameraName", description="Name of the camera")
-    dtype: str = Field(default="uint8", description="Data type of the image")
-    shape: Optional[Union[CameraShape, Dict[str, Union[float, int]]]] = Field(
-        default=None, description="Shape of the image"
-    )
-    time_stamp: Optional[str] = Field(
-        None, alias="TimeStamp", description="Camera timestamp"
-    )
-    image_data: Optional[Any] = Field(
-        None, alias="ImageData", description="Image data (bytes or numpy array)"
-    )
-    width: Optional[int] = Field(default=None, description="Image width")
-    height: Optional[int] = Field(default=None, description="Image height")
-    channels: Optional[int] = Field(default=None, description="Number of channels")
-    format: Optional[str] = Field(
-        default=None, description="Image format (raw, jpeg, png)"
-    )
-    frame_number: Optional[int] = Field(default=None, description="Frame number")
-
-    def process_image(self) -> None:
-        """Process the image data into a numpy array."""
-        if self.image_data is None:
-            return None
-
-        # If already a numpy array, skip processing
-        if isinstance(self.image_data, np.ndarray):
-            return
-
-        # Handle bytes data
-        if isinstance(self.image_data, bytes):
-            nparr = np.frombuffer(self.image_data, np.uint8)
-
-            # Check if it's raw RGBA/RGB data or encoded
-            if self.format == "raw" and self.width and self.height:
-                channels = self.channels or 4
-                try:
-                    self.image_data = nparr.reshape((self.height, self.width, channels))
-                    # Convert RGBA to BGR for OpenCV compatibility
-                    if channels == 4:
-                        self.image_data = cv2.cvtColor(
-                            self.image_data, cv2.COLOR_RGBA2BGR
-                        )
-                    elif channels == 3:
-                        self.image_data = cv2.cvtColor(
-                            self.image_data, cv2.COLOR_RGB2BGR
-                        )
-                except ValueError:
-                    # Fallback to decode
-                    self.image_data = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-            else:
-                # Encoded image (JPEG, PNG)
-                self.image_data = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-
-    @classmethod
-    def from_grpc_frame(cls, frame: Any, camera_name: str = "camera") -> "CameraData":
-        """Create CameraData from a gRPC ImageFrame message."""
-        return cls(
-            camera_name=camera_name,
-            dtype="uint8",
-            width=frame.width,
-            height=frame.height,
-            channels=frame.channels,
-            format=frame.format,
-            time_stamp=str(frame.timestamp_ms),
-            frame_number=frame.frame_number,
-            image_data=frame.data,
-            shape=CameraShape(
-                width=frame.width,
-                height=frame.height,
-                channel=frame.channels,
-            ),
-        )