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

luckyrobots/message/pubsub.py

@@ -1,145 +0,0 @@
-"""
-Publisher/subscriber implementation with WebSocket transport.
-
-This module provides Publisher and Subscriber classes for implementing
-publisher/subscriber patterns with WebSocket transport for distributed
-communication.
-"""
-
-import logging
-import threading
-from typing import Any, Callable, Dict, List, Type
-
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger("pubsub")
-
-
-class Publisher:
-    # Class dictionary to keep track of all publishers by topic
-    _publishers_by_topic: Dict[str, List["Publisher"]] = {}
-    _lock = threading.RLock()
-
-    def __init__(self, topic: str, message_type: Type, queue_size: int = 10):
-        self.topic = topic
-        self.message_type = message_type
-        self.queue_size = queue_size
-        self._subscribers: List[Callable[[Any], None]] = []
-
-        # Register this publisher in the class dictionary
-        with Publisher._lock:
-            if topic not in Publisher._publishers_by_topic:
-                Publisher._publishers_by_topic[topic] = []
-            Publisher._publishers_by_topic[topic].append(self)
-
-        logger.debug(f"Created publisher for topic: {topic}")
-
-    def __del__(self):
-        """Delete the publisher"""
-        with Publisher._lock:
-            if self.topic in Publisher._publishers_by_topic:
-                if self in Publisher._publishers_by_topic[self.topic]:
-                    Publisher._publishers_by_topic[self.topic].remove(self)
-                if not Publisher._publishers_by_topic[self.topic]:
-                    del Publisher._publishers_by_topic[self.topic]
-
-    def publish(self, message: Any) -> None:
-        # Type check the message
-        if not isinstance(message, self.message_type):
-            raise TypeError(
-                f"Expected message of type {self.message_type.__name__}, got {type(message).__name__}"
-            )
-
-        # Publish to all local subscribers
-        for subscriber in self._subscribers:
-            try:
-                subscriber(message)
-            except Exception as e:
-                logger.error(
-                    f"Error in subscriber callback for topic {self.topic}: {e}"
-                )
-
-        # Note: Remote publishing is handled by the Node class, which
-        # wraps this publish method to publish to the WebSocket transport
-
-    def add_subscriber(self, subscriber: Callable[[Any], None]) -> None:
-        """Add a subscriber to the publisher"""
-        if subscriber not in self._subscribers:
-            self._subscribers.append(subscriber)
-            logger.debug(f"Added subscriber to topic: {self.topic}")
-
-    def remove_subscriber(self, subscriber: Callable[[Any], None]) -> None:
-        """Remove a subscriber from the publisher"""
-        if subscriber in self._subscribers:
-            self._subscribers.remove(subscriber)
-            logger.debug(f"Removed subscriber from topic: {self.topic}")
-
-    @classmethod
-    def get_publishers_for_topic(cls, topic: str) -> List["Publisher"]:
-        """Get all publishers for a given topic"""
-        with cls._lock:
-            return cls._publishers_by_topic.get(topic, [])
-
-    @classmethod
-    def get_all_topics(cls) -> List[str]:
-        """Get all topics"""
-        with cls._lock:
-            return list(cls._publishers_by_topic.keys())
-
-
-class Subscriber:
-    # Class dictionary to keep track of all subscribers
-    _subscribers_by_topic: Dict[str, List["Subscriber"]] = {}
-    _lock = threading.RLock()
-
-    def __init__(
-        self,
-        topic: str,
-        message_type: Type,
-        callback: Callable[[Any], None],
-        queue_size: int = 10,
-    ):
-        self.topic = topic
-        self.message_type = message_type
-        self.callback = callback
-        self.queue_size = queue_size
-
-        # Find publishers for this topic and subscribe
-        self._connect_to_publishers()
-
-        # Register this subscriber in the class dictionary
-        with Subscriber._lock:
-            if topic not in Subscriber._subscribers_by_topic:
-                Subscriber._subscribers_by_topic[topic] = []
-            Subscriber._subscribers_by_topic[topic].append(self)
-
-        logger.debug(f"Created subscriber for topic: {topic}")
-
-    def __del__(self):
-        """Delete the subscriber"""
-        # Unsubscribe from all publishers
-        publishers = Publisher.get_publishers_for_topic(self.topic)
-        for publisher in publishers:
-            publisher.remove_subscriber(self.callback)
-
-        # Remove from class dictionary
-        with Subscriber._lock:
-            if self.topic in Subscriber._subscribers_by_topic:
-                if self in Subscriber._subscribers_by_topic[self.topic]:
-                    Subscriber._subscribers_by_topic[self.topic].remove(self)
-                if not Subscriber._subscribers_by_topic[self.topic]:
-                    del Subscriber._subscribers_by_topic[self.topic]
-
-    def _connect_to_publishers(self) -> None:
-        """Connect to all publishers for a given topic"""
-        publishers = Publisher.get_publishers_for_topic(self.topic)
-        for publisher in publishers:
-            if publisher.message_type == self.message_type:
-                publisher.add_subscriber(self.callback)
-
-    @classmethod
-    def get_subscribers_for_topic(cls, topic: str) -> List["Subscriber"]:
-        """Get all subscribers for a given topic"""
-        with cls._lock:
-            return cls._subscribers_by_topic.get(topic, [])

