Coverage for faststream/confluent/parser.py: 91%

20 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1from typing import TYPE_CHECKING, Any, cast 

2 

3from faststream.message import StreamMessage, decode_message 

4 

5from .message import FAKE_CONSUMER, KafkaMessage 

6 

7if TYPE_CHECKING: 

8 from collections.abc import Sequence 

9 

10 from confluent_kafka import Message 

11 

12 from faststream._internal.basic_types import DecodedMessage 

13 

14 from .message import ConsumerProtocol 

15 

16 # Type of headers returned by confluent_kafka Message.headers() 

17 _HeadersInput = ( 

18 dict[str, str | bytes | None] 

19 | list[tuple[str, str | bytes | None]] 

20 | tuple[tuple[str, str | bytes | None], ...] 

21 ) 

22 

23 

24class AsyncConfluentParser: 

25 """A class to parse Kafka messages.""" 

26 

27 __slots__ = ( 

28 "_consumer", 

29 "is_manual", 

30 ) 

31 

32 def __init__(self, is_manual: bool = False) -> None: 

33 self.is_manual = is_manual 

34 self._consumer: ConsumerProtocol = FAKE_CONSUMER 

35 

36 def _setup(self, consumer: "ConsumerProtocol") -> None: 

37 self._consumer = consumer 

38 

39 async def parse_message( 

40 self, 

41 message: "Message", 

42 ) -> KafkaMessage: 

43 """Parses a Kafka message.""" 

44 headers = _parse_msg_headers(cast("_HeadersInput", message.headers() or ())) 

45 

46 body = message.value() or b"" 

47 offset = message.offset() 

48 _, timestamp = message.timestamp() 

49 

50 return KafkaMessage( 

51 body=body, 

52 headers=headers, 

53 reply_to=headers.get("reply_to", ""), 

54 content_type=headers.get("content-type"), 

55 message_id=f"{offset}-{timestamp}", 

56 correlation_id=headers.get("correlation_id"), 

57 raw_message=message, 

58 consumer=self._consumer, 

59 is_manual=self.is_manual, 

60 ) 

61 

62 async def parse_batch( 

63 self, 

64 message: tuple["Message", ...], 

65 ) -> KafkaMessage: 

66 """Parses a batch of messages from a Kafka consumer.""" 

67 body: list[Any] = [] 

68 batch_headers: list[dict[str, str]] = [] 

69 

70 first = message[0] 

71 last = message[-1] 

72 

73 for m in message: 

74 body.append(m.value() or b"") 

75 batch_headers.append( 

76 _parse_msg_headers(cast("_HeadersInput", m.headers() or ())) 

77 ) 

78 

79 headers = next(iter(batch_headers), {}) 

80 

81 _, first_timestamp = first.timestamp() 

82 

83 return KafkaMessage( 

84 body=body, 

85 headers=headers, 

86 batch_headers=batch_headers, 

87 reply_to=headers.get("reply_to", ""), 

88 content_type=headers.get("content-type"), 

89 message_id=f"{first.offset()}-{last.offset()}-{first_timestamp}", 

90 correlation_id=headers.get("correlation_id"), 

91 raw_message=message, 

92 consumer=self._consumer, 

93 is_manual=self.is_manual, 

94 ) 

95 

96 async def decode_message( # ruff: ignore[no-self-use] 

97 self, 

98 msg: "StreamMessage[Message]", 

99 ) -> "DecodedMessage": 

100 """Decodes a message.""" 

101 return decode_message(msg) 

102 

103 async def decode_batch( 

104 self, 

105 msg: "StreamMessage[tuple[Message, ...]]", 

106 ) -> "DecodedMessage": 

107 """Decode a batch of messages.""" 

108 return [decode_message(await self.parse_message(m)) for m in msg.raw_message] 

109 

110 

111def _parse_msg_headers(headers: "_HeadersInput") -> dict[str, str]: 

112 """Decode header values into a text view without changing the native message.""" 

113 if isinstance(headers, dict): 113 ↛ 114line 113 didn't jump to line 114 because the condition on line 113 was never true

114 seq: Sequence[tuple[str, bytes | str | None]] = list(headers.items()) 

115 else: 

116 seq = headers 

117 return { 

118 key: (value if isinstance(value, str) else value.decode(errors="replace")) 

119 for key, value in seq 

120 if value is not None 

121 }