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
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
1from typing import TYPE_CHECKING, Any, cast
3from faststream.message import StreamMessage, decode_message
5from .message import FAKE_CONSUMER, KafkaMessage
7if TYPE_CHECKING:
8 from collections.abc import Sequence
10 from confluent_kafka import Message
12 from faststream._internal.basic_types import DecodedMessage
14 from .message import ConsumerProtocol
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 )
24class AsyncConfluentParser:
25 """A class to parse Kafka messages."""
27 __slots__ = (
28 "_consumer",
29 "is_manual",
30 )
32 def __init__(self, is_manual: bool = False) -> None:
33 self.is_manual = is_manual
34 self._consumer: ConsumerProtocol = FAKE_CONSUMER
36 def _setup(self, consumer: "ConsumerProtocol") -> None:
37 self._consumer = consumer
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 ()))
46 body = message.value() or b""
47 offset = message.offset()
48 _, timestamp = message.timestamp()
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 )
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]] = []
70 first = message[0]
71 last = message[-1]
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 )
79 headers = next(iter(batch_headers), {})
81 _, first_timestamp = first.timestamp()
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 )
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)
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]
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 }