weenspace-queue 0.1.0__tar.gz → 0.1.2__tar.gz

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weenspace-queue
-Version: 0.1.0
+Version: 0.1.2
 Summary: WeenSpace queue client for RabbitMQ and AWS SQS, supporting both synchronous and asynchronous operations.
 License: MIT
 License-File: LICENSE
@@ -13,11 +13,15 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Networking
-Requires-Dist: packaging (>=25.0,<26.0)
+Provides-Extra: aws
+Requires-Dist: boto3 (>=1.43.100,<2.0.0) ; extra == "aws"
+Requires-Dist: packaging (>=26.3,<27.0)
 Requires-Dist: python-qpid-proton (>=0.40.0,<0.41.0)
-Requires-Dist: typing-extensions (>=4.15.0,<5.0.0)
+Requires-Dist: rabbitmq-amqp-python-client (>=1.0.1,<2.0.0)
+Requires-Dist: typing-extensions (>=4.16.0,<5.0.0)
 Project-URL: Homepage, https://github.com/weenspace/weenspace-queue
 Project-URL: Repository, https://github.com/weenspace/weenspace-queue
 Description-Content-Type: text/markdown
@@ -49,86 +53,59 @@ pip install weenspace-queue
 
 ## 🚀 Quick Start
 
-### Basic Publisher/Consumer
+### Unified Publisher/Consumer
 
 ```python
-from weenspace_queue import (
-    Environment,
-    Connection,
-    Publisher,
-    Consumer,
-    Message,
-    ClassicQueueSpecification,
-    ExchangeSpecification,
-)
-
-# Create environment and connection
-environment = Environment(uri="amqp://guest:guest@localhost:5672/")
-connection = environment.connection()
-
-# Declare queue with dead letter support
-management = connection.management()
-queue_spec = ClassicQueueSpecification(
-    name="my-queue",
-    is_durable=True,
-    dead_letter_exchange="dlx",
-    dead_letter_routing_key="dlx-key",
-    max_priority=10,  # Enable priority
-)
-management.declare_queue(queue_spec)
+from weenspace_queue import Message, QueueClient, QueueSpecification
 
-# Publish message
-publisher = connection.publisher("/queues/my-queue")
-publisher.publish(Message(body=b"Hello WeenSpace!"))
+client = QueueClient("rabbitmq", uri="amqp://guest:guest@localhost:5672/")
+queue = client.declare_queue(QueueSpecification(name="my-queue"))
+client.publish(queue, Message(body=b"Hello WeenSpace!"))
 
-# Consume messages
-def on_message(message):
+def on_message(message: Message) -> None:
     print(f"Received: {message.body}")
     message.accept()
 
-consumer = connection.consumer("/queues/my-queue", handler=on_message)
+client.consume(queue, handler=on_message, prefetch=10)
 ```
 
+Install AWS support with `pip install "weenspace-queue[aws]"`.
+
 ### Async Support
 
 ```python
 import asyncio
-from weenspace_queue.asyncio import AsyncEnvironment
+from weenspace_queue import AsyncQueueClient, Message, QueueSpecification
 
 async def main():
-    async with AsyncEnvironment(uri="amqp://localhost:5672/") as env:
-        async with env.connection() as conn:
-            publisher = await conn.publisher("/queues/my-queue")
-            await publisher.publish(Message(body=b"Async message!"))
+    async with AsyncQueueClient("rabbitmq", uri="amqp://localhost:5672/") as client:
+        queue = await client.declare_queue(QueueSpecification(name="my-queue"))
+        await client.publish(queue, Message(body=b"Async message!"))
 
 asyncio.run(main())
 ```
 
-### OAuth2 Authentication
+### RabbitMQ authentication
 
 ```python
-from weenspace_queue import Environment, OAuth2Options
+from weenspace_queue import QueueClient
 
-oauth = OAuth2Options(token="your_jwt_token")
-environment = Environment(
+client = QueueClient(
+    "rabbitmq",
     uri="amqp://localhost:5672/",
-    oauth2_options=oauth
+    oauth2_options=your_oauth_options
 )
 ```
 
 ### TLS/SSL Connection
 
 ```python
-from weenspace_queue import Environment, SslConfiguration
+from weenspace_queue import QueueClient
 
-ssl_config = SslConfiguration(
-    ca_cert="/path/to/ca.pem",
-    client_cert="/path/to/client.pem",
-    client_key="/path/to/client.key"
-)
-environment = Environment(
+client = QueueClient(
+    "rabbitmq",
     uri="amqps://localhost:5671/",
-    ssl_configuration=ssl_config
+    ssl_context=your_ssl_context
 )
 ```
 
