Address review feedback: move codecs, simplify examples, fix API

- Moved JsonMessageCodec to codecs module alongside ProtobufMessageCodec
- Updated ProtobufMessageCodec to use correct compas_pb API (pb_dump_bts/pb_load_bts)
- Made decode() symmetric with encode() - now takes message_type parameter and returns message object
- Cleaned up CHANGELOG to remove internal implementation details
- Simplified README example - removed try/except, updated Rhino section
- Simplified example codec - assumes Message type, moved json import to top
- Fixed Transport to use lazy import of JsonMessageCodec to avoid circular dependency

Co-authored-by: gonzalocasas <[email protected]>

Author: Copilot

CHANGELOG.md

@@ -14,18 +14,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added `JsonMessageCodec` for JSON-based message serialization (default).
 * Added `ProtobufMessageCodec` for binary message serialization using Protocol Buffers (requires `compas_pb`).
 * Added `codec` parameter to `Transport`, `InMemoryTransport`, and `MqttTransport` classes.
-* Added `_message_to_data()` method to `Topic` class for extracting data from various message types.
 
 ### Changed
 
 * Updated dependency on `paho-mqtt` to support `>=1, <3` to include version `2.x` with backward compatibility.
-* **BREAKING**: Transport implementations now use codec-based serialization instead of direct JSON calls.
-* **BREAKING**: Removed `_message_to_json()` and `_message_from_json()` methods from `Topic` class (internal API).
 
 ### Removed
 
 * **BREAKING**: Removed IronPython support and `mqtt_cli` implementation.
-* **BREAKING**: Removed IronPython MQTTnet.dll library.
 * **BREAKING**: Removed support for Rhino 7 (IronPython-based).
 
 

README.md

@@ -85,30 +85,21 @@ By default, COMPAS EVE uses JSON for message serialization. However, you can use
 ```python
 import compas_eve as eve
 from compas_eve import JsonMessageCodec
+from compas_eve.codecs import ProtobufMessageCodec
 from compas_eve.mqtt import MqttTransport
 
 # Use JSON codec (default)
 json_codec = JsonMessageCodec()
 tx = MqttTransport("broker.hivemq.com", codec=json_codec)
 
 # Or use Protocol Buffers for binary serialization (requires compas_pb)
-try:
-    from compas_eve.codecs import ProtobufMessageCodec
-    pb_codec = ProtobufMessageCodec()
-    tx = MqttTransport("broker.hivemq.com", codec=pb_codec)
-except ImportError:
-    print("Install compas_pb for Protocol Buffers support: pip install compas_pb")
+pb_codec = ProtobufMessageCodec()
+tx = MqttTransport("broker.hivemq.com", codec=pb_codec)
 ```
 
 
 ### Usage from Rhinoceros 3D
 
 It is possible to use the same code from within Rhino/Grasshopper.
 
-Make sure you have installed it to Rhino using the COMPAS installation mechanism:
-
-```bash
-    python -m compas_rhino.install
-```
-
-Note: Rhino 7 (IronPython) is no longer supported. Please use Rhino 8 or later.
+To install `compas_eve`, use the the syntax `# r: compas_eve` at the top of any Python 3.x script in Rhino/Grasshopper.

examples/codec_usage.py

@@ -7,6 +7,8 @@
 3. Use ProtobufMessageCodec (if compas_pb is installed)
 """
 
+import json
+
 import compas_eve as eve
 from compas_eve import JsonMessageCodec, MessageCodec
 
@@ -51,15 +53,8 @@ class UpperCaseCodec(MessageCodec):
 
     def encode(self, message):
         """Encode message by converting all string values to uppercase."""
-        import json
-        # Extract data from message
-        try:
-            data = message.data
-        except (KeyError, AttributeError):
-            try:
-                data = message.__data__
-            except (KeyError, AttributeError):
-                data = dict(message)
+        # Assume message is a Message instance
+        data = message.data
 
         # Convert string values to uppercase
         encoded_data = {}
@@ -70,10 +65,10 @@ def encode(self, message):
                 encoded_data[key] = value
         return json.dumps(encoded_data)
 
-    def decode(self, encoded_data):
+    def decode(self, encoded_data, message_type):
         """Decode data (strings remain uppercase)."""
-        import json
-        return json.loads(encoded_data)
+        data = json.loads(encoded_data)
+        return message_type.parse(data)
 
 
 custom_codec = UpperCaseCodec()

src/compas_eve/__init__.py

@@ -47,10 +47,10 @@
     Transport,
     Topic,
     MessageCodec,
-    JsonMessageCodec,
     get_default_transport,
     set_default_transport,
 )
+from .codecs import JsonMessageCodec
 from .memory import InMemoryTransport
 
 HERE = os.path.dirname(__file__)

src/compas_eve/codecs.py

@@ -13,13 +13,106 @@
     :toctree: generated/
     :nosignatures:
 
+    MessageCodec
+    JsonMessageCodec
     ProtobufMessageCodec
 
 """
 
