Coverage for faststream/kafka/configs/broker.py: 94%

27 statements  

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

1from collections.abc import Callable 

2from dataclasses import dataclass, field 

3from functools import partial 

4from types import MappingProxyType 

5from typing import Any 

6 

7import aiokafka 

8 

9from faststream.__about__ import SERVICE_NAME 

10from faststream._internal.configs import ( 

11 BrokerConfig, 

12 UnderlyingDriverAnnotation, 

13 UnderlyingDriverAnnotations, 

14) 

15from faststream._internal.parser import DefaultCodec 

16from faststream._internal.utils.data import filter_by_dict 

17from faststream.kafka.helpers import AdminService 

18from faststream.kafka.publisher.producer import ( 

19 AioKafkaFastProducer, 

20 FakeAioKafkaFastProducer, 

21) 

22from faststream.kafka.schemas.params import ConsumerConnectionParams 

23 

24 

25def _context_annotations_factory() -> UnderlyingDriverAnnotations: 

26 # `annotations` reaches this module through the broker, so the 

27 # objects a row needs only exist once the package is built. 

28 from aiokafka.consumer.consumer import AIOKafkaConsumer # ruff: ignore[import-outside-top-level] 

29 

30 from faststream.kafka import annotations # ruff: ignore[import-outside-top-level] 

31 from faststream.kafka.broker.broker import ( # ruff: ignore[import-outside-top-level] 

32 KafkaBroker as KafkaBrokerDriver, 

33 ) 

34 from faststream.kafka.message import ( # ruff: ignore[import-outside-top-level] 

35 KafkaMessage as KafkaMessageDriver, 

36 ) 

37 from faststream.kafka.publisher.producer import AioKafkaFastProducer # ruff: ignore[import-outside-top-level] 

38 

39 return MappingProxyType( 

40 { 

41 AIOKafkaConsumer: UnderlyingDriverAnnotation( 

42 type_hint=annotations.Consumer, 

43 module="faststream.kafka.annotations", 

44 name="Consumer", 

45 ), 

46 KafkaBrokerDriver: UnderlyingDriverAnnotation( 

47 type_hint=annotations.KafkaBroker, 

48 module="faststream.kafka.annotations", 

49 name="KafkaBroker", 

50 ), 

51 KafkaMessageDriver: UnderlyingDriverAnnotation( 

52 type_hint=annotations.KafkaMessage, 

53 module="faststream.kafka.annotations", 

54 name="KafkaMessage", 

55 ), 

56 AioKafkaFastProducer: UnderlyingDriverAnnotation( 

57 type_hint=annotations.KafkaProducer, 

58 module="faststream.kafka.annotations", 

59 name="KafkaProducer", 

60 ), 

61 }, 

62 ) 

63 

64 

65@dataclass(kw_only=True) 

66class KafkaBrokerConfig(BrokerConfig): 

67 producer: "AioKafkaFastProducer" = field(default_factory=FakeAioKafkaFastProducer) 

68 builder: Callable[..., aiokafka.AIOKafkaConsumer] = lambda: None 

69 

70 client_id: str | None = SERVICE_NAME 

71 client_rack: str | None = None 

72 consumer_only: bool = False 

73 allow_auto_create_topics: bool = True 

74 admin: AdminService = field(default_factory=AdminService) 

75 

76 default_driver_annotations: UnderlyingDriverAnnotations = field( 

77 default_factory=_context_annotations_factory, 

78 ) 

79 

80 @property 

81 def admin_client(self) -> "aiokafka.admin.client.AIOKafkaAdminClient": 

82 return self.admin.client 

83 

84 async def connect(self, **connection_kwargs: Any) -> "None": 

85 # In consumer-only mode the broker neither produces messages nor needs 

86 # admin permissions, so skip creating those clients to allow callers 

87 # to use credentials scoped to read-only ACLs. 

88 if not self.consumer_only: 

89 producer = aiokafka.AIOKafkaProducer(**connection_kwargs) 

90 await self.producer.connect( 

91 producer, 

92 serializer=self.fd_config._serializer, 

93 codec=self.broker_codec or DefaultCodec(), 

94 ) 

95 await self.admin.connect(**connection_kwargs) 

96 

97 consumer_options, _ = filter_by_dict( 

98 ConsumerConnectionParams, 

99 connection_kwargs, 

100 ) 

101 # client_rack is consumer-only, so it is not part of connection_kwargs 

102 # (which is also used to build the producer); inject it here when set. 

103 if self.client_rack is not None: 103 ↛ 104line 103 didn't jump to line 104 because the condition on line 103 was never true

104 consumer_options["client_rack"] = self.client_rack 

105 self.builder = partial(aiokafka.AIOKafkaConsumer, **consumer_options) 

106 

107 async def disconnect(self) -> "None": 

108 await self.admin.disconnect() 

109 

110 if not self.consumer_only: 

111 await self.producer.disconnect()