wrapyfi.middlewares package

Submodules

wrapyfi.middlewares.mqtt module

class wrapyfi.middlewares.mqtt.MqttMiddlewarePubSub(*args, **kwargs)

Bases: object

MQTT middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections.

static activate(broker_address: str = 'broker.emqx.io', broker_port: int = 1883, **kwargs)

Activate the MQTT middleware. Initializes the MQTT client with the provided address and options.

Parameters:

• broker_address – str: The MQTT broker address

• broker_port – int: The MQTT broker port

• kwargs – dict: Additional keyword arguments for the middleware

__init__(broker_address: str = 'broker.emqx.io', broker_port: int = 1883, client_id: str | None = None, **kwargs)

Initialize the MQTT middleware. This method is automatically called when the class is instantiated.

Parameters:

• broker_address – str: The MQTT broker address

• broker_port – int: The MQTT broker port

• client_id – str: The MQTT client ID

• kwargs – dict: Additional keyword arguments for compatibility with the interface

register_callback(topic: str, callback)

Register an event handler for a specific topic.

Parameters:

• topic – str: The topic to subscribe to

• callback – callable: The function to call when a message is received on this topic

is_connected() → bool

Check whether the MQTT client is connected.

Returns:

bool: True if connected, False otherwise.

static deinit()

Deinitialize the MQTT middleware. This method is automatically called when the program exits.

wrapyfi.middlewares.ros module

class wrapyfi.middlewares.ros.ROSMiddleware(*args, **kwargs)

Bases: object

ROS middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections. The activate and deinit methods are automatically called when the class is instantiated and when the program exits, respectively.

static activate(**kwargs)

Activate the ROS middleware. This method should be called to initialize the middleware.

Parameters:

kwargs – dict: Keyword arguments to be passed to the ROS initialization function

__init__(node_name: str = 'wrapyfi', anonymous: bool = True, disable_signals: bool = True, *args, **kwargs)

Initialize the ROS middleware. This method is automatically called when the class is instantiated.

Parameters:

• node_name – str: The name of the ROS node

• anonymous – bool: Whether the ROS node should be anonymous

• disable_signals – bool: Whether the ROS node should disable signals

• args – list: Positional arguments to be passed to the ROS initialization function

• kwargs – dict: Keyword arguments to be passed to the ROS initialization function

static deinit()

Deinitialize the ROS middleware. This method is automatically called when the program exits.

class wrapyfi.middlewares.ros.ROSNativeObjectService

Bases: object

class wrapyfi.middlewares.ros.ROSImageService

Bases: object

wrapyfi.middlewares.ros2 module

class wrapyfi.middlewares.ros2.ROS2Middleware(*args, **kwargs)

Bases: object

ROS 2 middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections. The activate and deinit methods are automatically called when the class is instantiated and when the program exits, respectively.

static activate(**kwargs)

Activate the ROS 2 middleware. This method should be called to initialize the middleware.

Parameters:

kwargs – dict: Keyword arguments to be passed to the ROS 2 initialization function

__init__(*args, **kwargs)

Initialize the ROS 2 middleware. This method is automatically called when the class is instantiated.

Parameters:

• args – list: Positional arguments to be passed to the ROS 2 initialization function

• kwargs – dict: Keyword arguments to be passed to the ROS 2 initialization function

static deinit()

Deinitialize the ROS 2 middleware. This method is automatically called when the program exits.

wrapyfi.middlewares.websocket module

class wrapyfi.middlewares.websocket.WebSocketMiddlewarePubSub(*args, **kwargs)

Bases: object

WebSocket middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections.

static activate(socket_address: str = 'http://127.0.0.1:5000', **kwargs)

Activate the WebSocket middleware. Initializes the WebSocket client with the provided address and options.

Parameters:

• socket_address – str: The WebSocket server address

• kwargs – dict: Additional keyword arguments for the middleware

