Client for ws-protocol in python

[EnzoGhisoni]

Is there a python client for foxglove ws-protocol ?
Or an example about a client in python with the library websockets ?

I try to communicate with a ROS2 application running ros-foxglove-bridge by using websockets (the sub-protocol foxglove.websocket.v1). i'm able to subscribe to topics and listen for messages but I was not able to decode the bytes message (cdr). The messages received are raw bits messages here is what i get from a string:
b'\x01\x03\x00\x00\x00\x00\x88\xe3\x1bZ\x05\xc7\x17\x00\x01\x00\x00I\x00\x00\x00Hello, world! Time(nanoseconds=1713344067810695536, clock_type=ROS_TIME)\x00\x00\x00\x00'

I tried to use mcap (https://github.com/foxglove/mcap/tree/b8a73890348ef2dc69272b377fd2faab56f0303f) python examples to decode the bytes but I got the error: AttributeError: 'bytes' object has no attribute 'seekable'.
I also tried to use deserialize_message from rclpy.serialization but I have the following error: rclpy._rclpy_pybind11.RMWError: failed to deserialize ROS message: rmw_serialize

Platform:
Ubuntu 22.04
Test in localhost
Data from ROS2 humble using ros-foxglove-bridge using commit [e37a3e1]

Here is my script:

import asyncio
import websockets
import json

from std_msgs.msg import String
from rclpy.serialization import deserialize_message

from mcap.reader import make_reader
from mcap_ros2.reader import read_ros2_messages
from mcap_ros2.decoder import DecoderFactory

async def handle_event(websocket, message, subscribed):
    # Handle different types of events here
    print("Received event:", message)
    
    if subscribed == False:
        
        subscribed = True
        subsriber = {
            "op": "subscribe",
            "subscriptions": [
                {"id": 3, "channelId": 3} # replace by the selected channel id the subscribe
            ]
        }
        await websocket.send(json.dumps(subsriber))
    
    if type(message) == bytes:
        print("Start to deserialize")
        message_type = String()

        # Decode the message here

        #decoded_data = deserialize_message(serialized_message=message, message_type=message_type)
        
        # print(decoded_data)

async def connect_to_server():
    uri = "ws://0.0.0.0:9090"  # Change this to your server URI
    subscribed = False
    async with websockets.connect(uri, subprotocols=["foxglove.websocket.v1"]) as websocket:
        print("Connected to server.")
        try:
            while True:
                message = await websocket.recv()
                
                await handle_event(websocket, message, subscribed)
                subscribed = True
        except websockets.ConnectionClosed:
            print("Connection to server closed.")

async def main():
    await connect_to_server()

if __name__ == "__main__":
    asyncio.run(main())

[defunctzombie]

We don't have a python client library. The challenge you will have with decoding the raw ROS2 CDR data in python is that you need to lookup (or build at runtime) a deserializer for the specific message you want to read. It looks like you understand some part of that by trying to invoke the "deserialize_message" method from rclpy with the String type. Is that the type of the message you are trying to deserialize?

An error like AttributeError: 'bytes' object has no attribute 'seekable'. indicates to me that you are passing some sort of object that deserialize_message does not support. This is a more ROS 2 specific question so you might have more luck asking on the ROS 2 support forums on what kind of type needs to be passed to deserialize_message if bytes is not sufficient.

[zugaldia]

I see that starting with 0.8, the bridge now supports JSON encoding for ROS2. Does that mean that there is a parameter we can use to receive messages in JSON rather than in binary CDR?

[achim-k]

JSON encoding is currently only supported for publishing messages from the client to the server