asyncapi-python 0.1.0__tar.gz → 0.1.2__tar.gz

asyncapi_python-0.1.2/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: asyncapi-python
+Version: 0.1.2
+Summary: Easily generate type-safe and async Python applications from AsyncAPI 3 specifications.
+License: Apache-2.0
+Author: Yaroslav Petrov
+Author-email: yaroslav.v.petrov@gmail.com
+Requires-Python: >=3.9,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: amqp
+Provides-Extra: codegen
+Requires-Dist: aio-pika ; extra == "amqp"
+Requires-Dist: black ; extra == "codegen"
+Requires-Dist: datamodel-code-generator[http] (>=0.26.1,<0.27.0) ; extra == "codegen"
+Requires-Dist: jinja2 (>=3.1.4,<4.0.0) ; extra == "codegen"
+Requires-Dist: pydantic (>=2)
+Requires-Dist: pytz
+Requires-Dist: pyyaml ; extra == "codegen"
+Requires-Dist: typer[all] (>=0.12.5,<0.13.0) ; extra == "codegen"
+Description-Content-Type: text/markdown
+
+# AsyncAPI Python Code Generator
+
+[Link to this github repository](https://github.com/G-USI/asyncapi-python)
+
+Easily generate type-safe and async Python applications from AsyncAPI 3 specifications.
+
+## Features
+
+- [x] Creates `Application` class from [AsyncAPI 3](https://asyncapi.com) specifications, implementing every operation in the file
+- [x] Generates typed Python code (messages are generated using [datamodel-code-generator](https://github.com/koxudaxi/datamodel-code-generator))
+- [x] Performs dynamic validation of messages with [Pydantic 2](https://docs.pydantic.dev/latest/)
+- [x] Enforces the user code to implement all consumer methods as described by spec
+- [x] Provides async code
+- [x] Spec parser references other files through absolute or relative paths
+- [ ] Spec parser references other files through url
+- [x] Supports request-reply pattern
+- [x] Supports publish-subscribe pattern
+- [ ] AsyncAPI trait support
+- [ ] Customizable message encoder/decoder
+
+## Requirements
+
+- `python>=3.10`
+- `pydantic>=2`
+- `pytz`
+- For `codegen` extra
+  - `jinja2`
+  - `typer`
+  - `datamodel-code-generator`
+  - `pyyaml`
+- For `amqp` extra
+  - `aio-pika`
+
+## Installation
+
+For code generation (development env), run:
+
+```bash
+pip install asyncapi-python[codegen]
+```
+
+For runtime, run:
+
+```bash
+pip install asyncapi-python[amqp]
+```
+
+You can replace `amqp` with any other supported protocols. For more info, see [Supported Protocols](#supported-protocols--use-cases) section.
+
+## Supported Protocols / Use Cases
+
+Below, you may see the table of protocols and the supported use cases. The tick signs (✅) contain links to the examples for each implemented protocol-use case pair, while the hammer signs (🔨) contain links to the Issues tracking the progress for protocol-use case pairs. The list of protocols and use cases is expected to increase over the progress of development.
+
+| Use Case   | AMQP                                             |
+| ---------- | ------------------------------------------------ |
+| Pub-Sub    | [✅ amqp-pub-sub](./examples/amqp-pub-sub)            |
+| Work Queue | [✅ amqp-work-queue](./examples/amqp-work-queue) |
+| RPC        | [✅ amqp-rpc](./examples/amqp-rpc)               |
+
+## Documentation
+
+Although there's no documentation available at the moment, a set of comprehensive examples with comments for each implemented use-case is under the [examples](./examples/) directory.
+
+## Contributing
+
+Contributions are welcome! Please feel free to open an Issue or submit a Pull Request.
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+

asyncapi_python-0.1.2/README.md

@@ -0,0 +1,70 @@
+# AsyncAPI Python Code Generator
+
+[Link to this github repository](https://github.com/G-USI/asyncapi-python)
+
+Easily generate type-safe and async Python applications from AsyncAPI 3 specifications.
+
+## Features
+
+- [x] Creates `Application` class from [AsyncAPI 3](https://asyncapi.com) specifications, implementing every operation in the file
+- [x] Generates typed Python code (messages are generated using [datamodel-code-generator](https://github.com/koxudaxi/datamodel-code-generator))
+- [x] Performs dynamic validation of messages with [Pydantic 2](https://docs.pydantic.dev/latest/)
+- [x] Enforces the user code to implement all consumer methods as described by spec
+- [x] Provides async code
+- [x] Spec parser references other files through absolute or relative paths
+- [ ] Spec parser references other files through url
+- [x] Supports request-reply pattern
+- [x] Supports publish-subscribe pattern
+- [ ] AsyncAPI trait support
+- [ ] Customizable message encoder/decoder
+
+## Requirements
+
+- `python>=3.10`
+- `pydantic>=2`
+- `pytz`
+- For `codegen` extra
+  - `jinja2`
+  - `typer`
+  - `datamodel-code-generator`
+  - `pyyaml`
+- For `amqp` extra
+  - `aio-pika`
+
+## Installation
+
+For code generation (development env), run:
+
+```bash
+pip install asyncapi-python[codegen]
+```
+
+For runtime, run:
+
+```bash
+pip install asyncapi-python[amqp]
+```
+
+You can replace `amqp` with any other supported protocols. For more info, see [Supported Protocols](#supported-protocols--use-cases) section.
+
+## Supported Protocols / Use Cases
+
+Below, you may see the table of protocols and the supported use cases. The tick signs (✅) contain links to the examples for each implemented protocol-use case pair, while the hammer signs (🔨) contain links to the Issues tracking the progress for protocol-use case pairs. The list of protocols and use cases is expected to increase over the progress of development.
+
+| Use Case   | AMQP                                             |
+| ---------- | ------------------------------------------------ |
+| Pub-Sub    | [✅ amqp-pub-sub](./examples/amqp-pub-sub)            |
+| Work Queue | [✅ amqp-work-queue](./examples/amqp-work-queue) |
+| RPC        | [✅ amqp-rpc](./examples/amqp-rpc)               |
+
+## Documentation
+
+Although there's no documentation available at the moment, a set of comprehensive examples with comments for each implemented use-case is under the [examples](./examples/) directory.
+
+## Contributing
+
+Contributions are welcome! Please feel free to open an Issue or submit a Pull Request.
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "asyncapi-python"
-version = "0.1.0"
+version = "0.1.2"
 license = "Apache-2.0"
-description = ""
+description = "Easily generate type-safe and async Python applications from AsyncAPI 3 specifications."
 authors = ["Yaroslav Petrov <yaroslav.v.petrov@gmail.com>"]
 readme = "README.md"
 packages = [
@@ -20,11 +20,12 @@ codegen = [
     "asyncapi_python_codegen",
     "pyyaml",
     "datamodel-code-generator",
+    "black",
 ]
 amqp = ["aio-pika"]
 
 [tool.poetry.dependencies]
-python = ">=3.10,<3.13"
+python = ">=3.9,<3.13"
 pydantic = ">=2"
 pytz = "*"
 jinja2 = { version = "^3.1.4", optional = true }
@@ -32,17 +33,19 @@ typer = { extras = ["all"], version = "^0.12.5", optional = true }
 datamodel-code-generator = { extras = [
     "http",
 ], version = "^0.26.1", optional = true }
-aio-pika = { version = "^9.4.3", optional = true }
-pyyaml = { version = "^6.0.2", optional = true }
+aio-pika = { version = "*", optional = true }
+pyyaml = { version = "*", optional = true }
+black = { version = "*", optional = true }
 
 [tool.poetry.group.dev.dependencies]
-black = "^24.10.0"
-mypy = "^1.11.2"
-isort = "^5.13.2"
-types-pyyaml = "^6.0.12.20240917"
-pytest = "^8.3.3"
-types-pytz = "^2024.2.0.20241003"
-pytest-asyncio = "^0.24.0"
+black = "*"
+mypy = "*"
+isort = "*"
+types-pyyaml = "*"
+pytest = "*"
+types-pytz = "*"
+pytest-asyncio = "*"
+pex = "*"
 
 [build-system]
 requires = ["poetry-core"]

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python/amqp/base_application.py

@@ -16,25 +16,24 @@
 from .connection import channel_pool, AmqpPool
 from .consumer import Consumer
 from .producer import Producer
-from abc import ABC, abstractmethod
-from typing import Literal, TypedDict
+from typing import Literal, Optional, TypedDict
 
 
 class Queue(TypedDict):
-    name: str | None
+    name: Optional[str]
     durable: bool
     exclusive: bool
     auto_delete: bool
 
 
 class Exchange(TypedDict):
-    name: str | None
+    name: Optional[str]
     type: Literal["topic", "direct", "fanout", "default", "headers"]
     durable: bool
     auto_delete: bool
 
 
-class BaseApplication(ABC):
+class BaseApplication:
     def __init__(self, amqp_uri: str):
         self._uri = amqp_uri
         self._has_started = False

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python/amqp/consumer.py

@@ -15,19 +15,19 @@
 
 from .message_handler import AbstractMessageHandler, MessageHandler, RpcMessageHandler
 from .message_handler_params import MessageHandlerParams
-from .utils import encode_message, decode_message
+from .utils import encode_message, decode_message, union_model
 
 import asyncio
 from aio_pika import Message
 from aio_pika.pool import Pool
 from aio_pika.abc import AbstractRobustChannel
 from asyncio import Future
-from typing import Callable, TypeVar
-from pydantic import BaseModel
+from typing import Callable, Optional, Sequence, TypeVar, Union
+from pydantic import BaseModel, RootModel
 from logging import getLogger
 
-T = TypeVar("T", bound=BaseModel)
-U = TypeVar("U", bound=BaseModel)
+T = TypeVar("T")
+U = TypeVar("U")
 
 
 class Consumer:
@@ -36,7 +36,7 @@ class Consumer:
         self._logger = getLogger(__name__)
         self._pool = channel_pool
 
-    async def run_blocking(self, timeout: int | float | None):
+    async def run_blocking(self, timeout: Union[int, float, None]):
         await self.run()
         if timeout is not None:
             await asyncio.sleep(timeout)
@@ -56,18 +56,20 @@ class Consumer:
         self,
         *,
         params: MessageHandlerParams,
-        input_type: type[T],
-        output_type: type[U] | None,
+        input_types: Sequence[type[T]],
+        output_types: Union[None, Sequence[type[U]]],
         callback: Callable,
     ):
         handler: AbstractMessageHandler
         if params in self._handlers:
             raise AssertionError(f"Only one handler for `{params}` is allowed")
-        if output_type is None:
+        if output_types is None or len(output_types) == 0:
             handler = MessageHandler(
                 name=params.root.name,
                 callback=callback,
-                decode_message=lambda x: decode_message(x, input_type),
+                decode_message=lambda x: decode_message(
+                    x, union_model(input_types)
+                ).root,
             )
         else:
             handler = RpcMessageHandler(
@@ -75,6 +77,8 @@ class Consumer:
                 callback=callback,
                 reply_callback=self._reply_callback,
                 encode_message=encode_message,
-                decode_message=lambda x: decode_message(x, input_type),
+                decode_message=lambda x: decode_message(
+                    x, union_model(input_types)
+                ).root,
             )
         self._handlers[params] = handler

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python/amqp/message_handler.py

@@ -15,13 +15,13 @@
 
 from abc import ABC, abstractmethod
 from aio_pika.message import AbstractIncomingMessage, Message
-from typing import Awaitable, Callable, Generic, TypeVar
+from typing import Awaitable, Callable, Generic, TypeVar, Union
 from pydantic import BaseModel
 from logging import getLogger
 
 
 T = TypeVar("T", bound=BaseModel)
-U = TypeVar("U", bound=BaseModel | None)
+U = TypeVar("U", bound=Union[BaseModel, None])
 V = TypeVar("V", bound=BaseModel)
 
 

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python/amqp/message_handler_params.py

@@ -14,7 +14,7 @@
 
 
 from pydantic import RootModel, BaseModel, ConfigDict, computed_field
-from typing import Literal
+from typing import Literal, Optional, Union
 from aio_pika.abc import AbstractRobustChannel
 from .message_handler import AbstractMessageHandler
 
@@ -24,7 +24,7 @@ class ExchangeHandlerParams(BaseModel):
     kind: Literal["exchange"] = "exchange"
     type: Literal["direct", "fanout", "topic", "headers"]
     name: str
-    routing_key: str | None
+    routing_key: Optional[str]
     auto_delete: bool = False
 
 
@@ -39,24 +39,28 @@ class QueueHandlerParams(BaseModel):
 
 class MessageHandlerParams(RootModel):
     model_config = ConfigDict(frozen=True)
-    root: QueueHandlerParams | ExchangeHandlerParams
+    root: Union[QueueHandlerParams, ExchangeHandlerParams]
 
     async def setup_consume(
         self,
         handler: AbstractMessageHandler,
         channel: AbstractRobustChannel,
     ):
-        match self.root:
-            case ExchangeHandlerParams(
-                name=name, routing_key=rk, type=et, auto_delete=ad
-            ):
-                exchange = await channel.declare_exchange(name, type=et, auto_delete=ad)
-                queue = await channel.declare_queue(exclusive=True)
-                await queue.bind(exchange, rk)
-            case QueueHandlerParams(name=name, exclusive=ex, auto_delete=ad, durable=d):
-                queue = await channel.declare_queue(
-                    name, exclusive=ex, auto_delete=ad, durable=d
-                )
-            case _:
-                raise NotImplementedError
+        if isinstance(self.root, ExchangeHandlerParams):
+            exchange = await channel.declare_exchange(
+                name=self.root.name,
+                type=self.root.type,
+                auto_delete=self.root.auto_delete,
+            )
+            queue = await channel.declare_queue(exclusive=True)
+            await queue.bind(exchange, self.root.routing_key)
+        elif isinstance(self.root, QueueHandlerParams):
+            queue = await channel.declare_queue(
+                self.root.name,
+                exclusive=self.root.exclusive,
+                auto_delete=self.root.auto_delete,
+                durable=self.root.durable,
+            )
+        else:
+            raise NotImplementedError
         await queue.consume(handler)

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python/amqp/producer.py

@@ -21,14 +21,15 @@ from aio_pika.abc import (
     AbstractIncomingMessage,
 )
 from logging import getLogger
-from pydantic import BaseModel
-from typing import TypeVar
+from pydantic import BaseModel, RootModel, create_model
+from typing import Optional, Sequence, TypeVar, Union, Type
+from collections.abc import Sequence as Seq
 from asyncio import Future
 from uuid import uuid4
-from .utils import encode_message, decode_message
+from .utils import encode_message, decode_message, union_model
 
-T = TypeVar("T", bound=BaseModel)
-U = TypeVar("U", bound=BaseModel)
+T = TypeVar("T")
+U = TypeVar("U")
 
 
 class Producer:
@@ -44,7 +45,7 @@ class Producer:
         self._pool = channel_pool
         self._replies: dict[str, Future[AbstractIncomingMessage]] = {}
         self._reply_queue = reply_queue
-        self._reply_consumer_tag: str | None = None
+        self._reply_consumer_tag: Optional[str] = None
 
     async def _on_reply(self, msg: AbstractIncomingMessage):
         await msg.ack()
@@ -59,12 +60,10 @@ class Producer:
     async def publish(
         self,
         message: T,
-        exchange: str | None,
-        routing_key: str | None,
+        exchange: Optional[str],
+        routing_key: Optional[str],
     ):
-        outbound_message = Message(
-            body=encode_message(message),
-        )
+        outbound_message = Message(body=encode_message(RootModel[T](message)))
         async with self._pool.acquire() as channel:
             await (
                 await channel.get_exchange(exchange)
@@ -75,9 +74,9 @@ class Producer:
     async def request(
         self,
         message: T,
-        exchange: str | None,
-        routing_key: str | None,
-        output_type: type[U],
+        exchange: Optional[str],
+        routing_key: Optional[str],
+        output_types: Sequence[type[U]],
     ) -> U:
         if not self._reply_consumer_tag:
             raise AssertionError(
@@ -85,7 +84,7 @@ class Producer:
             )
         corr_id = str(uuid4())
         outbound_message = Message(
-            body=encode_message(message),
+            body=encode_message(RootModel[T](message)),
             correlation_id=corr_id,
             reply_to=self._reply_queue.name,
         )
@@ -98,6 +97,9 @@ class Producer:
             ).publish(outbound_message, routing_key or "")
             self._logger.info(f"Sent request {message}")
             self._replies[corr_id] = reply_future
-        res = decode_message((await reply_future).body, output_type)
+        res = decode_message(
+            (await reply_future).body,
+            union_model(tuple(output_types)),
+        ).root
         self._logger.info(f"Got response {res}")
         return res

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python/amqp/utils.py

@@ -13,10 +13,12 @@
 # limitations under the License.
 
 
-from pydantic import BaseModel
-from typing import TypeVar
+from functools import cache
+from pydantic import BaseModel, RootModel, create_model
+from typing import TypeVar, Union
 
 T = TypeVar("T", bound=BaseModel)
+U = TypeVar("U")
 
 
 def encode_message(message: T) -> bytes:
@@ -25,3 +27,9 @@ def encode_message(message: T) -> bytes:
 
 def decode_message(message: bytes, schema: type[T]) -> T:
     return schema.model_validate_json(message)
+
+
+@cache
+def union_model(types: tuple[type[U], ...]) -> type[RootModel[U]]:
+    UnionType = Union.__getitem__(types)
+    return RootModel[UnionType]  # type: ignore

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/__init__.py

@@ -36,13 +36,12 @@ def generate(
 
     # Generate code
     generation_result: dict[Path, str]
-    match protocol:
-        case "amqp":
-            generation_result = g.amqp.generate(
-                input_path=input_file, output_path=output_dir
-            )
-        case _:
-            raise NotImplementedError(f"Protocol {protocol} is not supported")
+    if protocol == "amqp":
+        generation_result = g.amqp.generate(
+            input_path=input_file, output_path=output_dir
+        )
+    else:
+        raise NotImplementedError(f"Protocol {protocol} is not supported")
 
     # Write files
     for path, code in generation_result.items():

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/document/bindings/amqp.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 
 
-from typing import Literal
+from typing import Literal, Optional, Union
 
 from pydantic import BaseModel, Field, RootModel
 
 
 class Exchange(BaseModel):
-    name: str | None = None
+    name: Optional[str] = None
     type: Literal["topic", "direct", "fanout", "default", "headers"] = "default"
     durable: bool = False
     auto_delete: bool = Field(alias="autoDelete", default=False)
@@ -31,7 +31,7 @@ class ExchangeBinding(BaseModel):
 
 
 class Queue(BaseModel):
-    name: str | None = None
+    name: Optional[str] = None
     durable: bool = False
     exclusive: bool = False
     auto_delete: bool = Field(alias="autoDelete", default=False)
@@ -43,4 +43,4 @@ class QueueBinding(BaseModel):
 
 
 class AmqpBinding(RootModel):
-    root: ExchangeBinding | QueueBinding = QueueBinding()
+    root: Union[ExchangeBinding, QueueBinding] = QueueBinding()

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/document/components.py

@@ -15,10 +15,8 @@
 
 from __future__ import annotations
 
-from pydantic import model_validator
-
-from .base import BaseModel
-from typing import Any, Literal
+from .base import BaseModel, RootModel
+from typing import Any, Literal, Optional
 from .ref import MaybeRef, Ref
 from .bindings import Bindings
 
@@ -28,56 +26,44 @@ class Components(BaseModel):
     channels: dict[str, MaybeRef[Channel]] = {}
     messages: dict[str, MaybeRef[Message]] = {}
     correlation_ids: dict[str, CorrelationId] = {}
+    schemas: dict[str, MaybeRef[JsonSchema]] = {}
 
 
-class JsonSchema(BaseModel):
+class JsonSchema(RootModel):
     # TODO: Create a better parser for JsonSchema
-    type: str
-    properties: dict[str, Any]
-    required: list[str] = []
+    root: Any
 
 
 class Message(BaseModel):
-    title: str
-    headers: MaybeRef[JsonSchema] | None = None
+    title: Optional[str] = None
+    headers: Optional[MaybeRef[JsonSchema]] = None
     payload: MaybeRef[JsonSchema]
 
-    @model_validator(mode="before")
-    @classmethod
-    def has_title(cls, data: dict[str, Any]):
-        if not "title" in data:
-            raise AssertionError(
-                "As of now, all Message objects require "
-                + "`title` field to be present to uniquely identify data types. "
-                + "This limitation will be removed in the future."
-            )
-        return data
-
 
 class CorrelationId(BaseModel):
-    description: str | None = None
+    description: Optional[str] = None
     location: str
 
 
 class Operation(BaseModel):
     action: Literal["receive", "send"]
     channel: Ref[Channel]
-    reply: OperationReply | None = None
+    reply: Optional[OperationReply] = None
 
 
 class OperationReply(BaseModel):
-    address: ReplyAddress | None = None
+    address: Optional[ReplyAddress] = None
     channel: Ref[Channel]
 
 
 class ReplyAddress(BaseModel):
-    description: str | None = None
+    description: Optional[str] = None
     location: str
 
 
 class Channel(BaseModel):
-    address: str | None = None
-    title: str | None = None
-    description: str | None = None
-    bindings: Bindings | None = None
+    address: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    bindings: Optional[Bindings] = None
     messages: dict[str, MaybeRef[Message]]

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/document/document.py

@@ -18,7 +18,7 @@ from pathlib import Path
 
 from pydantic import Field
 from .base import BaseModel
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, Literal, Optional
 import yaml
 from .components import Channel, Components, Message, Operation
 from .ref import MaybeRef, Ref
@@ -53,4 +53,4 @@ class Document(BaseModel):
 class Info(BaseModel):
     title: str
     version: str
-    description: str | None = None
+    description: Optional[str] = None

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/document/ref.py

@@ -23,7 +23,8 @@ from .document_context import (
     set_current_doc_path,
     DOCUMENT_CONTEXT_STACK,
 )
-from typing import Any, Callable, Generic, TypeVar, Annotated
+from typing import Any, Callable, Generic, TypeVar, Annotated, Union
+from typing_extensions import Self
 
 
 T = TypeVar("T", bound=BaseModel)
@@ -54,32 +55,49 @@ class Ref(BaseModel, Generic[T]):
     def get(self) -> T:
         from .document import Document
 
-        doc = Document.load_yaml(self.filepath).model_dump(by_alias=True)
+        sub = self.flatten()
+        doc = Document.load_yaml(sub.filepath).model_dump(by_alias=True)
         for p in self.doc_path:
             doc = doc[p]
+        with set_current_doc_path(sub.filepath):
+            return sub.type().model_validate(doc)
 
-        with set_current_doc_path(self.filepath):
-            if "$ref" in doc:
-                return self.__class__.model_validate(doc).get()
-            return self.type().model_validate(doc)
+    @cache
+    def flatten(self, max_depth: int = 1000) -> Self:
+        from .document import Document
+
+        sub = self
+        for _ in range(max_depth):
+            doc = Document.load_yaml(sub.filepath).model_dump(by_alias=True)
+            try:
+                for p in sub.doc_path:
+                    doc = doc[p]
+            except KeyError as e:
+                raise KeyError(
+                    f"$ref `{sub.ref}` is invalid \n"
+                    + f"The Error was raised when trying to get key {e.args}"
+                )
+            if not "$ref" in doc:
+                return sub
+            sub = self.__class__.model_validate(doc)
+        raise RecursionError(
+            f"Document Ref[{self.type().__class__}] flattening limit reached"
+        )
 
     @model_validator(mode="before")
     @classmethod
     def parse_ref(cls, data: Any) -> Any:
-        fp: str | Path
-
-        match data:
-            case {"ref": ref} | {"$ref": ref} if isinstance(ref, str):
-                match ref.split("#"):
-                    case "", dp:
-                        fp = current_doc_path()
-                    case fp, dp if not Path(fp).is_absolute():
-                        fp = current_doc_path().parent / fp
-                    case fp, dp:
-                        ...
-
-            case x:
-                raise ValueError(f"Requires {{$ref: ... }}, given {x} ")
+        fp: Union[str, Path]
+
+        if (ref := data.get("ref")) or (ref := data.get("$ref")):
+            fp, dp = ref.split("#")
+            if fp == "":
+                fp = current_doc_path()
+            elif not Path(fp).is_absolute():
+                fp = current_doc_path().parent / fp
+        else:
+            raise ValueError(f"Requires {{$ref: ... }}, given {data} ")
+
         return {
             **data,
             "$ref": ref,
@@ -88,8 +106,8 @@ class Ref(BaseModel, Generic[T]):
         }
 
 
-class MaybeRef(RootModel[Ref[T] | T], Generic[T]):
-    root: Ref[T] | T
+class MaybeRef(RootModel[Union[Ref[T], T]], Generic[T]):
+    root: Union[Ref[T], T]
 
     def get(self) -> T:
         return self.root.get() if isinstance(self.root, Ref) else self.root

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/generators/amqp/generate.py

@@ -17,11 +17,12 @@ from __future__ import annotations
 from contextlib import ExitStack
 import json
 from pathlib import Path
-import subprocess
+import tempfile
 import jinja2 as j2
-from typing import Any, Literal, TypedDict
+from typing import Literal, Optional, TypedDict
 from asyncapi_python_codegen import document as d
 from itertools import chain
+from datamodel_code_generator.__main__ import main as datamodel_codegen
 
 from .utils import snake_case
 
@@ -46,13 +47,13 @@ def generate(
             doc.info.description,
             doc.info.version,
         ).items()
-    } | {output_path / "models.py": generate_models(ops)}
+    } | {output_path / "models.py": generate_models(ops, doc.filepath.parent)}
 
 
 def generate_application(
     ops: list[Operation],
     title: str,
-    description: str | None,
+    description: Optional[str],
     version: str,
     template_dir: Path = Path(__file__).parent / "templates",
     filenames: list[str] = ["__init__.py", "application.py"],
@@ -65,16 +66,11 @@ def generate_application(
         return {f: t.render(**render_args) for t, f in zip(templates, filenames)}
 
 
-def generate_models(schemas: list[Operation]) -> str:
-    args = """datamodel-codegen
-    --output-model-type pydantic_v2.BaseModel
-    --input-file-type jsonschema
-    """.split()
-
+def generate_models(schemas: list[Operation], cwd: Path) -> str:
     inp = {
         "$schema": "http://json-schema.org/draft-07/schema#",
         "$defs": {
-            type_name: type_schema
+            type_name: {"$ref": type_schema}
             for s in schemas
             for type_name, type_schema in chain(
                 zip(s["input_types"], s["input_schemas"]),
@@ -82,31 +78,49 @@ def generate_models(schemas: list[Operation]) -> str:
             )
         },
     }
-    return subprocess.run(
-        args=args, capture_output=True, check=True, input=json.dumps(inp).encode()
-    ).stdout.decode()
+
+    with tempfile.TemporaryDirectory() as dir:
+        schema_path = Path(dir) / "schema.json"
+        models_path = Path(dir) / "models.py"
+
+        args = f"""
+        --input { str(schema_path.absolute()) }
+        --output { str(models_path.absolute()) }
+        --output-model-type pydantic_v2.BaseModel
+        --input-file-type jsonschema
+        """.split()
+
+        with schema_path.open("w") as schema:
+            json.dump(inp, schema)
+
+        datamodel_codegen(args=args)
+
+        with models_path.open() as f:
+            models_code = f.read()
+
+    return models_code
 
 
 def get_operation(op_name: str, op: d.Operation) -> Operation:
-    exchange: str | None
-    routing_key: str | None
+    exchange: Optional[str]
+    routing_key: Optional[str]
 
     channel = op.channel.get()
     reply_channel = op.reply.channel.get() if op.reply else None
     addr = lambda x: x or channel.address or op_name
-    match channel.bindings:
-        case None:
-            # Default exchange + named queues
-            exchange = None
-            routing_key = addr(None)
-        case bind if bind.amqp.root.type == "queue":
-            # Default exchange + named queues
-            exchange = None
-            routing_key = addr(bind.amqp.root.queue.name)
-        case bind if bind.amqp.root.type == "routingKey":
-            # Named exchange + exclusive queues
-            exchange = addr(bind.amqp.root.exchange.name)
-            routing_key = None
+
+    if channel.bindings is None:
+        # Default exchange + named queues
+        exchange = None
+        routing_key = addr(None)
+    elif (bind := channel.bindings).amqp.root.type == "queue":
+        # Default exchange + named queues
+        exchange = None
+        routing_key = addr(bind.amqp.root.queue.name)
+    elif bind.amqp.root.type == "routingKey":
+        # Named exchange + exclusive queues
+        exchange = addr(bind.amqp.root.exchange.name)
+        routing_key = None
 
     # Get reply channel properties
     if reply_channel is not None:
@@ -124,31 +138,69 @@ def get_operation(op_name: str, op: d.Operation) -> Operation:
                     "As of now, reply channel must be a queue without name"
                 )
 
+    input_types: list[str]
+    input_schemas: list[str]
+    output_types: list[str]
+    output_schemas: list[str]
+
+    input_types, input_schemas = get_channel_types(
+        channel, op.channel.filepath, op.channel.doc_path
+    )
+    output_types, output_schemas = (
+        get_channel_types(
+            op.reply.channel.get(),
+            op.reply.channel.filepath,
+            op.reply.channel.doc_path,
+        )
+        if op.reply
+        else ([], [])
+    )
+
     return {
         "field_name": snake_case(op_name),
         "action": op.action,
         "exchange": exchange,
         "routing_key": routing_key,
-        "input_types": [msg.get().title for msg in channel.messages.values()],
-        "input_schemas": [
-            msg.get().payload.get().model_dump() for msg in channel.messages.values()
-        ],
-        "output_types": (
-            [msg.get().title for msg in reply_channel.messages.values()]
-            if reply_channel
-            else []
-        ),
-        "output_schemas": (
-            [
-                msg.get().payload.get().model_dump()
-                for msg in reply_channel.messages.values()
-            ]
-            if reply_channel
-            else []
-        ),
+        "input_types": input_types,
+        "input_schemas": input_schemas,
+        "output_types": output_types,
+        "output_schemas": output_schemas,
     }
 
 
+def get_channel_types(
+    channel: d.Channel,
+    channel_filepath: Path,
+    channel_doc_path: tuple[str, ...],
+) -> tuple[list[str], list[str]]:
+    types, schemas = [], []
+    for message_key, message in channel.messages.items():
+
+        if isinstance(message.root, d.Ref):
+            msg_ref = message.root.flatten()
+            msg_filepath = msg_ref.filepath
+            msg_doc_path = msg_ref.doc_path
+            del msg_ref
+        else:
+            msg_filepath = channel_filepath
+            msg_doc_path = (*channel_doc_path, "messages", message_key)
+
+        message_payload = message.get().payload.root
+        if isinstance(message_payload, d.Ref):
+            payload_ref = message_payload.flatten()
+            pl_filepath = payload_ref.filepath
+            pl_doc_path = payload_ref.doc_path
+            del payload_ref
+        else:
+            pl_filepath = msg_filepath
+            pl_doc_path = (*msg_doc_path, "payload")
+
+        types.append(message.get().title or message_key)
+        schemas.append(str(pl_filepath) + "#/" + "/".join(pl_doc_path))
+
+    return types, schemas
+
+
 class Operation(TypedDict):
     field_name: str
     action: Literal["send", "receive"]
@@ -156,5 +208,5 @@ class Operation(TypedDict):
     routing_key: str | None
     input_types: list[str]
     output_types: list[str]
-    input_schemas: list[Any]
-    output_schemas: list[Any]
+    input_schemas: list[str]
+    output_schemas: list[str]

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/generators/amqp/templates/application.py.j2

@@ -14,7 +14,8 @@
 from .models import *
 from asyncapi_python.amqp import BaseApplication, Consumer
 from asyncapi_python.amqp.message_handler_params import MessageHandlerParams
-from typing import Callable, Awaitable
+from typing import Callable, Awaitable, Union
+from pydantic import RootModel
 
 
 class Application(BaseApplication):
@@ -34,8 +35,8 @@ class Application(BaseApplication):
         await super().start(blocking=blocking)
     
     {% for op in ops if op.action == "send" -%}
-    {%- set in_type = op.input_types | join(" | ") -%}
-    {%- set out_type = op.output_types | join(" | ") if op.output_types else "None" -%}
+    {%- set in_type = "Union[" + (op.input_types | join(" | ")) + "]" -%}
+    {%- set out_type = "Union[" + (op.output_types | join(" | ") if op.output_types else "None") + "]" -%}
     {%- set callback_type = "Callable[["+ in_type + "], Awaitable[" + out_type + "]" + "]" -%}
     {%- set send_method = "publish" if out_type == "None" else "request" -%}
     {%- set routing_key_literal = '"' + op.routing_key + '"' if op.routing_key else "None" -%}
@@ -46,7 +47,7 @@ class Application(BaseApplication):
             exchange={{ '"' + op.exchange + '"' if op.exchange else "None" }},
             routing_key={{ routing_key_literal }},
             {%- if send_method == "request" %}
-            output_type={{ out_type }},
+            output_types={{ "[" + op.output_types | join(", ") + "]" }},
             {%- endif %}
         )
     {% endfor %}
@@ -72,8 +73,8 @@ class ConsumerWrapper:
 
     
     {% for op in ops if op.action == "receive" %}
-    {%- set in_type = op.input_types | join(" | ") -%}
-    {%- set out_type = op.output_types | join(" | ") if op.output_types else "None" -%}
+    {%- set in_type = "Union[" + (op.input_types | join(", ")) + "]" -%}
+    {%- set out_type = "Union[" + (op.output_types | join(", ") if op.output_types else "None") + "]" -%}
     {%- set callback_type = "Callable[["+ in_type + "], Awaitable[" + out_type + "]" + "]" -%}
     {%- set routing_key_literal = '"' + op.routing_key + '"' if op.routing_key else "None" -%}
     def {{ op.field_name }}(self, callback: {{ callback_type }}) -> None:
@@ -93,8 +94,8 @@ class ConsumerWrapper:
                 {"kind": "queue", "name": "{{op.routing_key}}"}
                 {%- endif %}
             ),
-            input_type={{in_type}},
-            output_type={{out_type}},
+            input_types={{ "[" + op.input_types | join(", ") + "]" }},
+            output_types={{ "[" + op.output_types | join(", ") + "]" }},
             callback=callback,
         )
     {% endfor %}

{asyncapi_python-0.1.0 → asyncapi_python-0.1.2}/src/asyncapi_python_codegen/generators/amqp/utils.py

@@ -31,12 +31,13 @@ def snake_case(s: str) -> str:
     ).lower()
 
 
-def camel_case(kind: Literal["upper", "lower"], string: str):
+def camel_case(kind: Literal["upper", "lower"], string: str) -> str:
+    if not string:
+        return ""
+
     string = sub(r"(_|-)+", " ", string).title().replace(" ", "")
-    match string, kind:
-        case "", _:
-            return ""
-        case _, "lower":
-            return string[0].lower() + string[1:]
-        case _, "upper":
-            return string[0].upper() + string[1:]
+
+    if kind == "lower":
+        return string[0].lower() + string[1:]
+    elif kind == "upper":
+        return string[0].upper() + string[1:]

asyncapi_python-0.1.0/PKG-INFO

@@ -1,38 +0,0 @@
-Metadata-Version: 2.1
-Name: asyncapi-python
-Version: 0.1.0
-Summary: 
-License: Apache-2.0
-Author: Yaroslav Petrov
-Author-email: yaroslav.v.petrov@gmail.com
-Requires-Python: >=3.10,<3.13
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: amqp
-Provides-Extra: codegen
-Requires-Dist: aio-pika (>=9.4.3,<10.0.0) ; extra == "amqp"
-Requires-Dist: datamodel-code-generator[http] (>=0.26.1,<0.27.0) ; extra == "codegen"
-Requires-Dist: jinja2 (>=3.1.4,<4.0.0) ; extra == "codegen"
-Requires-Dist: pydantic (>=2)
-Requires-Dist: pytz
-Requires-Dist: pyyaml (>=6.0.2,<7.0.0) ; extra == "codegen"
-Requires-Dist: typer[all] (>=0.12.5,<0.13.0) ; extra == "codegen"
-Description-Content-Type: text/markdown
-
-# AsyncAPI Python Code Generator
-
-> This README is a work in progress
-
-A command line interface to generate Python code from AsyncAPI specifications. This tool helps you automatically create Python implementations of AsyncAPI services, reducing boilerplate code and ensuring consistency with your API specifications.
-
-## Features
-
-- Generates Python code from AsyncAPI specifications
-- Creates both consumer and producer implementations
-- Supports AMQP protocol
-- Includes connection pooling and management
-- Provides base application structure
-

asyncapi_python-0.1.0/README.md

@@ -1,13 +0,0 @@
-# AsyncAPI Python Code Generator
-
-> This README is a work in progress
-
-A command line interface to generate Python code from AsyncAPI specifications. This tool helps you automatically create Python implementations of AsyncAPI services, reducing boilerplate code and ensuring consistency with your API specifications.
-
-## Features
-
-- Generates Python code from AsyncAPI specifications
-- Creates both consumer and producer implementations
-- Supports AMQP protocol
-- Includes connection pooling and management
-- Provides base application structure