__init__(socket_address: str = 'http://127.0.0.1:5000', monitor_listener_spawn: str | None = None, websocket_kwargs: dict | None = None, **kwargs)

Initialize the WebSocket middleware. This method is automatically called when the class is instantiated.

Parameters:

• socket_address – str: The WebSocket server address

• monitor_listener_spawn – str: Determines the type of listener spawn

• websocket_kwargs – dict: Additional keyword arguments for the WebSocket connection

• kwargs – dict: Additional keyword arguments for compatibility with the interface

register_callback(topic: str, callback)

Register an event handler for a specific topic.

Parameters:

• topic – str: The topic/event to listen to

• callback – callable: The function to call when the event occurs

is_connected() → bool

Check whether the WebSocket client is connected.

Returns:

bool: True if connected, False otherwise.

static deinit()

Deinitialize the WebSocket middleware. This method is automatically called when the program exits.

wrapyfi.middlewares.yarp module

class wrapyfi.middlewares.yarp.YarpMiddleware(*args, **kwargs)

Bases: object

YARP middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections. The activate and deinit methods are automatically called when the class is instantiated and when the program exits, respectively.

static activate(**kwargs)

Activate the YARP middleware. This method should be called to initialize the middleware.

Parameters:

kwargs – dict: Keyword arguments to be passed to the YARP initialization function

__init__(*args, **kwargs)

Initialize the YARP middleware. This method is automatically called when the class is instantiated.

static deinit()

Deinitialize the YARP middleware. This method is automatically called when the program exits.

wrapyfi.middlewares.zeromq module

class wrapyfi.middlewares.zeromq.ZeroMQMiddlewarePubSub(*args, **kwargs)

Bases: object

ZeroMQ PUB/SUB middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections. The activate and deinit methods are automatically called when the class is instantiated and when the program exits, respectively.

class ZeroMQSharedMonitorData(use_multiprocessing: bool = False)

Bases: object

Shared data class for the ZeroMQ PUB/SUB monitor. This class is used to share data between the main process and the monitor listener process/thread.

__init__(use_multiprocessing: bool = False)

Initialize the shared data class.

Parameters:

use_multiprocessing – bool: Whether to use multiprocessing or threading

add_topic(topic: str)

Add a topic to the shared data class.

Parameters:

topic – str: The topic to add

remove_topic(topic: str)

Remove a topic from the shared data class.

Parameters:

topic – str: The topic to remove

get_topics()

Get the list of topics in the shared data class.

Returns:

list: The list of topics

update_connection(topic: str, data: dict)

Update the connection data for a topic, e.g. the number of subscribers.

Parameters:

• topic – str: The topic to update

• data – dict: The connection data

remove_connection(topic: str)

Remove the connection data for a topic.

Parameters:

topic – str: The topic to remove

get_connections()

Get the connection data for all topics.

Returns:

dict: The connection data for all topics

is_connected(topic: str)

Check whether a topic is connected.

Parameters:

topic – str: The topic to check

static activate(**kwargs)

Activate the ZeroMQ PUB/SUB middleware. This method should be called to initialize the middleware.

Parameters:

kwargs – dict: Keyword arguments to be passed to the ZeroMQ initialization function

__init__(zeromq_proxy_kwargs: dict | None = None, zeromq_post_kwargs: dict | None = None, **kwargs)

Initialize the ZeroMQ PUB/SUB middleware. This method is automatically called when the class is instantiated.

Parameters:

• zeromq_proxy_kwargs – Optional[dict]: Keyword arguments to be passed to the ZeroMQ proxy initialization function

• zeromq_post_kwargs – Optional[dict]: Keyword arguments to be passed to the ZeroMQ initialization function (these are ZeroMQ options)

• kwargs – dict: Keyword arguments to be passed to the ZeroMQ initialization function

static proxy_thread(socket_pub_address: str = 'tcp://127.0.0.1:5555', socket_sub_address: str = 'tcp://127.0.0.1:5556', inproc_address: str = 'inproc://monitor')

