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

luckyrobots/core/manager.py

@@ -1,236 +0,0 @@
-"""
-WebSocket server for distributed node communication.
-
-This module provides a WebSocket server that acts as a central hub for distributed
-nodes to discover each other and communicate.
-"""
-
-import msgpack
-import asyncio
-import logging
-from typing import Dict, Set
-
-from fastapi import FastAPI, WebSocket
-
-from ..message.transporter import MessageType, TransportMessage
-
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger("manager")
-
-# FastAPI app
-app = FastAPI()
-
-
-class Manager:
-    def __init__(self):
-        # Dict of node name to WebSocket connection
-        self.active_nodes: Dict[str, WebSocket] = {}
-
-        # Dict of topic to set of subscribed node names
-        self.subscriptions: Dict[str, Set[str]] = {}
-
-        # Dict of service name to node name
-        self.services: Dict[str, str] = {}
-
-        # Lock for thread safety
-        self.lock = asyncio.Lock()
-
-    async def register_node(self, node_name: str, websocket: WebSocket):
-        """Register a node with the manager"""
-        async with self.lock:
-            self.active_nodes[node_name] = websocket
-            logger.info(f"Node registered: {node_name}")
-
-    async def unregister_node(self, node_name: str):
-        """Unregister a node from the manager"""
-        async with self.lock:
-            # Remove the node from active nodes
-            if node_name in self.active_nodes:
-                del self.active_nodes[node_name]
-
-            # Remove the node from subscriptions
-            for topic, nodes in list(self.subscriptions.items()):
-                if node_name in nodes:
-                    nodes.remove(node_name)
-                    if not nodes:
-                        del self.subscriptions[topic]
-
-            # Remove the node from services
-            for service, provider in list(self.services.items()):
-                if provider == node_name:
-                    del self.services[service]
-
-            logger.info(f"Node unregistered: {node_name}")
-
-    async def subscribe(self, node_name: str, topic: str):
-        """Subscribe a node to a topic"""
-        async with self.lock:
-            if topic not in self.subscriptions:
-                self.subscriptions[topic] = set()
-            self.subscriptions[topic].add(node_name)
-            logger.debug(f"Node {node_name} subscribed to topic: {topic}")
-
-    async def unsubscribe(self, node_name: str, topic: str):
-        """Unsubscribe a node from a topic"""
-        async with self.lock:
-            if topic in self.subscriptions and node_name in self.subscriptions[topic]:
-                self.subscriptions[topic].remove(node_name)
-                if not self.subscriptions[topic]:
-                    del self.subscriptions[topic]
-                logger.debug(f"Node {node_name} unsubscribed from topic: {topic}")
-
-    async def register_service(self, node_name: str, service_name: str):
-        """Register a service with the manager"""
-        async with self.lock:
-            self.services[service_name] = node_name
-            logger.debug(f"Service registered: {service_name} by node {node_name}")
-
-    async def unregister_service(self, node_name: str, service_name: str):
-        """Unregister a service from the manager"""
-        async with self.lock:
-            if (
-                service_name in self.services
-                and self.services[service_name] == node_name
-            ):
-                del self.services[service_name]
-                logger.debug(f"Service unregistered: {service_name}")
-
-    async def route_message(self, message: TransportMessage):
-        """Route a message to the appropriate nodes"""
-        try:
-            # Handle message based on its type
-            if message.msg_type == MessageType.PUBLISH:
-                await self._route_publish(message)
-            elif message.msg_type == MessageType.SERVICE_REQUEST:
-                await self._route_service_request(message)
-            elif message.msg_type == MessageType.SERVICE_RESPONSE:
-                await self._route_service_response(message)
-            else:
-                # For other message types, just log and ignore
-                logger.debug(
-                    f"Received message of type {message.msg_type}, not routing"
-                )
-        except Exception as e:
-            logger.error(f"Error routing message: {e}")
-
-    async def _route_publish(self, message: TransportMessage):
-        """Route a publish message to subscribed nodes"""
-        topic = message.topic_or_service
-        sender_node = message.node_name
-
-        # Get the list of subscribed nodes for this topic
-        async with self.lock:
-            subscribers = self.subscriptions.get(topic, set()).copy()
-
-        # Send the message to all subscribers except the sender
-        for node_name in subscribers:
-            if node_name != sender_node and node_name in self.active_nodes:
-                try:
-                    await self.active_nodes[node_name].send(
-                        msgpack.dumps(message.dict())
-                    )
-                except Exception as e:
-                    logger.error(f"Error sending to node {node_name}: {e}")
-
-    async def _route_service_request(self, message: TransportMessage):
-        """Route a service request to the appropriate node"""
-        service_name = message.topic_or_service
-        requester_node = message.node_name
-
-        # Find the service provider
-        async with self.lock:
-            provider_node = self.services.get(service_name)
-
-        if not provider_node:
-            # Service not found, send error response
-            error_response = TransportMessage(
-                msg_type=MessageType.SERVICE_RESPONSE,
-                node_name="node_server",
-                topic_or_service=service_name,
-                message_id=message.message_id,
-                data={"error": f"Service {service_name} not found"},
-            )
-
-            if requester_node in self.active_nodes:
-                try:
-                    await self.active_nodes[requester_node].send(
-                        msgpack.dumps(error_response.dict())
-                    )
-                except Exception as e:
-                    logger.error(
-                        f"Error sending error response to node {requester_node}: {e}"
-                    )
-            return
-
-        # Forward the request to the service provider
-        if provider_node in self.active_nodes:
-            try:
-                await self.active_nodes[provider_node].send_bytes(
-                    msgpack.dumps(message.dict())
-                )
-            except Exception as e:
-                logger.error(
-                    f"Error forwarding service request to node {provider_node}: {e}"
-                )
-                raise e
-        else:
-            # Provider not connected, send error response
-            error_response = TransportMessage(
-                msg_type=MessageType.SERVICE_RESPONSE,
-                node_name="node_server",
-                topic_or_service=service_name,
-                message_id=message.message_id,
-                data={"error": f"Service provider {provider_node} is not connected"},
-            )
-
-            if requester_node in self.active_nodes:
-                try:
-                    await self.active_nodes[requester_node].send(
-                        msgpack.dumps(error_response.dict())
-                    )
-                except Exception as e:
-                    logger.error(
-                        f"Error sending error response to node {requester_node}: {e}"
-                    )
-
-    async def _route_service_response(self, message: TransportMessage):
-        """Route a service response to the appropriate node"""
-        service_name = message.topic_or_service
-        message_id = message.message_id
-
-        if not message_id:
-            logger.error(f"Service response missing message_id: {message}")
-            return
-
-        # Extract requester node name from message_id (format: node_name_service_name_timestamp_id)
-        try:
-            parts = message_id.split("_")
-            requester_node = parts[0]
-
-            # For namespaced nodes, reconstruct the full name
-            if len(parts) > 4:  # There are more underscores in the node name
-                requester_node = "_".join(
-                    parts[:-3]
-                )  # Everything except the last 3 parts
-        except Exception as e:
-            logger.error(
-                f"Error extracting requester node from message_id {message_id}: {e}"
-            )
-            return
-
-        # Forward the response to the requester
-        if requester_node in self.active_nodes:
-            try:
-                await self.active_nodes[requester_node].send(
-                    msgpack.dumps(message.dict())
-                )
-            except Exception as e:
-                logger.error(
-                    f"Error forwarding service response to node {requester_node}: {e}"
-                )
-        else:
-            logger.warning(
-                f"Requester node {requester_node} not connected for response {message_id}"
-            )