@@ -143,7 +120,7 @@ See [examples](./examples) folder for more detailed usage examples.
 # from python_rabbitmq import RabbitMQ
 
 # New (weenspace-queue)
-from weenspace_queue import Environment, Connection
+from weenspace_queue import QueueClient
 ```
 
 ## 📋 Requirements

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/README.md

@@ -25,86 +25,59 @@ pip install weenspace-queue
 
 ## 🚀 Quick Start
 
-### Basic Publisher/Consumer
+### Unified Publisher/Consumer
 
 ```python
-from weenspace_queue import (
-    Environment,
-    Connection,
-    Publisher,
-    Consumer,
-    Message,
-    ClassicQueueSpecification,
-    ExchangeSpecification,
-)
-
-# Create environment and connection
-environment = Environment(uri="amqp://guest:guest@localhost:5672/")
-connection = environment.connection()
-
-# Declare queue with dead letter support
-management = connection.management()
-queue_spec = ClassicQueueSpecification(
-    name="my-queue",
-    is_durable=True,
-    dead_letter_exchange="dlx",
-    dead_letter_routing_key="dlx-key",
-    max_priority=10,  # Enable priority
-)
-management.declare_queue(queue_spec)
+from weenspace_queue import Message, QueueClient, QueueSpecification
 
-# Publish message
-publisher = connection.publisher("/queues/my-queue")
-publisher.publish(Message(body=b"Hello WeenSpace!"))
+client = QueueClient("rabbitmq", uri="amqp://guest:guest@localhost:5672/")
+queue = client.declare_queue(QueueSpecification(name="my-queue"))
+client.publish(queue, Message(body=b"Hello WeenSpace!"))
 
-# Consume messages
-def on_message(message):
+def on_message(message: Message) -> None:
     print(f"Received: {message.body}")
     message.accept()
 
-consumer = connection.consumer("/queues/my-queue", handler=on_message)
+client.consume(queue, handler=on_message, prefetch=10)
 ```
 
+Install AWS support with `pip install "weenspace-queue[aws]"`.
+
 ### Async Support
 
 ```python
 import asyncio
-from weenspace_queue.asyncio import AsyncEnvironment
+from weenspace_queue import AsyncQueueClient, Message, QueueSpecification
 
 async def main():
-    async with AsyncEnvironment(uri="amqp://localhost:5672/") as env:
-        async with env.connection() as conn:
-            publisher = await conn.publisher("/queues/my-queue")
-            await publisher.publish(Message(body=b"Async message!"))
+    async with AsyncQueueClient("rabbitmq", uri="amqp://localhost:5672/") as client:
+        queue = await client.declare_queue(QueueSpecification(name="my-queue"))
+        await client.publish(queue, Message(body=b"Async message!"))
 
 asyncio.run(main())
 ```
 
-### OAuth2 Authentication
+### RabbitMQ authentication
 
 ```python
-from weenspace_queue import Environment, OAuth2Options
+from weenspace_queue import QueueClient
 
