Coverage for faststream/redis/parser/binary.py: 99%
100 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
1import enum
2from collections.abc import Sequence
3from struct import pack, unpack
4from typing import TYPE_CHECKING, Any, Optional, Union
6from faststream._internal._compat import json_loads
8from .message import MessageFormat
10if TYPE_CHECKING:
11 from fast_depends.library.serializer import SerializerProto
13 from faststream._internal.basic_types import SendableMessage
14 from faststream._internal.parser import CodecProto
17class FastStreamMessageVersion(int, enum.Enum):
18 v1 = 1
21class BinaryMessageFormatV1(MessageFormat):
22 """Message format to encode into binary and parse it."""
24 __slots__ = ()
26 IDENTITY_HEADER = b"\x89BIN\x0d\x0a\x1a\x0a" # to avoid confusion with other formats
28 @classmethod
29 async def encode(
30 cls,
31 *,
32 message: Union[Sequence["SendableMessage"], "SendableMessage"],
33 reply_to: str | None,
34 headers: dict[str, Any] | None,
35 correlation_id: str,
36 serializer: Optional["SerializerProto"] = None,
37 codec: Optional["CodecProto"] = None,
38 ) -> bytes:
39 msg = await cls.build(
40 message=message,
41 reply_to=reply_to,
42 headers=headers,
43 correlation_id=correlation_id,
44 serializer=serializer,
45 codec=codec,
46 )
47 headers_writer = BinaryWriter()
48 for key, value in msg.headers.items():
49 headers_writer.write_string(key)
50 headers_writer.write_string(value)
52 headers_len = len(headers_writer.data)
53 writer = BinaryWriter()
54 writer.write(cls.IDENTITY_HEADER)
55 writer.write_short(FastStreamMessageVersion.v1.value)
56 headers_start = len(writer.data) + 8
57 data_start = 2 + headers_start + headers_len
58 writer.write_int(headers_start)
59 writer.write_int(data_start)
60 writer.write_short(len(msg.headers.items()))
61 writer.write(headers_writer.get_bytes())
62 writer.write(msg.data)
63 return writer.get_bytes()
65 @classmethod
66 def parse(cls, data: bytes) -> tuple[bytes, dict[str, Any]]:
67 headers: dict[str, Any] = {}
68 final_data: bytes
70 try:
71 reader = BinaryReader(data)
72 magic_header = reader.read_until(len(cls.IDENTITY_HEADER))
73 message_version = reader.read_short()
75 if (
76 magic_header == cls.IDENTITY_HEADER
77 and message_version == FastStreamMessageVersion.v1.value
78 ):
79 headers_start = reader.read_int()
80 data_start = reader.read_int()
81 reader.shift_offset_to(headers_start)
82 header_count = reader.read_short()
83 for _ in range(header_count):
84 key = reader.read_string()
85 value = reader.read_string()
86 headers[key] = value
88 reader.shift_offset_to(data_start)
89 final_data = reader.read_bytes()
91 else:
92 parsed_data = json_loads(data)
93 final_data = parsed_data["data"].encode()
94 headers = parsed_data["headers"]
96 except Exception:
97 # Raw Redis message format or legacy JSON envelope
98 try:
99 parsed_data = json_loads(data)
100 final_data = parsed_data["data"].encode()
101 headers = parsed_data.get("headers", {})
102 except Exception:
103 final_data = data
104 headers = {}
105 return final_data, headers
107 return final_data, headers
110class BinaryWriter:
111 __slots__ = ("data",)
113 def __init__(self) -> None:
114 self.data = bytearray()
116 def write(self, data: bytes) -> None:
117 self.data.extend(data)
119 def write_short(self, number: int) -> None:
120 int_bytes = pack(">H", number)
121 self.write(int_bytes)
123 def write_int(self, number: int) -> None:
124 int_bytes = pack(">I", number)
125 self.write(int_bytes)
127 def write_string(self, data: str | bytes) -> None:
128 if isinstance(data, str): 128 ↛ 130line 128 didn't jump to line 130 because the condition on line 128 was always true
129 data = data.encode()
130 self.write_short(len(data))
131 self.write(data)
133 def get_bytes(self) -> bytes:
134 return bytes(self.data)
137class BinaryReader:
138 __slots__ = (
139 "data",
140 "offset",
141 )
143 def __init__(self, data: bytes) -> None:
144 self.data = data
145 self.offset = 0
147 def read_until(self, offset: int) -> bytes:
148 data = self.data[self.offset : self.offset + offset]
149 self.offset += offset
150 return data
152 def shift_offset_to(self, offset: int) -> None:
153 self.offset = offset
155 def read_short(self) -> int:
156 data = unpack(">H", self.data[self.offset : self.offset + 2])[0]
157 self.offset += 2
158 return int(data)
160 def read_int(self) -> int:
161 data = unpack(">I", self.data[self.offset : self.offset + 4])[0]
162 self.offset += 4
163 return int(data)
165 def read_string(self) -> str:
166 str_len = self.read_short()
167 data = self.data[self.offset : self.offset + str_len]
168 self.offset += str_len
169 return data.decode()
171 def read_bytes(self) -> bytes:
172 return self.data[self.offset :]