luckyrobots/message/srv/client.py

@@ -1,81 +0,0 @@
-import asyncio
-from typing import Generic, Optional, Type, TypeVar
-
-from .service import (
-    ServiceNotFoundError,
-    ServiceServer,
-)
-
-T = TypeVar("T")  # Request type
-R = TypeVar("R")  # Response type
-
-
-class ServiceClient(Generic[T, R]):
-    def __init__(self, service_type: Type[T], service_name: str):
-        # ServiceClient attributes
-        self.service_type = service_type
-        self.service_name = service_name
-
-        # Initialize the ServiceServer object
-        self._service: Optional[ServiceServer] = None
-
-    async def connect(self, retry_count: int = 3, retry_delay: float = 1.0) -> bool:
-        """Connect to the service server"""
-        for attempt in range(retry_count):
-            self._service = ServiceServer.get_service(self.service_name)
-            if self._service is not None:
-                return True
-
-            if attempt < retry_count - 1:
-                await asyncio.sleep(retry_delay)
-
-        return False
-
-    async def call(
-        self, request: T, service_name: str = None, timeout: float = 30.0
-    ) -> R:
-        """Call the service server"""
-        # Default to the client's service name if none provided
-        if service_name is None:
-            service_name = self.service_name
-
-        if self.service_name != service_name:
-            raise ValueError(
-                f"Service name mismatch. Expected {self.service_name}, got {service_name}"
-            )
-
-        # Validate request type if possible
-        request_type = getattr(self.service_type, "Request", self.service_type)
-        if not isinstance(request, request_type):
-            raise TypeError(
-                f"Expected request of type {request_type.__name__}, got {type(request).__name__}"
-            )
-
-        if self._service is None:
-            connected = await self.connect()
-            if not connected:
-                raise ServiceNotFoundError(f"Service {self.service_name} not found")
-
-        # Check service type compatibility if possible
-        if (
-            hasattr(self.service_type, "Request")
-            and hasattr(self._service.service_type, "Request")
-            and self.service_type.Request != self._service.service_type.Request
-        ):
-            raise TypeError(
-                f"Service request type mismatch. Expected {self.service_type.Request.__name__}, "
-                f"got {self._service.service_type.Request.__name__}"
-            )
-
-        if (
-            hasattr(self.service_type, "Response")
-            and hasattr(self._service.service_type, "Response")
-            and self.service_type.Response != self._service.service_type.Response
-        ):
-            raise TypeError(
-                f"Service response type mismatch. Expected {self.service_type.Response.__name__}, "
-                f"got {self._service.service_type.Response.__name__}"
-            )
-
-        # Call the service server
-        return await self._service.call(request, service_name, timeout=timeout)

luckyrobots/message/srv/service.py

