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

luckyrobots/utils/sim_manager.py

@@ -1,406 +0,0 @@
-import os
-import platform
-import subprocess
-import tempfile
-import threading
-import time
-import logging
-
-from typing import Optional
-
-if not os.getenv("PYTEST_CURRENT_TEST") and not os.getenv("LUCKYROBOTS_NO_LOGS"):
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    )
-logger = logging.getLogger("luckyworld")
-
-LOCK_FILE = os.path.join(tempfile.gettempdir(), "luckyworld_lock")
-_process = None
-_monitor_thread = None
-_shutdown_event = threading.Event()
-
-
-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 monitor_process():
-    """Monitor the LuckyWorld 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("LuckyWorld process has terminated")
-                # Don't kill the main process, just break out of monitoring
-                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 is_luckyworld_running() -> bool:
-    """Check if LuckyWorld is running by checking the lock file"""
-    return os.path.exists(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 find_luckyworld_executable() -> Optional[str]:
-    """Automatically find LuckyWorld executable in common locations"""
-    is_wsl = "microsoft" in platform.uname().release.lower()
-
-    # 1. Check environment variable first (highest priority)
-    env_path = os.environ.get("LUCKYWORLD_PATH")
-    if env_path:
-        logger.info(f"Using LUCKYWORLD_PATH environment variable: {env_path}")
-        if os.path.exists(env_path):
-            return env_path
-        else:
-            logger.warning(f"LUCKYWORLD_PATH points to non-existent file: {env_path}")
-
-    # 2. Check LUCKYWORLD_HOME environment variable
-    env_home = os.environ.get("LUCKYWORLD_HOME")
-    if env_home:
-        logger.info(f"Using LUCKYWORLD_HOME environment variable: {env_home}")
-        if platform.system() == "Linux" and not is_wsl:
-            env_executable = os.path.join(env_home, "LuckyWorld.sh")
-        elif platform.system() == "Darwin":
-            env_executable = os.path.join(
-                env_home, "LuckyWorld.app", "Contents", "MacOS", "LuckyWorld"
-            )
-        else:
-            env_executable = os.path.join(env_home, "LuckyWorldV2.exe")
-
-        if os.path.exists(env_executable):
-            return env_executable
-        else:
-            logger.warning(
-                f"LUCKYWORLD_HOME does not contain executable: {env_executable}"
-            )
-
-    # 3. System installation paths
-    if platform.system() == "Linux" and not is_wsl:
-        system_paths = [
-            "/opt/LuckyWorld/LuckyWorld.sh",
-            "/usr/local/bin/LuckyWorld.sh",
-            os.path.expanduser("~/.local/share/LuckyWorld/LuckyWorld.sh"),
-            os.path.expanduser("~/LuckyWorld/LuckyWorld.sh"),
-        ]
-    elif platform.system() == "Darwin":
-        system_paths = [
-            "/Applications/LuckyWorld/LuckyWorld.app/Contents/MacOS/LuckyWorld",
-            os.path.expanduser(
-                "~/Applications/LuckyWorld/LuckyWorld.app/Contents/MacOS/LuckyWorld"
-            ),
-        ]
-    else:  # Windows or WSL2
-        system_paths = [
-            "C:\\Program Files\\LuckyWorld\\LuckyWorldV2.exe",
-            "C:\\Program Files (x86)\\LuckyWorld\\LuckyWorldV2.exe",
-            os.path.expanduser("~\\AppData\\Local\\LuckyWorld\\LuckyWorldV2.exe"),
-        ]
-
-        if is_wsl:
-            system_paths.extend(
-                [
-                    "/mnt/c/Program Files/LuckyWorld/LuckyWorldV2.exe",
-                    "/mnt/c/Program Files (x86)/LuckyWorld/LuckyWorldV2.exe",
-                ]
-            )
-
-    for path in system_paths:
-        if os.path.exists(path):
-            logger.info(f"Found LuckyWorld at: {path}")
-            return path
-
-    return None
-
-
-def launch_luckyworld(
-    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 LuckyWorld with simplified parameters"""
-    global _process, _monitor_thread
-
-    # Check if already running
-    if is_luckyworld_running():
-        logger.error("LuckyWorld is already running. Stop the existing instance first.")
-        return False
-
-    # Find executable if not provided
-    if executable_path is None:
-        executable_path = find_luckyworld_executable()
-        if executable_path is None:
-            logger.error(
-                "Could not find LuckyWorld executable. Please provide the path manually."
-            )
-            logger.info("You can set the path using environment variables:")
-            logger.info("  LUCKYWORLD_PATH=/full/path/to/LuckyWorldV2.exe")
-            logger.info("  LUCKYWORLD_HOME=/path/to/luckyworld/directory")
-            logger.info("Or check these common locations:")
-            logger.info("  Development: Build/Windows/LuckyWorldV2.exe")
-            logger.info("  Windows: C:\\Program Files\\LuckyWorld\\LuckyWorldV2.exe")
-            logger.info("  WSL2: /mnt/c/Program Files/LuckyWorld/LuckyWorldV2.exe")
-            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 LuckyWorld: {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"LuckyWorld 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 LuckyWorld: {e}")
-        stop_luckyworld()
-        return False
-
-
-def kill_processes():
-    """Kill all LuckyWorld processes"""
-    system = platform.system()
-    is_wsl = "microsoft" in platform.uname().release.lower()
-
-    if is_wsl:
-        return _kill_wsl_processes()
-    elif system == "Windows":
-        return _kill_windows_processes()
-    elif system == "Darwin":
-        return _kill_macos_processes()
-    else:
-        return _kill_linux_processes()
-
-
-def _kill_wsl_processes():
-    try:
-        result = subprocess.run(
-            [
-                "/mnt/c/Windows/System32/taskkill.exe",
-                "/F",
-                "/IM",
-                "LuckyWorldV2.exe",
-            ],
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-
-        if result.returncode == 0:
-            return True
-        elif result.returncode == 128:  # Process not found
-            logger.info("No LuckyWorld processes found running")
-            return True
-        else:
-            logger.warning(
-                f"taskkill failed with code {result.returncode}: {result.stderr}"
-            )
-            return False
-
-    except subprocess.TimeoutExpired:
-        logger.error("taskkill command timed out")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to kill processes: {e}")
-        return False
-
-
-def _kill_windows_processes():
-    """Windows-specific process killing"""
-    try:
-        # Kill LuckyWorldV2.exe
-        result = subprocess.run(
-            ["taskkill", "/F", "/IM", "LuckyWorldV2.exe"],
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-
-        if result.returncode == 0:
-            logger.info("Successfully killed LuckyWorldV2.exe processes")
-            return True
-        elif result.returncode == 128:  # Process not found
-            logger.info("No LuckyWorldV2.exe processes found")
-            return True
-        else:
-            logger.warning(f"taskkill failed: {result.stderr}")
-            return False
-
-    except subprocess.TimeoutExpired:
-        logger.error("taskkill command timed out")
-        return False
-    except FileNotFoundError:
-        logger.error("taskkill command not found")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to kill Windows processes: {e}")
-        return False
-
-
-def _kill_macos_processes():
-    """macOS-specific process killing"""
-    try:
-        # Kill LuckyWorld processes
-        result = subprocess.run(
-            ["pkill", "-f", "LuckyWorld"],
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-
-        if result.returncode == 0:
-            logger.info("Successfully killed LuckyWorld processes")
-            return True
-        elif result.returncode == 1:  # No processes found
-            logger.info("No LuckyWorld processes found")
-            return True
-        else:
-            logger.warning(f"pkill failed: {result.stderr}")
-            return False
-
-    except subprocess.TimeoutExpired:
-        logger.error("pkill command timed out")
-        return False
-    except FileNotFoundError:
-        logger.error("pkill command not found")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to kill macOS processes: {e}")
-        return False
-
-
-def _kill_linux_processes():
-    """Linux-specific process killing"""
-    try:
-        # Kill LuckyWorld processes
-        result = subprocess.run(
-            ["pkill", "-f", "LuckyWorld"],
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-
-        if result.returncode == 0:
-            logger.info("Successfully killed LuckyWorld processes")
-            return True
-        elif result.returncode == 1:  # No processes found
-            logger.info("No LuckyWorld processes found")
-            return True
-        else:
-            logger.warning(f"pkill failed: {result.stderr}")
-            return False
-
-    except subprocess.TimeoutExpired:
-        logger.error("pkill command timed out")
-        return False
-    except FileNotFoundError:
-        logger.error("pkill command not found")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to kill Linux processes: {e}")
-        return False
-
-
-def stop_luckyworld() -> bool:
-    """Stop the running LuckyWorld instance"""
-    global _process
-
-    if not is_luckyworld_running():
-        logger.info("LuckyWorld is not running")
-        return True
-
-    try:
-        if _process:
-            logger.info("Stopping LuckyWorld...")
-
-            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 LuckyWorld: {e}")
-        return False

luckyrobots-0.1.63.dist-info/METADATA

@@ -1,251 +0,0 @@
-Metadata-Version: 2.4
-Name: luckyrobots
-Version: 0.1.63
-Summary: Robotics-AI Training in Hyperrealistic Game Environments
-Project-URL: Homepage, https://github.com/luckyrobots/luckyrobots
-Project-URL: Bug Tracker, https://github.com/luckyrobots/luckyrobots/issues
-Author-email: Devrim Yasar <braces.verbose03@icloud.com>, Ethan Clark <ethan@luckyrobots.com>
-License-File: LICENSE
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Requires-Dist: asyncio
-Requires-Dist: beautifulsoup4
-Requires-Dist: fastapi
-Requires-Dist: msgpack
-Requires-Dist: numpy
-Requires-Dist: opencv-python
-Requires-Dist: packaging
-Requires-Dist: psutil
-Requires-Dist: pydantic
-Requires-Dist: pyyaml
-Requires-Dist: requests
-Requires-Dist: tqdm
-Requires-Dist: ultralytics
-Requires-Dist: uvicorn[standard]
-Requires-Dist: watchdog
-Requires-Dist: websocket-client
-Requires-Dist: websockets
-Provides-Extra: dev
-Requires-Dist: black; extra == 'dev'
-Requires-Dist: build; extra == 'dev'
-Requires-Dist: pre-commit; extra == 'dev'
-Requires-Dist: twine; extra == 'dev'
-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>
-
-<p align="center">
-  <a href="https://luckyrobots.github.io/ReleaseV0.1/" target="_blank">
-   <img src="https://img.shields.io/badge/Explore_V0.1-Get_Started-grey?style=for-the-badge&labelColor=grey&color=blue" alt="Get Started" />
-  </a>
-</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 Lucky World" src="https://github.com/user-attachments/assets/279a7864-9a8b-453e-8567-3a174f5db8ab" />
-  <img width="49%" alt="Open floor plan in Lucky World" src="https://github.com/user-attachments/assets/68c72b97-98ab-42b0-a065-8a4247b014c7" />
-</p>
-
-## Quick Start
-
-1. **Download Lucky World Executable from our [releases page](https://github.com/luckyrobots/luckyrobots/releases/latest) and add its path to your system variables**
-   ```bash
-   # Set environment variables (choose one method):
-
-   # Method 1: Set LUCKYWORLD_PATH directly to the executable
-   export LUCKYWORLD_PATH=/path/to/LuckyWorld.exe  # Windows
-   export LUCKYWORLD_PATH=/path/to/LuckyWorld      # Linux/Mac
-
-   # Method 2: Set LUCKYWORLD_HOME to the directory containing the executable
-   export LUCKYWORLD_HOME=/path/to/luckyworld/directory
-   ```
-
-2. **Create conda environment (recommended)**
-   ```bash
-   conda create -n luckyrobots python
-   conda activate luckyrobots
-   ```
-
-3. **Install**
-   ```bash
-   pip install luckyrobots
-   ```
-
-4. **Run Example**
-   ```bash
-   git clone https://github.com/luckyrobots/luckyrobots.git
-   cd luckyrobots/examples
-   python controller.py
-   ```
-
-## Basic Usage
-
-```python
-from luckyrobots import LuckyRobots, Node
-import numpy as np
-
-# Create controller node
-class RobotController(Node):
-    async def control_loop(self):
-        # Reset environment
-        reset_response = await self.reset_client.call(Reset.Request())
-
-        # Send actions
-        actuator_values = np.array([0.1, 0.2, -0.1, 0.0, 0.5, 1.0])
-        step_response = await self.step_client.call(Step.Request(actuator_values=actuator_values))
-
-        # Access observations
-        observation = step_response.observation
-        joint_states = observation.observation_state
-        camera_data = observation.observation_cameras
-
-# Start simulation
-luckyrobots = LuckyRobots()
-controller = RobotController()
-luckyrobots.register_node(controller)
-luckyrobots.start(scene="kitchen", robot="so100", task="pickandplace")
-```
-
-## Available Robots & Environments
-
-### Robots
-- **so100**: 6-DOF manipulator with gripper
-- **stretch_v1**: Mobile manipulator
-- **dji300**: Quadcopter drone
-
-### Scenes
-- **kitchen**: Residential kitchen environment
-- **loft**: Open floor plan apartment
-- **drone_flight**: Outdoor flight area
-
-### Tasks
-- **pickandplace**: Object manipulation
-- **navigation**: Path planning and movement
-
-## API Reference
-
-### Core Classes
-
-**LuckyRobots**: Main simulation manager
-- `start(scene, robot, task, observation_type)`: Initialize simulation
-- `register_node(node)`: Add controller node
-- `spin()`: Run main loop
-
-**Node**: Base class for robot controllers
-- `create_client(service_type, service_name)`: Create service client
-- `create_service(service_type, service_name, handler)`: Create service server
-
-### Services
-
-**Reset**: Reset robot to initial state
-```python
-request = Reset.Request(seed=42, options={})
-response = await reset_client.call(request)
-```
-
-**Step**: Send action and get observation
-```python
-request = Step.Request(actuator_values=[0.1, 0.2, -0.1])
-response = await step_client.call(request)
-```
-
-### Observations
-
-Access sensor data from step responses:
-```python
-# Joint positions and velocities
-joint_states = response.observation.observation_state
-
-# Camera images (RGB + depth)
-for camera in response.observation.observation_cameras:
-    image = camera.image_data  # numpy array
-    name = camera.camera_name  # "head_cam", "hand_cam", etc.
-```
-
-## Command Line Interface
-
-```bash
-# Basic usage
-python controller.py --robot so100 --scene kitchen --task pickandplace
-
-# With camera display
-python controller.py --show-camera --rate 30
-
-# Custom host/port
-python controller.py --host 192.168.1.100 --port 3001
-```
-
-## Configuration
-
-Robot configurations are defined in `src/luckyrobots/config/robots.yaml`:
-
-```yaml
-so100:
-  action_space:
-    actuator_names: [shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper]
-    actuator_limits:
-      - name: shoulder_pan
-        lower: -2.2
-        upper: 2.2
-  available_scenes: [kitchen]
-  available_tasks: [pickandplace]
-```
-
-## Architecture
-
-Lucky Robots uses a distributed node architecture:
-
-- **Manager Node**: Central message routing
-- **LuckyRobots Node**: Simulation interface
-- **Controller Nodes**: User-defined robot controllers
-- **WebSocket Transport**: Inter-node communication
-- **Lucky World**: Physics simulation backend
-
-## Development
-
-### Setup Development Environment
-```bash
-git clone https://github.com/luckyrobots/luckyrobots.git
-cd luckyrobots
-pip install -e .
-```
-
-### Contributing
-1. Fork the repository
-2. Create a feature branch
-3. Make changes and add tests
-4. Submit a pull request
-
-## 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.63.dist-info/RECORD

@@ -1,24 +0,0 @@
-luckyrobots/__init__.py,sha256=yr8nMUVzAe8ohD7XNywTDwLX98HwjT4cagxARkld1HQ,426
-luckyrobots/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-luckyrobots/config/robots.yaml,sha256=w0HwB35WRd7X0-hQRgtYQaRWmOk32-e6pMxT88aereE,1806
-luckyrobots/core/luckyrobots.py,sha256=Hmf2d2IOya5lW0tYfK0yNy3Z5fZDLWs-FJDWyycIGd8,23032
-luckyrobots/core/manager.py,sha256=p9Ehs2SKLpBEEJf8hvTFUG_foPrQszgH6BUbIzBTtBo,9212
-luckyrobots/core/models.py,sha256=fbAKpIOZM8D6rKxRgo1_9rioNa99bT_phCZ9xrwWFaE,2108
-luckyrobots/core/node.py,sha256=lDKqAQSMEctjU-v4F9Lifz_ZsKG6wxsNuyRqtOWrQRA,10512
-luckyrobots/message/__init__.py,sha256=7oM16w34XBc8xuKZh3rNRPnqHMjhyYYG0bqLS3j2PjQ,432
-luckyrobots/message/pubsub.py,sha256=iPMhRCq7IASqSO8eXs8LwMUayJp-piYdPSc741a3qKs,5490
-luckyrobots/message/transporter.py,sha256=5I1YCv8jlG-swM__ZTQ4L8BLmUfOSfs_3iLWXeprC6M,15815
-luckyrobots/message/srv/client.py,sha256=wT8Q-cuu3aXeRmkO_8CTFSO9aJqtrzyyxBopyUl3HNw,2971
-luckyrobots/message/srv/service.py,sha256=zmOFt6VBGUiy5btZo5Wh4-vr2oJfhzHjOV3hB2IzAFw,4495
-luckyrobots/message/srv/types.py,sha256=j-VuYsum_98gQBj9-37vsHWC8PcvPd15UP-NkoEtPYw,1948
-luckyrobots/utils/check_updates.py,sha256=5CpAe2jK1igjJVIoZKzRWgg9jwKsmiyEwqgldyek6H8,6439
-luckyrobots/utils/download.py,sha256=UWQkB6yp-UsOK93pw0noHmv2rVLXcjY5JKd9EkKUG-c,3593
-luckyrobots/utils/event_loop.py,sha256=r2sn7G9JHFKUri4aUnZ_1D82CTZnEsr3woLLKiDx8Dw,2638
-luckyrobots/utils/helpers.py,sha256=4o3Jy0-otnVl0duqncoIuEufEo2AP9BDdgKSEYUOCYQ,2193
-luckyrobots/utils/sim_manager.py,sha256=-FwHaHtfDo9-LBKafwchFkmAamwmFCnPqLAR3hhjsEI,12991
-luckyrobots/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-luckyrobots/config/robots.yaml,sha256=w0HwB35WRd7X0-hQRgtYQaRWmOk32-e6pMxT88aereE,1806
-luckyrobots-0.1.63.dist-info/METADATA,sha256=I_dmqA_LJR5KMI6aOMyk3WtnIwG3xYu_o2XIvSJ4AI4,7674
-luckyrobots-0.1.63.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-luckyrobots-0.1.63.dist-info/licenses/LICENSE,sha256=xsPYvRJPH_fW_sofTUknI_KvZOsD4-BqjSOTZqI6Nmw,1069
-luckyrobots-0.1.63.dist-info/RECORD,,