Proxy thread for the ZeroMQ PUB/SUB proxy.

Parameters:

• socket_pub_address – str: The address of the PUB socket

• socket_sub_address – str: The address of the SUB socket

• inproc_address – str: The address of the inproc socket (connections within the same process, for exchanging subscription data between the proxy and the monitor)

static subscription_monitor_thread(inproc_address: str = 'inproc://monitor', socket_sub_address: str = 'tcp://127.0.0.1:5556', pubsub_monitor_topic: str = 'ZEROMQ/CONNECTIONS', verbose: bool = False)

Subscription monitor thread for the ZeroMQ PUB/SUB proxy.

Parameters:

• inproc_address – str: The address of the inproc socket (connections within the same process, for exchanging subscription data between the proxy and the monitor)

• socket_sub_address – str: The address of the SUB socket

• pubsub_monitor_topic – str: The topic to use for publishing subscription data

• verbose – bool: Whether to print debug messages

static deinit()

class wrapyfi.middlewares.zeromq.ZeroMQMiddlewareReqRep(*args, **kwargs)

Bases: object

ZeroMQ REQ/REP middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections. The activate and deinit methods are automatically called when the class is instantiated and when the program exits, respectively.

static activate(**kwargs)

Activate the ZeroMQ REQ/REP middleware. This method should be called to initialize the middleware.

Parameters:

kwargs – dict: Keyword arguments to be passed to the ZeroMQ initialization function

__init__(zeromq_proxy_kwargs: dict | None = None, zeromq_post_kwargs: dict | None = None, *args, **kwargs)

Initialize the ZeroMQ REQ/REP middleware. This method is automatically called when the class is instantiated.

Parameters:

• zeromq_proxy_kwargs – Optional[dict]: Keyword arguments to be passed to the ZeroMQ proxy initialization function

• zeromq_post_kwargs – Optional[dict]: Keyword arguments to be passed to the ZeroMQ initialization function (these are ZeroMQ options)

• args – list: Positional arguments to be passed to the ZeroMQ initialization function

• kwargs – dict: Keyword arguments to be passed to the ZeroMQ initialization function

static deinit()

class wrapyfi.middlewares.zeromq.ZeroMQMiddlewareParamServer(*args, **kwargs)

Bases: object

ZeroMQ parameter server middleware wrapper. This class is a singleton, so it can be instantiated only once. The activate method should be called to initialize the middleware. The deinit method should be called to deinitialize the middleware and destroy all connections. The activate and deinit methods are automatically called when the class is instantiated and when the program exits, respectively.

Note: This parameter server is experimental and not fully tested.

static activate(**kwargs)

__init__(zeromq_proxy_kwargs: dict | None = None, zeromq_post_kwargs: Optional = None, *args, **kwargs)

Initialize the ZeroMQ parameter server middleware. This method is automatically called when the class is instantiated.

Parameters:

• zeromq_proxy_kwargs – Optional[dict]: Keyword arguments to be passed to the ZeroMQ proxy initialization function

• zeromq_post_kwargs – Optional[dict]: Keyword arguments to be passed to the ZeroMQ initialization function (these are ZeroMQ options)

• kwargs – dict: Keyword arguments to be passed to the ZeroMQ initialization function

static publish_params(param_server, params: dict, cached_params: dict, root_topics: set, update_trigger: bool)

Publish parameters to the parameter server.

Parameters:

• param_server – zmq.Socket: The parameter server socket

• params – dict: The parameters to be published

• cached_params – dict: The cached parameters. This is used to check whether the parameters have changed

• root_topics – set: The root topics. This is used to check whether there are any active subscribers

• update_trigger – bool: Whether to trigger an update of the parameters

Returns:

Tuple[bool, dict]: Whether to trigger an update of the parameters and the cached parameters

static deinit()

Deinitialize the ZeroMQ parameter server.

Module contents