@@ -1,135 +0,0 @@
-import asyncio
-import logging
-from typing import Callable, Dict, Generic, List, Optional, Type, TypeVar
-
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger("service")
-
-T = TypeVar("T")  # Request type
-R = TypeVar("R")  # Response type
-
-
-class ServiceError(Exception):
-    """Base exception for service-related errors"""
-
-    pass
-
-
-class ServiceTimeoutError(ServiceError):
-    """Exception raised when a service call times out"""
-
-    pass
-
-
-class ServiceNotFoundError(ServiceError):
-    """Exception raised when a service is not found"""
-
-    pass
-
-
-class ServiceHandlerError(ServiceError):
-    """Exception raised when a service handler raises an exception"""
-
-    pass
-
-
-class ServiceServer(Generic[T, R]):
-    """Enhanced service implementation with timeout and error handling"""
-
-    # Class dictionary to keep track of all services
-    _services: Dict[str, "ServiceServer"] = {}
-    _lock = asyncio.Lock()
-
-    def __init__(
-        self, service_type: Type[T], service_name: str, handler: Callable[[T], R]
-    ):
-        self._handler: Optional[Callable[[T], R]] = None
-
-        self.service_type = service_type
-        self.service_name = service_name
-
-        self.set_handler(handler)
-
-        # Register this service in the class dictionary
-        ServiceServer._services[service_name] = self
-
-        logger.debug(f"Created service: {service_name}")
-
-    def set_handler(self, handler: Callable[[T], R]) -> None:
-        """Set the handler for the service"""
-        self._handler = handler
-        logger.debug(f"Set handler for service: {self.service_name}")
-
-    async def call(self, request: T, service_name: str, timeout: float = 30.0) -> R:
-        """Call the service"""
-        if self.service_name != service_name:
-            raise ValueError(
-                f"Service name mismatch. Expected {self.service_name}, got {service_name}"
-            )
-
-        # Validate the request type if possible
-        request_type = getattr(self.service_type, "Request")
-        if not isinstance(request, request_type):
-            raise TypeError(
-                f"Expected request of type {request_type.__name__}, got {type(request).__name__}"
-            )
-
-        if self._handler is None:
-            raise ServiceNotFoundError(
-                f"No handler set for service {self.service_name}"
-            )
-
-        try:
-            # Run the handler with timeout
-            return await asyncio.wait_for(self._run_handler(request), timeout=timeout)
-        except asyncio.TimeoutError:
-            raise ServiceTimeoutError(
-                f"Service call to {self.service_name} timed out after {timeout} seconds"
-            )
-
-    async def _run_handler(self, request: T) -> R:
-        """Run the server handler and handle exceptions"""
-        try:
-            # If handler is already a coroutine function, await it
-            if asyncio.iscoroutinefunction(self._handler):
-                result = await self._handler(request)
-            else:
-                # Run non-async handler in a thread pool
-                loop = asyncio.get_event_loop()
-                result = await loop.run_in_executor(None, self._handler, request)
-
-            # Type check the result if possible
-            response_type = getattr(self.service_type, "Response", None)
-            if response_type and not isinstance(result, response_type):
-                raise TypeError(
-                    f"Service {self.service_name} returned {type(result).__name__}, expected {response_type.__name__}"
-                )
-
-            return result
-        except Exception as e:
-            logger.error(f"Error in service handler for {self.service_name}: {e}")
-            raise ServiceHandlerError(
-                f"Service handler for {self.service_name} raised an exception: {e}"
-            )
-
-    @classmethod
-    def get_service(cls, service_name: str) -> Optional["ServiceServer"]:
-        """Get a service by name"""
-        return cls._services.get(service_name)
-
-    @classmethod
-    def get_all_services(cls) -> List[str]:
-        """Get all services"""
-        return list(cls._services.keys())
-
-
-def get_service(name: str) -> Optional[ServiceServer]:
-    """External helper function to get a service by name"""
-    return ServiceServer.get_service(name)
-
-
-def get_all_services() -> List[str]:
-    """External helper function to get all services"""
-    return ServiceServer.get_all_services()

luckyrobots/message/srv/types.py

@@ -1,83 +0,0 @@
-"""Data models for messaging system.
-
-This module defines the data models used for request and response messaging.
-"""
-
-from typing import Any, Dict, Optional
-from ...core.models import ObservationModel
-
-from pydantic import BaseModel, Field
-
-
-class ServiceRequest(BaseModel):
-    """Base class for service requests"""
-
-    pass
-
-
-class ServiceResponse(BaseModel):
-    """Base class for service responses"""
-
-    success: bool = Field(
-        default=True, description="Whether the service call was successful"
-    )
-    message: str = Field(
-        default="", description="A message describing the service call"
-    )
-
-    request_type: str = Field(
-        description="Type of response (reset_response or step_response)"
-    )
-    request_id: str = Field(description="Unique identifier")
-    time_stamp: str = Field(alias="timeStamp", description="Timestamp value")
-
-    observation: ObservationModel = Field(description="Observation data")
-    info: Dict[str, str] = Field(description="Additional information")
-
-    class Config:
-        populate_by_name = True
-
-
-class ResetRequest(ServiceRequest):
-    """Request to reset the robot"""
-
-    seed: Optional[int] = Field(
-        default=None, description="The seed to reset the robot with"
-    )
-    options: Optional[Dict[str, Any]] = Field(
-        default=None, description="Options for the reset"
-    )
-
-
-class ResetResponse(ServiceResponse):
-    """Response to reset request"""
-
-    pass
-
-
-class Reset:
-    """Reset the robot"""
-
-    Request = ResetRequest
-    Response = ResetResponse
-
-
-class StepRequest(ServiceRequest):
-    """Request to step the robot with an action"""
-
-    actuator_values: list = Field(
-        description="The array of actuator values to control the robot with"
-    )
-
-
-class StepResponse(ServiceResponse):
-    """Response to step request"""
-
-    pass
-
-
-class Step:
-    """Step the robot with an action"""
-
-    Request = StepRequest
-    Response = StepResponse