Coverage for faststream/kafka/message.py: 98%

30 statements  

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

1from typing import Any, Protocol, Union 

2 

3from aiokafka import ( 

4 AIOKafkaConsumer, 

5 ConsumerRecord, 

6 TopicPartition as AIOKafkaTopicPartition, 

7) 

8 

9from faststream.message import AckStatus, StreamMessage 

10 

11 

12class ConsumerProtocol(Protocol): 

13 """A protocol for Kafka consumers.""" 

14 

15 async def commit(self) -> None: ... 

16 

17 def seek( 

18 self, 

19 partition: AIOKafkaTopicPartition, 

20 offset: int, 

21 ) -> None: 

22 pass 

23 

24 

25class FakeConsumer: 

26 """A fake Kafka consumer.""" 

27 

28 async def commit(self) -> None: 

29 pass 

30 

31 def seek( 

32 self, 

33 partition: AIOKafkaTopicPartition, 

34 offset: int, 

35 ) -> None: 

36 pass 

37 

38 

39FAKE_CONSUMER = FakeConsumer() 

40 

41 

42class KafkaRawMessage(ConsumerRecord[Any, Any]): # type: ignore[misc] 

43 consumer: AIOKafkaConsumer 

44 

45 

46class KafkaMessage( 

47 StreamMessage[ 

48 Union[ 

49 "ConsumerRecord[Any, Any]", 

50 tuple["ConsumerRecord[Any, Any]", ...], 

51 ] 

52 ], 

53): 

54 """Represents a Kafka message in the FastStream framework. 

55 

56 This class extends `StreamMessage` and is specialized for handling Kafka ConsumerRecord objects. 

57 """ 

58 

59 def __init__(self, *args: Any, consumer: ConsumerProtocol, **kwargs: Any) -> None: 

60 super().__init__(*args, **kwargs) 

61 self.consumer = consumer 

62 self.committed = AckStatus.ACKED 

63 

64 @property 

65 def raw_headers(self) -> dict[str, bytes | None]: 

66 """Original header bytes, or the first message's headers for a batch.""" 

67 raw_message = self.raw_message 

68 if isinstance(raw_message, tuple): 

69 if not raw_message: 

70 return {} 

71 raw_message = raw_message[0] 

72 return dict(raw_message.headers) 

73 

74 @property 

75 def batch_raw_headers(self) -> list[dict[str, bytes | None]]: 

76 """Original header bytes for every batch message; empty for a single message.""" 

77 if isinstance(self.raw_message, tuple): 

78 return [dict(message.headers) for message in self.raw_message] 

79 return [] 

80 

81 

82class KafkaAckableMessage(KafkaMessage): 

83 def __init__(self, *args: Any, **kwargs: Any) -> None: 

84 super().__init__(*args, **kwargs) 

85 self.committed = None 

86 

87 async def ack(self) -> None: 

88 if not self.committed: 

89 await self.consumer.commit() 

90 await super().ack() 

91 

92 async def reject(self) -> None: 

93 await self.ack() 

94 

95 async def nack(self) -> None: 

96 if not self.committed: 96 ↛ 112line 96 didn't jump to line 112 because the condition on line 96 was always true

97 # A batch may span several partitions: rewind each one to its earliest 

98 # record, so none of them is committed past an unprocessed message. 

99 records = ( 

100 self.raw_message 

101 if isinstance(self.raw_message, tuple) 

102 else (self.raw_message,) 

103 ) 

104 earliest: dict[AIOKafkaTopicPartition, int] = {} 

105 for record in records: 

106 topic_partition = AIOKafkaTopicPartition(record.topic, record.partition) 

107 offset = earliest.get(topic_partition) 

108 if offset is None or record.offset < offset: 

109 earliest[topic_partition] = record.offset 

110 for topic_partition, offset in earliest.items(): 

111 self.consumer.seek(partition=topic_partition, offset=offset) 

112 await super().nack()