-oauth = OAuth2Options(token="your_jwt_token")
-environment = Environment(
+client = QueueClient(
+    "rabbitmq",
     uri="amqp://localhost:5672/",
-    oauth2_options=oauth
+    oauth2_options=your_oauth_options
 )
 ```
 
 ### TLS/SSL Connection
 
 ```python
-from weenspace_queue import Environment, SslConfiguration
+from weenspace_queue import QueueClient
 
-ssl_config = SslConfiguration(
-    ca_cert="/path/to/ca.pem",
-    client_cert="/path/to/client.pem",
-    client_key="/path/to/client.key"
-)
-environment = Environment(
+client = QueueClient(
+    "rabbitmq",
     uri="amqps://localhost:5671/",
-    ssl_configuration=ssl_config
+    ssl_context=your_ssl_context
 )
 ```
 
@@ -119,7 +92,7 @@ See [examples](./examples) folder for more detailed usage examples.
 # from python_rabbitmq import RabbitMQ
 
 # New (weenspace-queue)
-from weenspace_queue import Environment, Connection
+from weenspace_queue import QueueClient
 ```
 
 ## 📋 Requirements

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "weenspace-queue"
-version = "0.1.0"
+version = "0.1.2"
 description = "WeenSpace queue client for RabbitMQ and AWS SQS, supporting both synchronous and asynchronous operations."
 authors = ["WeenSpace <weenspace@gmail.com>"]
 license = "MIT"
@@ -22,29 +22,30 @@ packages = [{include = "weenspace_queue"}]
 [tool.poetry.dependencies]
 python = "^3.14"
 python-qpid-proton = "^0.40.0"
-typing-extensions = "^4.15.0"
-packaging = "^25.0"
+rabbitmq-amqp-python-client = "^1.0.1"
+boto3 = { version = "^1.43.100", optional = true }
+typing-extensions = "^4.16.0"
+packaging = "^26.3"
+
+[tool.poetry.extras]
+aws = ["boto3"]
 
 [tool.poetry.group.dev.dependencies]
-pyjwt = "^2.13.0"
+boto3 = "^1.43.100"
+pyjwt = "^2.14.0"
 pika = "^1.4.4"
-flake8 = "^7.3.0"
-isort = "^6.0.0"
-mypy = "^1.19.0"
-pytest = "^9.0.0"
+flake8 = "^7.4.1"
+isort = "^9.0.1"
+mypy = "^2.3.1"
+pytest = "^9.1.1"
 black = "^26.5.1"
-requests = "^2.32.0"
-pytest-asyncio = "^1.3.0"
+requests = "^2.34.2"
+pytest-asyncio = "^1.4.0"
 
 [build-system]
-requires = ["poetry-core"]
+requires = ["poetry-core>=2.5.0"]
 build-backend = "poetry.core.masonry.api"
 
-[dependency-groups]
-dev = [
-    "boto3>=1.43.80",
-]
-
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/__init__.py

@@ -1,7 +1,4 @@
-from typing import Any, Callable, Dict, Type
-
-from .asyncio.aws_async import AwsAsyncEngine
-from .asyncio.rabbitmq_async import RabbitMqAsyncEngine
+from typing import Any, Callable, Type
 from .base import (
     AsyncQueueEngine,
     Message,
@@ -16,26 +13,54 @@ from .constants import (
     Provider,
     QueueKind,
 )
-from .providers.aws import AwsEngine
-from .providers.rabbitmq import RabbitMqEngine
+
+
+def __getattr__(name: str) -> Any:
+    """Lazily expose the low-level RabbitMQ compatibility API."""
+    try:
+        from rabbitmq_amqp_python_client import __dict__ as rabbitmq_namespace
+
+        value = rabbitmq_namespace.get(name)
+        if value is None and name == "DirectReplyToConsumerOptions":
+            value = rabbitmq_namespace["ConsumerOptions"]
+        if value is None:
+            raise KeyError(name)
+    except (ImportError, KeyError) as exc:
+        raise AttributeError(name) from exc
+    globals()[name] = value
+    return value
+
+
+def _engine_class(provider: str) -> Type[QueueEngine]:
+    if provider == PROVIDER_AWS:
+        from .providers.aws import AwsEngine
+
+        return AwsEngine
+    if provider == PROVIDER_RABBITMQ:
+        from .providers.rabbitmq import RabbitMqEngine
+
+        return RabbitMqEngine
+    raise ValueError(f"Unsupported provider '{provider}'")
+
+
+def _async_engine_class(provider: str) -> Type[AsyncQueueEngine]:
+    if provider == PROVIDER_AWS:
+        from .asyncio.aws_async import AwsAsyncEngine
+
+        return AwsAsyncEngine
+    if provider == PROVIDER_RABBITMQ:
+        from .asyncio.rabbitmq_async import RabbitMqAsyncEngine
+
+        return RabbitMqAsyncEngine
+    raise ValueError(f"Unsupported provider '{provider}'")
 
 
 class QueueClient:
     """Single client: pass provider name, then use the same publish/consume/topology methods."""
 
-    _ENGINES: Dict[str, Type[QueueEngine]] = {
-        PROVIDER_AWS: AwsEngine,
-        PROVIDER_RABBITMQ: RabbitMqEngine,
-    }
-
     def __init__(self, provider: str, **config: Any) -> None:
         prov_key = provider.lower().strip()
-        engine_cls = self._ENGINES.get(prov_key)
-        if engine_cls is None:
-            supported = ", ".join(sorted(self._ENGINES))
-            raise ValueError(
-                f"Unsupported provider '{provider}'. Supported: {supported}"
-            )
+        engine_cls = _engine_class(prov_key)
         self.provider = prov_key
         self.engine: QueueEngine = engine_cls(**config)
 
@@ -48,11 +73,17 @@ class QueueClient:
     def bind_pattern(self, queue_id: str, topic_id: str, pattern: str) -> None:
         self.engine.bind_pattern(queue_id, topic_id, pattern)
 
-    def publish(self, destination: str, message: Message) -> None:
-        self.engine.publish(destination, message)
+    def publish(self, destination: str, message: Message) -> Any:
+        return self.engine.publish(destination, message)
 
-    def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
-        self.engine.consume(queue_id, handler)
+    def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: int | None = None,
+    ) -> None:
+        return self.engine.consume(queue_id, handler, prefetch=prefetch)
 
     def stop(self) -> None:
         self.engine.stop()
@@ -70,19 +101,9 @@ class QueueClient:
 class AsyncQueueClient:
     """Async twin of QueueClient. Same method names, same provider argument."""
 
-    _ENGINES: Dict[str, Type[AsyncQueueEngine]] = {
-        PROVIDER_AWS: AwsAsyncEngine,
-        PROVIDER_RABBITMQ: RabbitMqAsyncEngine,
-    }
-
     def __init__(self, provider: str, **config: Any) -> None:
         prov_key = provider.lower().strip()
-        engine_cls = self._ENGINES.get(prov_key)
-        if engine_cls is None:
-            supported = ", ".join(sorted(self._ENGINES))
-            raise ValueError(
-                f"Unsupported provider '{provider}'. Supported: {supported}"
-            )
+        engine_cls = _async_engine_class(prov_key)
         self.provider = prov_key
         self.engine: AsyncQueueEngine = engine_cls(**config)
 
@@ -95,11 +116,17 @@ class AsyncQueueClient:
     async def bind_pattern(self, queue_id: str, topic_id: str, pattern: str) -> None:
         await self.engine.bind_pattern(queue_id, topic_id, pattern)
 
-    async def publish(self, destination: str, message: Message) -> None:
-        await self.engine.publish(destination, message)
-
-    async def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
-        await self.engine.consume(queue_id, handler)
+    async def publish(self, destination: str, message: Message) -> Any:
+        return await self.engine.publish(destination, message)
+
+    async def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: int | None = None,
+    ) -> None:
+        await self.engine.consume(queue_id, handler, prefetch=prefetch)
 
     async def stop(self) -> None:
         await self.engine.stop()

weenspace_queue-0.1.2/weenspace_queue/asyncio/__init__.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+__all__ = ["AwsAsyncEngine", "RabbitMqAsyncEngine"]
+
+
+def __getattr__(name: str) -> Any:
+	try:
+		from rabbitmq_amqp_python_client.asyncio import __dict__ as rabbitmq_namespace
+
+		value = rabbitmq_namespace[name]
+		globals()[name] = value
+		return value
+	except (ImportError, KeyError):
+		pass
+	if name == "AwsAsyncEngine":
+		from .aws_async import AwsAsyncEngine
+
+		return AwsAsyncEngine
+	if name == "RabbitMqAsyncEngine":
+		from .rabbitmq_async import RabbitMqAsyncEngine
+
+		return RabbitMqAsyncEngine
+	raise AttributeError(name)

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/asyncio/aws_async.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import asyncio
+from typing import Any, Callable
+
 from weenspace_queue.base import (
     AsyncQueueEngine,
     Message,
@@ -25,11 +27,19 @@ class AwsAsyncEngine(AsyncQueueEngine):
     async def bind_pattern(self, queue_id: str, topic_id: str, pattern: str) -> None:
         await asyncio.to_thread(self._sync.bind_pattern, queue_id, topic_id, pattern)
 
-    async def publish(self, destination: str, message: Message) -> None:
-        await asyncio.to_thread(self._sync.publish, destination, message)
-
-    async def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
-        await asyncio.to_thread(self._sync.consume, queue_id, handler)
+    async def publish(self, destination: str, message: Message) -> Any:
+        return await asyncio.to_thread(self._sync.publish, destination, message)
+
+    async def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: int | None = None,
+    ) -> None:
+        await asyncio.to_thread(
+            self._sync.consume, queue_id, handler, prefetch=prefetch
+        )
 
     async def stop(self) -> None:
         self._sync.stop()

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/asyncio/rabbitmq_async.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Callable, Optional
 
-from weenspace_queue import (
+from rabbitmq_amqp_python_client import (
     ClassicQueueSpecification,
     ExchangeSpecification,
     ExchangeToQueueBindingSpecification,
@@ -11,10 +11,10 @@ from weenspace_queue import (
     QuorumQueueSpecification,
     StreamSpecification,
 )
-from weenspace_queue.asyncio import AsyncEnvironment
-from weenspace_queue.delivery_context import DeliveryContext
-from weenspace_queue.amqp_consumer_handler import AMQPMessagingHandler
-from weenspace_queue.qpid.proton._events import Event
+from rabbitmq_amqp_python_client.asyncio import AsyncEnvironment
+from rabbitmq_amqp_python_client.delivery_context import DeliveryContext
+from rabbitmq_amqp_python_client.amqp_consumer_handler import AMQPMessagingHandler
+from rabbitmq_amqp_python_client.qpid.proton._events import Event
 
 from weenspace_queue.base import (
     AsyncQueueEngine,
@@ -35,10 +35,10 @@ from weenspace_queue.utils import (
 )
 
 _EXCHANGE_KIND_MAP = {
-    ExchangeKind.DIRECT: ExchangeType.DIRECT,
-    ExchangeKind.TOPIC: ExchangeType.TOPIC,
-    ExchangeKind.FANOUT: ExchangeType.FANOUT,
-    ExchangeKind.HEADERS: ExchangeType.HEADERS,
+    ExchangeKind.DIRECT: ExchangeType.direct,
+    ExchangeKind.TOPIC: ExchangeType.topic,
+    ExchangeKind.FANOUT: ExchangeType.fanout,
+    ExchangeKind.HEADERS: ExchangeType.headers,
 }
 
 
@@ -62,6 +62,9 @@ class _CallbackHandler(AMQPMessagingHandler):
         def requeue(evt: Event = event) -> None:
             context.requeue(evt)
 
+        def modified(evt: Event = event) -> None:
+            context.discard_with_annotations(evt, {})
+
         self._handler(
             Message(
                 body=encode_body(proton_msg.body),
@@ -70,6 +73,7 @@ class _CallbackHandler(AMQPMessagingHandler):
                 accept=accept,
                 reject=reject,
                 requeue=requeue,
+                modified=modified,
             )
         )
 
@@ -88,6 +92,7 @@ class RabbitMqAsyncEngine(AsyncQueueEngine):
         self._conn: Any = None
         self._mgmt: Any = None
         self._consumer: Any = None
+        self._publishers: dict[str, Any] = {}
 
     async def _ensure(self) -> None:
         if self._conn is not None:
@@ -95,6 +100,20 @@ class RabbitMqAsyncEngine(AsyncQueueEngine):
         self._conn = await self._env.connection()
         await self._conn.dial()
         self._mgmt = await self._conn.management()
+        self._fix_quorum_delivery_limit()
+
+    def _fix_quorum_delivery_limit(self) -> None:
+        management = getattr(self._mgmt, "_management", self._mgmt)
+        declare_queue = management._declare_queue
+
+        def declare_queue_with_rabbitmq_key(spec: Any) -> Any:
+            body = declare_queue(spec)
+            arguments = body.get("arguments", {})
+            if "x-deliver-limit" in arguments:
+                arguments["x-delivery-limit"] = arguments.pop("x-deliver-limit")
+            return body
+
+        management._declare_queue = declare_queue_with_rabbitmq_key
 
     async def declare_queue(self, spec: QueueSpecification) -> str:
         await self._ensure()
@@ -141,25 +160,32 @@ class RabbitMqAsyncEngine(AsyncQueueEngine):
             )
         )
 
-    async def publish(self, destination: str, message: Message) -> None:
+    async def publish(self, destination: str, message: Message) -> Any:
         await self._ensure()
         address = self._publish_address(destination, message.routing_key)
-        publisher = await self._conn.publisher(address)
-        try:
-            proton_msg = ProtonMessage(body=encode_body(message.body))
-            proton_msg.inferred = True
-            if message.routing_key:
-                proton_msg.subject = message.routing_key
-            await publisher.publish(proton_msg)
-        finally:
-            await publisher.close()
-
-    async def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
+        publisher = self._publishers.get(address)
+        if publisher is None:
+            publisher = await self._conn.publisher(address)
+            self._publishers[address] = publisher
+        proton_msg = ProtonMessage(body=encode_body(message.body))
+        proton_msg.inferred = True
+        if message.routing_key:
+            proton_msg.subject = message.routing_key
+        return await publisher.publish(proton_msg)
+
+    async def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: Optional[int] = None,
+    ) -> None:
         await self._ensure()
         destination = rabbitmq_queue_address(queue_id)
-        self._consumer = await self._conn.consumer(
-            destination, message_handler=_CallbackHandler(handler)
-        )
+        consumer_kwargs: dict[str, Any] = {"message_handler": _CallbackHandler(handler)}
+        if prefetch is not None:
+            consumer_kwargs["credit"] = prefetch
+        self._consumer = await self._conn.consumer(destination, **consumer_kwargs)
         await self._consumer.run()
 
     async def stop(self) -> None:
@@ -169,6 +195,9 @@ class RabbitMqAsyncEngine(AsyncQueueEngine):
     async def close(self) -> None:
         await self.stop()
         if self._conn is not None:
+            for publisher in self._publishers.values():
+                await publisher.close()
+            self._publishers.clear()
             await self._conn.close()
         await self._env.close()
 

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/base.py

@@ -17,6 +17,7 @@ class Message:
     accept: Optional[Callable[[], None]] = None
     reject: Optional[Callable[[], None]] = None
     requeue: Optional[Callable[[], None]] = None
+    modified: Optional[Callable[[], None]] = None
 
 
 @dataclass
@@ -55,11 +56,17 @@ class QueueEngine(ABC):
         pass
 
     @abstractmethod
-    def publish(self, destination: str, message: Message) -> None:
+    def publish(self, destination: str, message: Message) -> Any:
         pass
 
     @abstractmethod
-    def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
+    def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: Optional[int] = None,
+    ) -> None:
         pass
 
     @abstractmethod