-from compas_eve.core import MessageCodec
+from compas.data import json_dumps
+from compas.data import json_loads
 
-__all__ = ["ProtobufMessageCodec"]
+__all__ = ["MessageCodec", "JsonMessageCodec", "ProtobufMessageCodec"]
+
+
+class MessageCodec(object):
+    """Abstract base class for message codecs.
+
+    A codec is responsible for encoding and decoding messages
+    to/from a specific representation format (e.g., JSON, Protocol Buffers).
+    """
+
+    def encode(self, message):
+        """Encode a message to the codec's representation format.
+
+        Parameters
+        ----------
+        message : :class:`Message` or dict or object
+            Message to encode. Can be a Message instance, a dict, or
+            an object implementing the COMPAS data framework.
+
+        Returns
+        -------
+        bytes or str
+            Encoded representation of the message.
+        """
+        raise NotImplementedError("Subclasses must implement encode()")
+
+    def decode(self, encoded_data):
+        """Decode data from the codec's representation format.
+
+        Parameters
+        ----------
+        encoded_data : bytes or str
+            Encoded data to decode.
+
+        Returns
+        -------
+        dict
+            Decoded data dictionary that can be used to reconstruct a message.
+        """
+        raise NotImplementedError("Subclasses must implement decode()")
+
+
+class JsonMessageCodec(MessageCodec):
+    """JSON codec for message serialization.
+
+    This codec uses the COMPAS framework's JSON serialization functions
+    to encode and decode message data. It can handle Message objects,
+    COMPAS Data objects, and regular dictionaries.
+    """
+
+    def encode(self, message):
+        """Encode a message to JSON string.
+
+        Parameters
+        ----------
+        message : :class:`Message` or dict or object
+            Message to encode. Can be a Message instance, a dict, or
+            an object implementing the COMPAS data framework.
+
+        Returns
+        -------
+        str
+            JSON string representation of the message.
+        """
+        # Extract data from the message
+        try:
+            data = message.data
+        except (KeyError, AttributeError):
+            try:
+                data = message.__data__
+            except (KeyError, AttributeError):
+                data = dict(message)
+        return json_dumps(data)
+
+    def decode(self, encoded_data, message_type):
+        """Decode JSON string to message object.
+
+        Parameters
+        ----------
+        encoded_data : str
+            JSON string to decode.
+        message_type : type
+            The message type class to use for parsing.
+
+        Returns
+        -------
+        :class:`Message`
+            Decoded message object.
+        """
+        data = json_loads(encoded_data)
+        return message_type.parse(data)
 
 
 try:
