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

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,
-            ),
-        )

luckyrobots/models/randomization.py

@@ -1,77 +0,0 @@
-"""
-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"
-    )