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

1import enum 

2from collections.abc import Sequence 

3from struct import pack, unpack 

4from typing import TYPE_CHECKING, Any, Optional, Union 

5 

6from faststream._internal._compat import json_loads 

7 

8from .message import MessageFormat 

9 

10if TYPE_CHECKING: 

11 from fast_depends.library.serializer import SerializerProto 

12 

13 from faststream._internal.basic_types import SendableMessage 

14 from faststream._internal.parser import CodecProto 

15 

16 

17class FastStreamMessageVersion(int, enum.Enum): 

18 v1 = 1 

19 

20 

21class BinaryMessageFormatV1(MessageFormat): 

22 """Message format to encode into binary and parse it.""" 

23 

24 __slots__ = () 

25 

26 IDENTITY_HEADER = b"\x89BIN\x0d\x0a\x1a\x0a" # to avoid confusion with other formats 

27 

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) 

51 

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() 

64 

65 @classmethod 

66 def parse(cls, data: bytes) -> tuple[bytes, dict[str, Any]]: 

67 headers: dict[str, Any] = {} 

68 final_data: bytes 

69 

70 try: 

71 reader = BinaryReader(data) 

72 magic_header = reader.read_until(len(cls.IDENTITY_HEADER)) 

73 message_version = reader.read_short() 

74 

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 

87 

88 reader.shift_offset_to(data_start) 

89 final_data = reader.read_bytes() 

90 

91 else: 

92 parsed_data = json_loads(data) 

93 final_data = parsed_data["data"].encode() 

94 headers = parsed_data["headers"] 

95 

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 

106 

107 return final_data, headers 

108 

109 

110class BinaryWriter: 

111 __slots__ = ("data",) 

112 

113 def __init__(self) -> None: 

114 self.data = bytearray() 

115 

116 def write(self, data: bytes) -> None: 

117 self.data.extend(data) 

118 

119 def write_short(self, number: int) -> None: 

120 int_bytes = pack(">H", number) 

121 self.write(int_bytes) 

122 

123 def write_int(self, number: int) -> None: 

124 int_bytes = pack(">I", number) 

125 self.write(int_bytes) 

126 

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) 

132 

133 def get_bytes(self) -> bytes: 

134 return bytes(self.data) 

135 

136 

137class BinaryReader: 

138 __slots__ = ( 

139 "data", 

140 "offset", 

141 ) 

142 

143 def __init__(self, data: bytes) -> None: 

144 self.data = data 

145 self.offset = 0 

146 

147 def read_until(self, offset: int) -> bytes: 

148 data = self.data[self.offset : self.offset + offset] 

149 self.offset += offset 

150 return data 

151 

152 def shift_offset_to(self, offset: int) -> None: 

153 self.offset = offset 

154 

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) 

159 

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) 

164 

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() 

170 

171 def read_bytes(self) -> bytes: 

172 return self.data[self.offset :]