betterproto-rust-codec (Rust-backed Protobuf Codec)

0.1.1 · active · verified Fri Apr 10

betterproto-rust-codec provides a high-performance codec for `betterproto` messages, leveraging a Rust implementation to serialize and deserialize Protobuf wire format. It significantly speeds up conversion compared to Python-native alternatives, especially for large or frequently processed messages. The current version is 0.1.1, and releases are generally ad-hoc, often in response to `betterproto` updates or targeted performance improvements.

Warnings

breaking This library has strict dependency requirements for `betterproto`. Ensure your `betterproto` version meets the minimum requirement specified by `betterproto-rust-codec` (currently `>=2.0.0b6`). Using incompatible versions can lead to runtime errors or incorrect serialization.
Fix: Upgrade `betterproto` to the required version: `pip install betterproto>="2.0.0b6"` or check the `pyproject.toml` of `betterproto-rust-codec` for the exact requirement.
breaking Similarly, `betterproto-rust-codec` also has a minimum requirement for the `protobuf` library itself (currently `>=3.20.0`). Incompatible `protobuf` versions might cause issues with underlying type conversions or wire format interpretation.
Fix: Upgrade `protobuf` to the required version: `pip install protobuf>="3.20.0"` or check the `pyproject.toml` of `betterproto-rust-codec` for the exact requirement.
gotcha This codec is designed exclusively for `betterproto` messages. It will not work directly with messages generated by `protoc` or other standard `protobuf` Python libraries without first converting them to `betterproto` types.
Fix: Ensure you are using `betterproto.Message` subclasses. If working with non-betterproto messages, use the standard `protobuf` library's encoding/decoding or convert messages to `betterproto` format first.
gotcha While providing significant performance benefits, `betterproto-rust-codec` introduces a Rust dependency (compiled into a wheel). For extremely simple use cases or environments where Rust compilation might be an issue (e.g., highly restricted embedded systems, though pre-built wheels usually mitigate this), the overhead might not be justified if performance isn't a critical concern.
Fix: Evaluate your performance needs. If speed is paramount for Protobuf serialization/deserialization, this library is highly recommended. Otherwise, Python-native `betterproto` encoding/decoding might suffice.

Install

pip install betterproto-rust-codec Install betterproto-rust-codec

Imports

ProtobufCodec

from betterproto_rust_codec import ProtobufCodec

Quickstart

This quickstart demonstrates how to define a `betterproto` message, instantiate the `ProtobufCodec`, and then use it to efficiently encode and decode the message to and from Protobuf wire format bytes.

import betterproto
from betterproto.lib.google.protobuf import Timestamp
from betterproto_rust_codec import ProtobufCodec
import datetime

@betterproto.dataclass
class MyMessage(betterproto.Message):
    name: str = betterproto.string_field(1)
    value: int = betterproto.int32_field(2)
    timestamp: Timestamp = betterproto.message_field(3, wraps=True)

# Create an instance of the codec
codec = ProtobufCodec()

# Create a betterproto message
now_timestamp = Timestamp().from_datetime(datetime.datetime.now(datetime.timezone.utc))
original_message = MyMessage(
    name="Test Name",
    value=123,
    timestamp=now_timestamp
)

print(f"Original message: {original_message}")

# Encode the message
encoded_bytes = codec.encode(original_message)
print(f"Encoded bytes length: {len(encoded_bytes)}")

# Decode the message
decoded_message = codec.decode(MyMessage, encoded_bytes)

# Verify
print(f"Decoded message: {decoded_message}")
assert original_message.name == decoded_message.name
assert original_message.value == decoded_message.value
assert original_message.timestamp.seconds == decoded_message.timestamp.seconds
print("\nEncode/Decode successful!")

view raw JSON →