luckyrobots/core/models.py

@@ -1,68 +0,0 @@
-"""
-PyDantic models for the LuckyRobots framework.
-
-This module contains the PyDantic models that are used to define
-the data structures being sent over the WebSocket transport.
-"""
-
-from typing import Dict, List, Optional, Union
-from pydantic import BaseModel, Field
-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 data in observations"""
-
-    camera_name: str = Field(alias="CameraName", description="Name of the camera")
-    dtype: str = Field(description="Data type of the image")
-    shape: Union[CameraShape, Dict[str, Union[float, int]]] = Field(
-        description="Shape of the image"
-    )
-    time_stamp: Optional[str] = Field(
-        None, alias="TimeStamp", description="Camera timestamp"
-    )
-    image_data: Optional[bytes] = Field(
-        None, alias="ImageData", description="Image data"
-    )
-
-    def process_image(self) -> None:
-        """Process the base64 image data into a numpy array"""
-        if self.image_data is None:
-            return None
-
-        nparr = np.frombuffer(self.image_data, np.uint8)
-        self.image_data = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-
-    class Config:
-        populate_by_name = True
-
-
-class ObservationModel(BaseModel):
-    """Observation model that matches the JSON structure"""
-
-    observation_state: Dict[str, float] = Field(
-        alias="ObservationState", description="State values for actuators"
-    )
-    observation_cameras: Optional[List[CameraData]] = Field(
-        default=None, alias="ObservationCameras", description="List of camera data"
-    )
-
-    def process_all_cameras(self) -> None:
-        """Process all camera images in the observation"""
-        if self.observation_cameras is None:
-            return
-
-        for camera in self.observation_cameras:
-            camera.process_image()
-
-    class Config:
-        populate_by_name = True

luckyrobots/core/node.py

@@ -1,273 +0,0 @@
-"""
-Node class for the LuckyRobots framework.
-
-This module contains the Node class that is used to create a node in the
-LuckyRobots framework. A node is a component that can publish messages,
-subscribe to messages, and call services.
-"""
-
-import asyncio
-import logging
-import threading
-import uuid
-from typing import Any, Callable, Dict, Type
-
-from ..message.pubsub import Publisher, Subscriber
-from ..message.srv.client import ServiceClient
-from ..message.srv.service import ServiceServer, ServiceError
-from ..message.transporter import Transporter
-from ..utils.event_loop import run_coroutine
-
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger("node")
-
-
-class Node:
-    def __init__(
-        self, name: str, namespace: str = "", host: str = None, port: int = None
-    ):
-        self.name = name
-        self.namespace = namespace.strip("/")
-        self.full_name = (
-            f"/{self.namespace}/{self.name}" if self.namespace else f"/{self.name}"
-        )
-
-        # Get host and port from parameters if not provided
-        self.host = host
-        self.port = port
-
-        # Create a unique ID for this node instance
-        self.instance_id = str(uuid.uuid4())
-
-        self._publishers: Dict[str, Publisher] = {}
-        self._subscribers: Dict[str, Subscriber] = {}
-        self._services: Dict[str, ServiceServer] = {}
-        self._clients: Dict[str, ServiceClient] = {}
-        self._running = False
-        self._shutdown_event = threading.Event()
-
-        # Initialize WebSocket transporter
-        # Note: We connect to the same server for all communications
-        self.transporter = Transporter(
-            node_name=self.full_name,
-            uuid=self.instance_id,
-            host=self.host,
-            port=self.port,
-        )
-
-        logger.info(f"Created node: {self.full_name} (ID: {self.instance_id})")
-
-    def get_qualified_name(self, name: str) -> str:
-        """Get the qualified name for a given name"""
-        if name.startswith("/"):
-            return name
-
-        return f"{self.full_name}/{name}"
-
-    def create_publisher(
-        self, message_type: Type, topic: str, queue_size: int = 10
-    ) -> Publisher:
-        """Create a publisher for a given topic"""
-        qualified_topic = self.get_qualified_name(topic)
-        publisher = Publisher(qualified_topic, message_type, queue_size)
-        self._publishers[qualified_topic] = publisher
-
-        # Wrap the publish method to distribute messages
-        original_publish = publisher.publish
-
-        def distributed_publish(message):
-            # Publish locally
-            original_publish(message)
-
-            # Publish to remote nodes via transport layer
-            self.transporter.publish(qualified_topic, message)
-
-        publisher.publish = distributed_publish
-
-        return publisher
-
-    def create_subscription(
-        self,
-        message_type: Type,
-        topic: str,
-        callback: Callable[[Any], None],
-        queue_size: int = 10,
-    ) -> Subscriber:
-        """Create a subscriber for a given topic"""
-        qualified_topic = self.get_qualified_name(topic)
-        subscriber = Subscriber(qualified_topic, message_type, callback, queue_size)
-        self._subscribers[qualified_topic] = subscriber
-
-        # Create a wrapper for the callback that handles message type conversion
-        def transport_callback(data):
-            # Try to convert the data to the expected message type
-            if hasattr(message_type, "parse_obj"):
-                try:
-                    message = message_type.parse_obj(data)
-                    callback(message)
-                except Exception as e:
-                    logger.error(f"Error converting message data: {e}")
-            else:
-                # If the message type doesn't have parse_obj, pass the data directly
-                callback(data)
-
-        # Subscribe to the topic on the transport layer
-        self.transporter.subscribe(qualified_topic, transport_callback)
-
-        return subscriber
-
-    def create_client(self, service_type: Type, service_name: str) -> ServiceClient:
-        """Create a client for a given service"""
-        qualified_name = self.get_qualified_name(service_name)
-        client = ServiceClient(service_type, qualified_name)
-        self._clients[qualified_name] = client
-
-        # Store the original call method
-        original_call = client.call
-
-        # Create a new call method that tries both local and remote services
-        async def distributed_call(request, timeout=30.0):
-            try:
-                # Try to call the service locally first
-                return await original_call(request, qualified_name, timeout=timeout)
-            except Exception as e:
-                logger.debug(f"Local service call failed: {e}, trying remote service")
-
-                # Convert the request to a dictionary
-                if hasattr(request, "dict"):
-                    request_data = request.dict()
-                elif hasattr(request, "to_dict"):
-                    request_data = request.to_dict()
-                else:
-                    request_data = request
-
-                # Call the service through the transport
-                try:
-                    response_data = await self.transporter.call_service(
-                        qualified_name, request_data, timeout=timeout
-                    )
-
-                    # Check if response has an error
-                    if isinstance(response_data, dict) and "error" in response_data:
-                        raise ServiceError(
-                            response_data.get("error", "Unknown service error")
-                        )
-
-                    # Convert the response to the expected response type
-                    response_type = getattr(service_type, "Response", None)
-
-                    if response_type and hasattr(response_type, "parse_obj"):
-                        try:
-                            return response_type.parse_obj(response_data)
-                        except Exception as parse_error:
-                            logger.error(
-                                f"Error converting response data: {parse_error}"
-                            )
-                            raise ServiceError(f"Error parsing response: {parse_error}")
-                    else:
-                        # If no specific response type or parsing failed, return the data directly
-                        return response_data
-                except Exception as remote_error:
-                    logger.error(f"Remote service call failed: {remote_error}")
-                    raise ServiceError(f"Remote service call failed: {remote_error}")
-
-        # Replace the call method
-        client.call = distributed_call
-
-        return client
-
-    async def create_service(
-        self, service_type: Type, service_name: str, handler: Callable[[Any], Any]
-    ) -> ServiceServer:
-        """Create a service for a given service name"""
-        qualified_name = self.get_qualified_name(service_name)
-        service = ServiceServer(service_type, qualified_name, handler)
-        self._services[qualified_name] = service
-
-        # Create a wrapper for the handler that handles message type conversion and async
-        async def transport_handler(request_data):
-            # Try to convert the request data to the expected request type
-            request_type = getattr(service_type, "Request", service_type)
-
-            if hasattr(request_type, "parse_obj"):
-                try:
-                    request = request_type.parse_obj(request_data)
-                except Exception as e:
-                    logger.error(f"Error converting request data: {e}")
-                    return {"error": str(e), "success": False}
-            else:
-                # If the request type doesn't have parse_obj, pass the data directly
-                request = request_data
-
-            # Call the original handler and properly handle async
-            try:
-                if asyncio.iscoroutinefunction(handler):
-                    # Await the coroutine directly
-                    response = await handler(request)
-                else:
-                    # Run synchronous handler
-                    response = handler(request)
-
-                # If the response is also a coroutine, await it (sometimes happens with wrapped handlers)
-                if asyncio.iscoroutine(response):
-                    response = await response
-
-                # Convert the response to a dictionary
-                if hasattr(response, "dict"):
-                    return response.dict()
-                elif isinstance(response, dict):
-                    return response
-                else:
-                    # Try to convert to dict
-                    try:
-                        return dict(response)
-                    except (TypeError, ValueError):
-                        return {"value": response, "success": True}
-            except Exception as e:
-                logger.error(f"Error in service handler: {e}")
-                return {"error": str(e), "success": False}
-
-        # Register with transport using the async-aware wrapper
-        self.transporter.register_service(qualified_name, transport_handler)
-
-        return service
-
-    def create_service_client(
-        self,
-        service_type: Type,
-        service_name: str,
-        host: str = "localhost",
-        port: int = 3000,
-    ) -> ServiceClient:
-        """Create a service client for a given service name"""
-        qualified_name = self.get_qualified_name(service_name)
-        client = ServiceClient(service_type, qualified_name, host, port)
-        self._clients[qualified_name] = client
-        return client
-
-    def start(self) -> None:
-        """Start the node"""
-        self._running = True
-        run_coroutine(self._setup_async())
-        logger.info(f"Node {self.full_name} started")
-
-    async def _setup_async(self):
-        pass
-
-    def spin(self) -> None:
-        """Spin the node"""
-        logger.info(f"Node {self.full_name} spinning")
-        self._shutdown_event.wait()
-        logger.info(f"Node {self.full_name} stopped spinning")
-
-    def shutdown(self) -> None:
-        """Shutdown the node"""
-        self._running = False
-
-        # Shutdown WebSocket transporter
-        self.transporter.shutdown()
-
-        self._shutdown_event.set()
-        logger.info(f"Node {self.full_name} shutdown")

luckyrobots/message/__init__.py

@@ -1,18 +0,0 @@
-"""Service and publisher/subscriber patterns for LuckyRobots.
-
-This module provides service and publisher/subscriber patterns for:
-- Services (request/response)
-- Publishers (one-to-many)
-- Subscribers (many-to-one)
-"""
-
-from .pubsub import Publisher, Subscriber
-from .srv.client import ServiceClient
-from .srv.service import ServiceServer
-
-__all__ = [
-    "ServiceClient",
-    "ServiceServer",
-    "Publisher",
-    "Subscriber",
-]