@@ -87,11 +94,17 @@ class AsyncQueueEngine(ABC):
         pass
 
     @abstractmethod
-    async def publish(self, destination: str, message: Message) -> None:
+    async def publish(self, destination: str, message: Message) -> Any:
         pass
 
     @abstractmethod
-    async def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
+    async def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: Optional[int] = None,
+    ) -> None:
         pass
 
     @abstractmethod

weenspace_queue-0.1.2/weenspace_queue/providers/__init__.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+__all__ = ["AwsEngine", "RabbitMqEngine"]
+
+
+def __getattr__(name: str) -> Any:
+	if name == "AwsEngine":
+		from .aws import AwsEngine
+
+		return AwsEngine
+	if name == "RabbitMqEngine":
+		from .rabbitmq import RabbitMqEngine
+
+		return RabbitMqEngine
+	raise AttributeError(name)

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/providers/aws.py

@@ -20,6 +20,7 @@ from weenspace_queue.constants import (
     SQS_FIFO_SUFFIX,
     SQS_POLICY_ATTRIBUTE,
     SQS_QUEUE_ARN_ATTRIBUTE,
+    SQS_ARN_MARKER,
     SQS_RECEIPT_HANDLE_ATTR,
     SQS_REDRIVE_POLICY_ATTRIBUTE,
     SQS_RETENTION_ATTRIBUTE,
@@ -118,7 +119,7 @@ class AwsEngine(QueueEngine):
         self.sns.subscribe(**subscribe_kwargs)
         self._allow_sns_to_sqs(queue_url, queue_arn, topic_id)
 
-    def publish(self, destination: str, message: Message) -> None:
+    def publish(self, destination: str, message: Message) -> Dict[str, Any]:
         body_str = decode_body(message.body)
         msg_attrs = dict(inject_aws_routing_attrs(message.routing_key))
         extra_attrs = message.attributes or {}
@@ -143,8 +144,7 @@ class AwsEngine(QueueEngine):
                 dedup = extra_attrs.get("message_deduplication_id")
                 if dedup:
                     publish_kwargs["MessageDeduplicationId"] = str(dedup)
-            self.sns.publish(**publish_kwargs)
-            return
+            return self.sns.publish(**publish_kwargs)
 
         queue_url = self._as_queue_url(destination)
         send_kwargs: Dict[str, Any] = {
@@ -160,15 +160,22 @@ class AwsEngine(QueueEngine):
             dedup = extra_attrs.get("message_deduplication_id")
             if dedup:
                 send_kwargs["MessageDeduplicationId"] = str(dedup)
-        self.sqs.send_message(**send_kwargs)
+        return self.sqs.send_message(**send_kwargs)
 
-    def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
+    def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: int | None = None,
+    ) -> None:
         queue_url = self._as_queue_url(queue_id)
         self._running = True
+        max_messages = self._max_messages if prefetch is None else max(1, min(prefetch, 10))
         while self._running:
             response = self.sqs.receive_message(
                 QueueUrl=queue_url,
-                MaxNumberOfMessages=self._max_messages,
+                MaxNumberOfMessages=max_messages,
                 WaitTimeSeconds=self._wait_time_seconds,
                 MessageAttributeNames=["All"],
                 AttributeNames=["All"],
@@ -203,6 +210,11 @@ class AwsEngine(QueueEngine):
                 QueueUrl=queue_url, ReceiptHandle=handle, VisibilityTimeout=0
             )
 
+        def modified(handle: str = receipt) -> None:
+            self.sqs.change_message_visibility(
+                QueueUrl=queue_url, ReceiptHandle=handle, VisibilityTimeout=0
+            )
+
         return Message(
             body=body,
             routing_key=routing_key,
@@ -210,6 +222,7 @@ class AwsEngine(QueueEngine):
             accept=accept,
             reject=reject,
             requeue=requeue,
+            modified=modified,
         )
 
     def _as_queue_url(self, queue_id: str) -> str:

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/providers/rabbitmq.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Callable, Optional
 
-from weenspace_queue import (
+from rabbitmq_amqp_python_client import (
     AMQPMessagingHandler,
     ClassicQueueSpecification,
     Environment,
@@ -14,7 +14,7 @@ from weenspace_queue import (
     QuorumQueueSpecification,
     StreamSpecification,
 )
-from weenspace_queue.delivery_context import DeliveryContext
+from rabbitmq_amqp_python_client.delivery_context import DeliveryContext
 
 from weenspace_queue.base import Message, QueueEngine, QueueSpecification, TopicSpecification
 from weenspace_queue.constants import (
@@ -30,10 +30,10 @@ from weenspace_queue.utils import (
 )
 
 _EXCHANGE_KIND_MAP = {
-    ExchangeKind.DIRECT: ExchangeType.DIRECT,
-    ExchangeKind.TOPIC: ExchangeType.TOPIC,
-    ExchangeKind.FANOUT: ExchangeType.FANOUT,
-    ExchangeKind.HEADERS: ExchangeType.HEADERS,
+    ExchangeKind.DIRECT: ExchangeType.direct,
+    ExchangeKind.TOPIC: ExchangeType.topic,
+    ExchangeKind.FANOUT: ExchangeType.fanout,
+    ExchangeKind.HEADERS: ExchangeType.headers,
 }
 
 
@@ -64,6 +64,9 @@ class _CallbackHandler(AMQPMessagingHandler):
         def requeue(evt: Event = event) -> None:
             context.requeue(evt)
 
+        def modified(evt: Event = event) -> None:
+            context.discard_with_annotations(evt, {})
+
         self._handler(
             Message(
                 body=encode_body(proton_msg.body),
@@ -72,6 +75,7 @@ class _CallbackHandler(AMQPMessagingHandler):
                 accept=accept,
                 reject=reject,
                 requeue=requeue,
+                modified=modified,
             )
         )
 
@@ -90,7 +94,21 @@ class RabbitMqEngine(QueueEngine):
         self._conn = self._env.connection()
         self._conn.dial()
         self._mgmt = self._conn.management()
+        self._fix_quorum_delivery_limit()
         self._consumer: Optional[Any] = None
+        self._publishers: dict[str, Any] = {}
+
+    def _fix_quorum_delivery_limit(self) -> None:
+        declare_queue = self._mgmt._declare_queue
+
+        def declare_queue_with_rabbitmq_key(spec: Any) -> Any:
+            body = declare_queue(spec)
+            arguments = body.get("arguments", {})
+            if "x-deliver-limit" in arguments:
+                arguments["x-delivery-limit"] = arguments.pop("x-deliver-limit")
+            return body
+
+        self._mgmt._declare_queue = declare_queue_with_rabbitmq_key
 
     def declare_queue(self, spec: QueueSpecification) -> str:
         if spec.kind == QueueKind.STREAM:
@@ -156,35 +174,44 @@ class RabbitMqEngine(QueueEngine):
             )
         )
 
-    def publish(self, destination: str, message: Message) -> None:
+    def publish(self, destination: str, message: Message) -> Any:
         address = self._publish_address(destination, message.routing_key)
-        publisher = self._conn.publisher(address)
-        try:
-            proton_msg = ProtonMessage(body=encode_body(message.body))
-            proton_msg.inferred = True
-            if message.routing_key:
-                proton_msg.subject = message.routing_key
-            correlation_id = (message.attributes or {}).get("correlation_id")
-            if correlation_id is not None:
-                proton_msg.correlation_id = correlation_id
-            reply_to = (message.attributes or {}).get("reply_to")
-            if reply_to:
-                proton_msg.reply_to = reply_to
-            if message.attributes:
-                proton_msg.properties = {
-                    key: value
-                    for key, value in message.attributes.items()
-                    if key not in {"correlation_id", "reply_to"}
-                    and isinstance(value, (str, int, float, bool))
-                }
-            publisher.publish(proton_msg)
-        finally:
-            publisher.close()
-
-    def consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
+        publisher = self._publishers.get(address)
+        if publisher is None:
+            publisher = self._conn.publisher(address)
+            self._publishers[address] = publisher
+        proton_msg = ProtonMessage(body=encode_body(message.body))
+        proton_msg.inferred = True
+        if message.routing_key:
+            proton_msg.subject = message.routing_key
+        correlation_id = (message.attributes or {}).get("correlation_id")
+        if correlation_id is not None:
+            proton_msg.correlation_id = correlation_id
+        reply_to = (message.attributes or {}).get("reply_to")
+        if reply_to:
+            proton_msg.reply_to = reply_to
+        if message.attributes:
+            proton_msg.properties = {
+                key: value
+                for key, value in message.attributes.items()
+                if key not in {"correlation_id", "reply_to"}
+                and isinstance(value, (str, int, float, bool))
+            }
+        return publisher.publish(proton_msg)
+
+    def consume(
+        self,
+        queue_id: str,
+        handler: Callable[[Message], None],
+        *,
+        prefetch: Optional[int] = None,
+    ) -> None:
         destination = rabbitmq_queue_address(queue_id)
         wrapped = _CallbackHandler(handler)
-        self._consumer = self._conn.consumer(destination, message_handler=wrapped)
+        consumer_kwargs: dict[str, Any] = {"message_handler": wrapped}
+        if prefetch is not None:
+            consumer_kwargs["credit"] = prefetch
+        self._consumer = self._conn.consumer(destination, **consumer_kwargs)
         self._consumer.run()
 
     def stop(self) -> None:
@@ -193,6 +220,9 @@ class RabbitMqEngine(QueueEngine):
 
     def close(self) -> None:
         self.stop()
+        for publisher in self._publishers.values():
+            publisher.close()
+        self._publishers.clear()
         self._conn.close()
 
     def _publish_address(self, destination: str, routing_key: str) -> str:

weenspace_queue-0.1.2/weenspace_queue/ssl_configuration.py

@@ -0,0 +1,3 @@
+"""Compatibility exports for the RabbitMQ TLS configuration API."""
+
+from rabbitmq_amqp_python_client.ssl_configuration import *  # noqa: F401,F403

{weenspace_queue-0.1.0 → weenspace_queue-0.1.2}/weenspace_queue/utils.py

@@ -24,6 +24,14 @@ from .constants import (
 )
 
 
+def __getattr__(name: str) -> Any:
+    if name == "Converter":
+        from rabbitmq_amqp_python_client.utils import Converter
+
+        return Converter
+    raise AttributeError(name)
+
+
 def encode_body(body: Any) -> bytes:
     if isinstance(body, bytes):
         return body

weenspace_queue-0.1.0/weenspace_queue/asyncio/__init__.py

@@ -1,4 +0,0 @@
-from .aws_async import AwsAsyncEngine
-from .rabbitmq_async import RabbitMqAsyncEngine
-
-__all__ = ["AwsAsyncEngine", "RabbitMqAsyncEngine"]

weenspace_queue-0.1.0/weenspace_queue/providers/__init__.py

@@ -1,4 +0,0 @@
-from .aws import AwsEngine
-from .rabbitmq import RabbitMqEngine
-
-__all__ = ["AwsEngine", "RabbitMqEngine"]