Coverage for faststream/specification/asyncapi/factory.py: 97%

29 statements  

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

1from collections.abc import Sequence 

2from typing import TYPE_CHECKING, Any, Literal, Optional, Union 

3 

4from faststream.specification.base import Specification, SpecificationFactory 

5 

6if TYPE_CHECKING: 

7 from faststream._internal.basic_types import AnyHttpUrl 

8 from faststream._internal.broker import BrokerUsecase 

9 from faststream.asgi.handlers import HttpHandler 

10 from faststream.specification.schema import Contact, ExternalDocs, License, Tag 

11 

12 

13class AsyncAPI(SpecificationFactory): 

14 """Unslotted, following `SpecificationFactory`: one of these exists per app.""" 

15 

16 def __init__( 

17 self, 

18 /, 

19 *brokers: "BrokerUsecase[Any, Any, Any]", 

20 title: str = "FastStream", 

21 version: str = "0.1.0", 

22 description: str | None = None, 

23 terms_of_service: Optional["AnyHttpUrl"] = None, 

24 license: Union["License", "dict[str, Any]"] | None = None, 

25 contact: Union["Contact", "dict[str, Any]"] | None = None, 

26 tags: Sequence[Union["Tag", "dict[str, Any]"]] = (), 

27 external_docs: Union["ExternalDocs", "dict[str, Any]"] | None = None, 

28 identifier: str | None = None, 

29 schema_version: Literal["3.0.0", "2.6.0"] | str = "3.0.0", 

30 ) -> None: 

31 self.title = title 

32 self.version = version 

33 self.description = description 

34 self.terms_of_service = terms_of_service 

35 self.license = license 

36 self.contact = contact 

37 self.tags = tags 

38 self.external_docs = external_docs 

39 self.identifier = identifier 

40 self.schema_version = schema_version 

41 

42 self.brokers: list[BrokerUsecase[Any, Any, Any]] = [] 

43 for br in brokers: 

44 self.add_broker(br) 

45 

46 self.http_handlers: list[tuple[str, HttpHandler]] = [] 

47 

48 def add_broker( 

49 self, 

50 broker: "BrokerUsecase[Any, Any, Any]", 

51 /, 

52 ) -> "SpecificationFactory": 

53 if broker not in self.brokers: 

54 self.brokers.append(broker) 

55 return self 

56 

57 def add_http_route( 

58 self, 

59 path: str, 

60 handler: "HttpHandler", 

61 ) -> "SpecificationFactory": 

62 self.http_handlers.append((path, handler)) 

63 return self 

64 

65 def to_specification(self) -> Specification: 

66 if self.schema_version.startswith("3."): 

67 from .v3_0_0 import get_app_schema as schema_3_0 

68 

69 return schema_3_0( 

70 *self.brokers, 

71 title=self.title, 

72 app_version=self.version, 

73 schema_version=self.schema_version, 

74 description=self.description, 

75 terms_of_service=self.terms_of_service, 

76 contact=self.contact, 

77 license=self.license, 

78 identifier=self.identifier, 

79 tags=self.tags, 

80 external_docs=self.external_docs, 

81 http_handlers=self.http_handlers, 

82 ) 

83 

84 if self.schema_version.startswith("2.6."): 

85 from .v2_6_0 import get_app_schema as schema_2_6 

86 

87 return schema_2_6( 

88 *self.brokers, 

89 title=self.title, 

90 app_version=self.version, 

91 schema_version=self.schema_version, 

92 description=self.description, 

93 terms_of_service=self.terms_of_service, 

94 contact=self.contact, 

95 license=self.license, 

96 identifier=self.identifier, 

97 tags=self.tags, 

98 external_docs=self.external_docs, 

99 http_handlers=self.http_handlers, 

100 ) 

101 

102 msg = f"Unsupported schema version: {self.schema_version}" 

103 raise NotImplementedError(msg)