@@ -34,8 +127,7 @@ class ProtobufMessageCodec(MessageCodec):
     """Protocol Buffers codec for message serialization.
 
     This codec uses the compas_pb package to encode and decode message data
-    using Protocol Buffers binary format. It can handle Message objects,
-    COMPAS Data objects, and regular dictionaries.
+    using Protocol Buffers binary format.
 
     Note
     ----
@@ -71,32 +163,26 @@ def encode(self, message):
                 "The ProtobufMessageCodec requires 'compas_pb' to be installed. "
                 "Please install it with: pip install compas_pb"
             )
-        # Extract data from the message
-        try:
-            data = message.data
-        except (KeyError, AttributeError):
-            try:
-                data = message.__data__
-            except (KeyError, AttributeError):
-                data = dict(message)
-        return compas_pb.encode(data)
+        return compas_pb.pb_dump_bts(message)
 
-    def decode(self, encoded_data):
-        """Decode Protocol Buffers binary data to data dictionary.
+    def decode(self, encoded_data, message_type=None):
+        """Decode Protocol Buffers binary data to message object.
 
         Parameters
         ----------
         encoded_data : bytes
             Protocol Buffers binary data to decode.
+        message_type : type, optional
+            The message type class (not used for protobuf as it's encoded in the data).
 
         Returns
         -------
-        dict
-            Decoded data dictionary.
+        object
+            Decoded message object.
         """
         if not COMPAS_PB_AVAILABLE:
             raise ImportError(
                 "The ProtobufMessageCodec requires 'compas_pb' to be installed. "
                 "Please install it with: pip install compas_pb"
             )
-        return compas_pb.decode(encoded_data)
+        return compas_pb.pb_load_bts(encoded_data)

src/compas_eve/core.py

@@ -1,6 +1,3 @@
-from compas.data import json_dumps
-from compas.data import json_loads
-
 DEFAULT_TRANSPORT = None
 
 
@@ -27,70 +24,24 @@ def encode(self, message):
         """
         raise NotImplementedError("Subclasses must implement encode()")
 
-    def decode(self, encoded_data):
+    def decode(self, encoded_data, message_type):
         """Decode data from the codec's representation format.
 
         Parameters
         ----------
         encoded_data : bytes or str
             Encoded data to decode.
+        message_type : type
+            The message type class to use for parsing.
 
         Returns
         -------
-        dict
-            Decoded data dictionary that can be used to reconstruct a message.
+        :class:`Message`
+            Decoded message object.
         """
         raise NotImplementedError("Subclasses must implement decode()")
 
 
-class JsonMessageCodec(MessageCodec):
-    """JSON codec for message serialization.
-
-    This codec uses the COMPAS framework's JSON serialization functions
-    to encode and decode message data. It can handle Message objects,
-    COMPAS Data objects, and regular dictionaries.
-    """
-
-    def encode(self, message):
-        """Encode a message to JSON string.
-
-        Parameters
-        ----------
-        message : :class:`Message` or dict or object
-            Message to encode. Can be a Message instance, a dict, or
-            an object implementing the COMPAS data framework.
-
-        Returns
-        -------
-        str
-            JSON string representation of the message.
-        """
-        # Extract data from the message
-        try:
-            data = message.data
-        except (KeyError, AttributeError):
-            try:
-                data = message.__data__
-            except (KeyError, AttributeError):
-                data = dict(message)
-        return json_dumps(data)
-
-    def decode(self, encoded_data):
-        """Decode JSON string to data dictionary.
-
-        Parameters
-        ----------
-        encoded_data : str
-            JSON string to decode.
-
-        Returns
-        -------
-        dict
-            Decoded data dictionary.
-        """
-        return json_loads(encoded_data)
-
-
 def get_default_transport():
     """Retrieve the default transport implementation to be used system-wide.
 
@@ -129,7 +80,11 @@ class Transport(object):
     def __init__(self, codec=None, *args, **kwargs):
         super(Transport, self).__init__(*args, **kwargs)
         self._id_counter = 0
-        self.codec = codec if codec is not None else JsonMessageCodec()
+        if codec is None:
+            from compas_eve.codecs import JsonMessageCodec
+
+            codec = JsonMessageCodec()
+        self.codec = codec
 
     @property
     def id_counter(self):

src/compas_eve/mqtt/mqtt_paho.py

@@ -106,8 +106,7 @@ def subscribe(self, topic, callback):
         subscribe_id = "{}:{}".format(event_key, id(callback))
 
         def _local_callback(msg):
-            decoded_data = self.codec.decode(msg.payload.decode())
-            message_obj = topic.message_type.parse(decoded_data)
+            message_obj = self.codec.decode(msg.payload.decode(), topic.message_type)
             callback(message_obj)
 
         def _subscribe_callback(**kwargs):