weenspace-queue 0.1.0__tar.gz

weenspace_queue-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WeenSpace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weenspace_queue-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: weenspace-queue
+Version: 0.1.0
+Summary: WeenSpace queue client for RabbitMQ and AWS SQS, supporting both synchronous and asynchronous operations.
+License: MIT
+License-File: LICENSE
+Keywords: rabbitmq,amqp,messaging,event-driven,microservices,queue,weenspace
+Author: WeenSpace
+Author-email: weenspace@gmail.com
+Requires-Python: >=3.14,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Requires-Dist: packaging (>=25.0,<26.0)
+Requires-Dist: python-qpid-proton (>=0.40.0,<0.41.0)
+Requires-Dist: typing-extensions (>=4.15.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
+
+# WeenSpace RabbitMQ Client
+
+[![PyPI version](https://badge.fury.io/py/weenspace-queue.svg)](https://pypi.org/project/weenspace-queue/)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+A powerful Python RabbitMQ client for AMQP 1.0 protocol, designed for event-driven microservices architecture.
+
+## ✨ Features
+
+- 🔐 **Authentication**: OAuth2, TLS/SSL, Basic Auth
+- 📬 **Queue Types**: Classic, Quorum, Stream queues
+- ☠️ **Dead Letter Queues**: Built-in DLQ support with configurable strategies
+- ⚡ **Priority Queues**: Native priority queue support
+- 🔄 **Auto Reconnection**: Configurable recovery with exponential backoff
+- 🔀 **All Exchange Types**: Direct, Fanout, Topic, Headers
+- 🚀 **Async Support**: Native asyncio integration
+- 📊 **Streams**: RabbitMQ Streams with filtering support
+
+## 📦 Installation
+
+```bash
+pip install weenspace-queue
+```
+
+## 🚀 Quick Start
+
+### Basic 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)
+
+# Publish message
+publisher = connection.publisher("/queues/my-queue")
+publisher.publish(Message(body=b"Hello WeenSpace!"))
+
+# Consume messages
+def on_message(message):
+    print(f"Received: {message.body}")
+    message.accept()
+
+consumer = connection.consumer("/queues/my-queue", handler=on_message)
+```
+
+### Async Support
+
+```python
+import asyncio
+from weenspace_queue.asyncio import AsyncEnvironment
+
+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!"))
+
+asyncio.run(main())
+```
+
+### OAuth2 Authentication
+
+```python
+from weenspace_queue import Environment, OAuth2Options
+
+oauth = OAuth2Options(token="your_jwt_token")
+environment = Environment(
+    uri="amqp://localhost:5672/",
+    oauth2_options=oauth
+)
+```
+
+### TLS/SSL Connection
+
+```python
+from weenspace_queue import Environment, SslConfiguration
+
+ssl_config = SslConfiguration(
+    ca_cert="/path/to/ca.pem",
+    client_cert="/path/to/client.pem",
+    client_key="/path/to/client.key"
+)
+environment = Environment(
+    uri="amqps://localhost:5671/",
+    ssl_configuration=ssl_config
+)
+```
+
+## 📚 Documentation
+
+See [examples](./examples) folder for more detailed usage examples.
+
+## 🔄 Migration from python-rabbitmq
+
+```python
+# Old (python-rabbitmq)
+# from python_rabbitmq import RabbitMQ
+
+# New (weenspace-queue)
+from weenspace_queue import Environment, Connection
+```
+
+## 📋 Requirements
+
+- Python 3.13+
+- RabbitMQ 4.x with AMQP 1.0 plugin enabled
+
+## 📄 License
+
+MIT License - Based on the official [RabbitMQ AMQP Python Client](https://github.com/rabbitmq/rabbitmq-amqp-python-client)
+
+## 🙏 Credits
+
+This library is based on the official RabbitMQ AMQP 1.0 Python client by the RabbitMQ team.
+

weenspace_queue-0.1.0/README.md

@@ -0,0 +1,136 @@
+# WeenSpace RabbitMQ Client
+
+[![PyPI version](https://badge.fury.io/py/weenspace-queue.svg)](https://pypi.org/project/weenspace-queue/)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+A powerful Python RabbitMQ client for AMQP 1.0 protocol, designed for event-driven microservices architecture.
+
+## ✨ Features
+
+- 🔐 **Authentication**: OAuth2, TLS/SSL, Basic Auth
+- 📬 **Queue Types**: Classic, Quorum, Stream queues
+- ☠️ **Dead Letter Queues**: Built-in DLQ support with configurable strategies
+- ⚡ **Priority Queues**: Native priority queue support
+- 🔄 **Auto Reconnection**: Configurable recovery with exponential backoff
+- 🔀 **All Exchange Types**: Direct, Fanout, Topic, Headers
+- 🚀 **Async Support**: Native asyncio integration
+- 📊 **Streams**: RabbitMQ Streams with filtering support
+
+## 📦 Installation
+
+```bash
+pip install weenspace-queue
+```
+
+## 🚀 Quick Start
+
+### Basic 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)
+
+# Publish message
+publisher = connection.publisher("/queues/my-queue")
+publisher.publish(Message(body=b"Hello WeenSpace!"))
+
+# Consume messages
+def on_message(message):
+    print(f"Received: {message.body}")
+    message.accept()
+
+consumer = connection.consumer("/queues/my-queue", handler=on_message)
+```
+
+### Async Support
+
+```python
+import asyncio
+from weenspace_queue.asyncio import AsyncEnvironment
+
+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!"))
+
+asyncio.run(main())
+```
+
+### OAuth2 Authentication
+
+```python
+from weenspace_queue import Environment, OAuth2Options
+
+oauth = OAuth2Options(token="your_jwt_token")
+environment = Environment(
+    uri="amqp://localhost:5672/",
+    oauth2_options=oauth
+)
+```
+
+### TLS/SSL Connection
+
+```python
+from weenspace_queue import Environment, SslConfiguration
+
+ssl_config = SslConfiguration(
+    ca_cert="/path/to/ca.pem",
+    client_cert="/path/to/client.pem",
+    client_key="/path/to/client.key"
+)
+environment = Environment(
+    uri="amqps://localhost:5671/",
+    ssl_configuration=ssl_config
+)
+```
+
+## 📚 Documentation
+
+See [examples](./examples) folder for more detailed usage examples.
+
+## 🔄 Migration from python-rabbitmq
+
+```python
+# Old (python-rabbitmq)
+# from python_rabbitmq import RabbitMQ
+
+# New (weenspace-queue)
+from weenspace_queue import Environment, Connection
+```
+
+## 📋 Requirements
+
+- Python 3.13+
+- RabbitMQ 4.x with AMQP 1.0 plugin enabled
+
+## 📄 License
+
+MIT License - Based on the official [RabbitMQ AMQP Python Client](https://github.com/rabbitmq/rabbitmq-amqp-python-client)
+
+## 🙏 Credits
+
+This library is based on the official RabbitMQ AMQP 1.0 Python client by the RabbitMQ team.

weenspace_queue-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[tool.poetry]
+name = "weenspace-queue"
+version = "0.1.0"
+description = "WeenSpace queue client for RabbitMQ and AWS SQS, supporting both synchronous and asynchronous operations."
+authors = ["WeenSpace <weenspace@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/weenspace/weenspace-queue"
+repository = "https://github.com/weenspace/weenspace-queue"
+keywords = ["rabbitmq", "amqp", "messaging", "event-driven", "microservices", "queue", "weenspace"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Networking",
+]
+packages = [{include = "weenspace_queue"}]
+
+[tool.poetry.dependencies]
+python = "^3.14"
+python-qpid-proton = "^0.40.0"
+typing-extensions = "^4.15.0"
+packaging = "^25.0"
+
+[tool.poetry.group.dev.dependencies]
+pyjwt = "^2.13.0"
+pika = "^1.4.4"
+flake8 = "^7.3.0"
+isort = "^6.0.0"
+mypy = "^1.19.0"
+pytest = "^9.0.0"
+black = "^26.5.1"
+requests = "^2.32.0"
+pytest-asyncio = "^1.3.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "boto3>=1.43.80",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.black]
+line-length = 88
+target-version = ['py313']
+
+[tool.isort]
+profile = "black"
+line_length = 88
+
+[tool.mypy]
+python_version = "3.13"
+warn_return_any = true
+warn_unused_configs = true

weenspace_queue-0.1.0/weenspace_queue/__init__.py

@@ -0,0 +1,128 @@
+from typing import Any, Callable, Dict, Type
+
+from .asyncio.aws_async import AwsAsyncEngine
+from .asyncio.rabbitmq_async import RabbitMqAsyncEngine
+from .base import (
+    AsyncQueueEngine,
+    Message,
+    QueueEngine,
+    QueueSpecification,
+    TopicSpecification,
+)
+from .constants import (
+    PROVIDER_AWS,
+    PROVIDER_RABBITMQ,
+    ExchangeKind,
+    Provider,
+    QueueKind,
+)
+from .providers.aws import AwsEngine
+from .providers.rabbitmq import RabbitMqEngine
+
+
+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}"
+            )
+        self.provider = prov_key
+        self.engine: QueueEngine = engine_cls(**config)
+
+    def declare_queue(self, spec: QueueSpecification) -> str:
+        return self.engine.declare_queue(spec)
+
+    def declare_topic(self, spec: TopicSpecification) -> str:
+        return self.engine.declare_topic(spec)
+
+    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 consume(self, queue_id: str, handler: Callable[[Message], None]) -> None:
+        self.engine.consume(queue_id, handler)
+
+    def stop(self) -> None:
+        self.engine.stop()
+
+    def close(self) -> None:
+        self.engine.close()
+
+    def __enter__(self) -> "QueueClient":
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        self.close()
+
+
+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}"
+            )
+        self.provider = prov_key
+        self.engine: AsyncQueueEngine = engine_cls(**config)
+
+    async def declare_queue(self, spec: QueueSpecification) -> str:
+        return await self.engine.declare_queue(spec)
+
+    async def declare_topic(self, spec: TopicSpecification) -> str:
+        return await self.engine.declare_topic(spec)
+
+    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 stop(self) -> None:
+        await self.engine.stop()
+
+    async def close(self) -> None:
+        await self.engine.close()
+
+    async def __aenter__(self) -> "AsyncQueueClient":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        await self.close()
+
+
+__all__ = [
+    "AsyncQueueClient",
+    "AsyncQueueEngine",
+    "ExchangeKind",
+    "Message",
+    "Provider",
+    "QueueClient",
+    "QueueEngine",
+    "QueueKind",
+    "QueueSpecification",
+    "TopicSpecification",
+]

weenspace_queue-0.1.0/weenspace_queue/asyncio/__init__.py

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

weenspace_queue-0.1.0/weenspace_queue/asyncio/aws_async.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import asyncio
+from weenspace_queue.base import (
+    AsyncQueueEngine,
+    Message,
+    QueueSpecification,
+    TopicSpecification,
+)
+from weenspace_queue.providers.aws import AwsEngine
+
+
+class AwsAsyncEngine(AsyncQueueEngine):
+    """Async AWS engine. Uses aioboto3 when installed, otherwise boto3 in a worker thread."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        self._sync = AwsEngine(**kwargs)
+
+    async def declare_queue(self, spec: QueueSpecification) -> str:
+        return await asyncio.to_thread(self._sync.declare_queue, spec)
+
+    async def declare_topic(self, spec: TopicSpecification) -> str:
+        return await asyncio.to_thread(self._sync.declare_topic, spec)
+
+    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 stop(self) -> None:
+        self._sync.stop()
+
+    async def close(self) -> None:
+        await asyncio.to_thread(self._sync.close)