weenspace-queue 0.1.0__py3-none-any.whl

weenspace_queue/utils.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from .constants import (
+    AWS_NUMBER_DATA_TYPE,
+    AWS_STRING_DATA_TYPE,
+    RABBITMQ_EXCHANGE_PREFIX,
+    RABBITMQ_QUEUE_PREFIX,
+    ROUTING_KEY_ATTR,
+    ROUTING_KEY_INDEX_PREFIX,
+    ROUTING_KEY_LENGTH_ATTR,
+    ROUTING_KEY_REVERSE_INDEX_PREFIX,
+    ROUTING_SEPARATOR,
+    SNS_ARN_MARKER,
+    SNS_NOTIFICATION_TYPE,
+    SQS_ARN_MARKER,
+    SQS_BODY_KEY,
+    SQS_FIFO_SUFFIX,
+    SQS_URL_MARKER,
+    WILDCARD_MULTI,
+    WILDCARD_SINGLE,
+)
+
+
+def encode_body(body: Any) -> bytes:
+    if isinstance(body, bytes):
+        return body
+    if body is None:
+        return b""
+    if isinstance(body, str):
+        return body.encode("utf-8")
+    return json.dumps(body).encode("utf-8")
+
+
+def decode_body(body: Any) -> str:
+    if isinstance(body, bytes):
+        return body.decode("utf-8")
+    return str(body)
+
+
+def split_routing(value: str) -> List[str]:
+    if value == "":
+        return []
+    return value.split(ROUTING_SEPARATOR)
+
+
+def is_sns_destination(destination: str) -> bool:
+    return SNS_ARN_MARKER in destination
+
+
+def is_sqs_destination(destination: str) -> bool:
+    return SQS_ARN_MARKER in destination or SQS_URL_MARKER in destination
+
+
+def is_fifo_queue(name_or_url: str) -> bool:
+    return name_or_url.rstrip("/").endswith(SQS_FIFO_SUFFIX)
+
+
+def rabbitmq_queue_address(queue_id: str) -> str:
+    if queue_id.startswith(RABBITMQ_QUEUE_PREFIX) or queue_id.startswith(
+        RABBITMQ_EXCHANGE_PREFIX
+    ):
+        return queue_id
+    return f"{RABBITMQ_QUEUE_PREFIX}{queue_id.lstrip('/')}"
+
+
+def rabbitmq_exchange_address(topic_id: str, routing_key: str = "") -> str:
+    if topic_id.startswith(RABBITMQ_EXCHANGE_PREFIX) or topic_id.startswith(
+        RABBITMQ_QUEUE_PREFIX
+    ):
+        if routing_key and topic_id.count("/") == 2:
+            return f"{topic_id}/{routing_key}"
+        return topic_id
+    if routing_key:
+        return f"{RABBITMQ_EXCHANGE_PREFIX}{topic_id}/{routing_key}"
+    return f"{RABBITMQ_EXCHANGE_PREFIX}{topic_id}"
+
+
+def rabbitmq_resource_name(resource_id: str) -> str:
+    if resource_id.startswith(RABBITMQ_QUEUE_PREFIX):
+        return resource_id[len(RABBITMQ_QUEUE_PREFIX) :]
+    if resource_id.startswith(RABBITMQ_EXCHANGE_PREFIX):
+        remainder = resource_id[len(RABBITMQ_EXCHANGE_PREFIX) :]
+        return remainder.split("/", 1)[0]
+    return resource_id
+
+
+def inject_aws_routing_attrs(routing_key: str) -> Dict[str, Any]:
+    """Hydrate SNS/SQS MessageAttributes so wildcard filter policies can match."""
+    if not routing_key:
+        return {}
+    segments = split_routing(routing_key)
+    attributes: Dict[str, Any] = {
+        ROUTING_KEY_ATTR: {
+            "DataType": AWS_STRING_DATA_TYPE,
+            "StringValue": routing_key,
+        },
+        ROUTING_KEY_LENGTH_ATTR: {
+            "DataType": AWS_NUMBER_DATA_TYPE,
+            "StringValue": str(len(segments)),
+        },
+    }
+    for idx, value in enumerate(segments):
+        attributes[f"{ROUTING_KEY_INDEX_PREFIX}{idx}"] = {
+            "DataType": AWS_STRING_DATA_TYPE,
+            "StringValue": value,
+        }
+        attributes[f"{ROUTING_KEY_REVERSE_INDEX_PREFIX}{idx}"] = {
+            "DataType": AWS_STRING_DATA_TYPE,
+            "StringValue": segments[-(idx + 1)],
+        }
+    return attributes
+
+
+def rmq_pattern_to_aws_sns(routing_pattern: str) -> Dict[str, Any]:
+    """
+    Translate RabbitMQ topic patterns into SNS Message Attribute filter policies.
+
+    Supported shapes:
+    - exact: order.placed
+    - single-word *: order.*.completed
+    - multi-word trailing #: global.orders.#
+    - multi-word leading #: #.delayed
+    - combined: eu.*.truck.#
+    - middle #: region.#.failed
+    """
+    pattern = routing_pattern.strip()
+    if pattern in ("", WILDCARD_MULTI):
+        return {}
+
+    segments = split_routing(pattern)
+    if WILDCARD_SINGLE not in segments and WILDCARD_MULTI not in segments:
+        return {
+            ROUTING_KEY_ATTR: [pattern],
+            ROUTING_KEY_LENGTH_ATTR: [{"numeric": ["=", len(segments)]}],
+        }
+
+    hash_indexes = [i for i, segment in enumerate(segments) if segment == WILDCARD_MULTI]
+    policy: Dict[str, Any] = {}
+
+    if not hash_indexes:
+        policy[ROUTING_KEY_LENGTH_ATTR] = [{"numeric": ["=", len(segments)]}]
+        _apply_segment_filters(policy, segments, reverse=False)
+        return policy
+
+    first_hash = hash_indexes[0]
+    last_hash = hash_indexes[-1]
+    prefix = segments[:first_hash]
+    suffix = segments[last_hash + 1 :]
+
+    _apply_segment_filters(policy, prefix, reverse=False)
+    _apply_segment_filters(policy, list(reversed(suffix)), reverse=True)
+    return policy
+
+
+def _apply_segment_filters(
+    policy: Dict[str, Any], segments: List[str], reverse: bool
+) -> None:
+    prefix = ROUTING_KEY_REVERSE_INDEX_PREFIX if reverse else ROUTING_KEY_INDEX_PREFIX
+    for idx, segment in enumerate(segments):
+        key = f"{prefix}{idx}"
+        if segment == WILDCARD_MULTI:
+            continue
+        if segment == WILDCARD_SINGLE:
+            policy[key] = [{"exists": True}]
+        else:
+            policy[key] = [segment]
+
+
+def rabbitmq_pattern_matches(pattern: str, routing_key: str) -> bool:
+    """Reference matcher for RabbitMQ topic semantics used in tests."""
+    return _match_segments(split_routing(pattern), split_routing(routing_key))
+
+
+def _match_segments(pattern: List[str], key: List[str]) -> bool:
+    if not pattern:
+        return not key
+    head, tail = pattern[0], pattern[1:]
+    if head == WILDCARD_MULTI:
+        for consumed in range(len(key) + 1):
+            if _match_segments(tail, key[consumed:]):
+                return True
+        return False
+    if not key:
+        return False
+    if head in (WILDCARD_SINGLE, key[0]):
+        return _match_segments(tail, key[1:])
+    return False
+
+
+def sns_filter_matches(policy: Dict[str, Any], routing_key: str) -> bool:
+    """Evaluate a translated SNS filter against injected routing attributes."""
+    if not policy:
+        return True
+    attributes = inject_aws_routing_attrs(routing_key)
+    for attr_name, conditions in policy.items():
+        actual = attributes.get(attr_name)
+        if actual is None:
+            return False
+        actual_value = actual["StringValue"]
+        if not _condition_matches(conditions, actual_value):
+            return False
+    return True
+
+
+def _condition_matches(conditions: List[Any], actual_value: str) -> bool:
+    for condition in conditions:
+        if isinstance(condition, dict):
+            if "exists" in condition:
+                if condition["exists"]:
+                    return True
+                continue
+            numeric = condition.get("numeric")
+            if numeric and numeric[0] == "=":
+                return str(actual_value) == str(numeric[1])
+            continue
+        if str(condition) == str(actual_value):
+            return True
+    return False
+
+
+def unwrap_sqs_body(raw_body: str) -> tuple[bytes, str, Dict[str, Any]]:
+    """Unwrap SNS-to-SQS envelopes when present; otherwise treat as the payload."""
+    attributes: Dict[str, Any] = {}
+    routing_key = ""
+    body = raw_body
+    try:
+        parsed = json.loads(raw_body)
+    except (TypeError, json.JSONDecodeError):
+        return encode_body(raw_body), routing_key, attributes
+
+    if isinstance(parsed, dict) and parsed.get("Type") == SNS_NOTIFICATION_TYPE:
+        body = parsed.get("Message", "")
+        sns_attrs = parsed.get("MessageAttributes") or {}
+        routing_key = _routing_key_from_sns_attrs(sns_attrs)
+        attributes["sns"] = {key: value for key, value in parsed.items() if key != "Message"}
+        return encode_body(body), routing_key, attributes
+
+    return encode_body(raw_body), routing_key, attributes
+
+
+def _routing_key_from_sns_attrs(sns_attrs: Dict[str, Any]) -> str:
+    routing = sns_attrs.get(ROUTING_KEY_ATTR) or {}
+    return str(routing.get("Value") or routing.get("StringValue") or "")
+
+
+def routing_key_from_sqs_attributes(message: Dict[str, Any]) -> str:
+    attrs = message.get("MessageAttributes") or {}
+    routing = attrs.get(ROUTING_KEY_ATTR) or {}
+    return str(routing.get("StringValue") or routing.get("Value") or "")
+
+
+def extract_sqs_body(message: Dict[str, Any]) -> tuple[bytes, str, Dict[str, Any]]:
+    raw = message.get(SQS_BODY_KEY, "")
+    body, routing_key, extra = unwrap_sqs_body(raw)
+    if not routing_key:
+        routing_key = routing_key_from_sqs_attributes(message)
+    extra["sqs"] = {
+        key: value
+        for key, value in message.items()
+        if key not in {SQS_BODY_KEY}
+    }
+    return body, routing_key, extra
+
+
+def optional_queue_name_from_url(queue_url: str) -> Optional[str]:
+    if not queue_url:
+        return None
+    return queue_url.rstrip("/").split("/")[-1]

weenspace_queue-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+weenspace_queue/__init__.py,sha256=RGWo5dl9u-FfSlxT-dYiKg-ZPFu7ZBs3gd-SYOvuTaI,3964
+weenspace_queue/asyncio/__init__.py,sha256=DO2yDMXX-WosrZfxUbilQvUsIZlK-4I8K5qREu--4FI,139
+weenspace_queue/asyncio/aws_async.py,sha256=Jd-6tpF5PnLdqxTQ_9ScLkPihRl7NrcWFIPX_d4Da-k,1356
+weenspace_queue/asyncio/rabbitmq_async.py,sha256=-FWzSHLWV7f1wWebpYhRh2Wm7u5mhIw4elpZn7X8zRU,6339
+weenspace_queue/base.py,sha256=XTnA4afHlxgDr6fgZKEaox33AEaOYSZt5zRvNDDkSnQ,2602
+weenspace_queue/constants.py,sha256=RGpCUeu7GEv8yX7DGkBjxAqPoeIBMtrGzIRGWPau3kM,2009
+weenspace_queue/providers/__init__.py,sha256=mnVEFyRt1ttlNxiRUAUUV2yZl3djJhsKVHCRIsMo4cw,107
+weenspace_queue/providers/aws.py,sha256=0pQgcIciVbR2b0Zj4l4bTin_vCeUsh6eMN7RNLZJw50,10671
+weenspace_queue/providers/rabbitmq.py,sha256=0tDBx-oxBOHgy1UefmeUL0VvmWJPv-HCrYDL7qIeZKE,7390
+weenspace_queue/utils.py,sha256=6CB1kSNxuiGxA7A6dEDIooc7YHCw7cGuIpwZmq4mG74,8809
+weenspace_queue-0.1.0.dist-info/METADATA,sha256=d-trZDroRkRXlVba_1e441U_Z12JqE9P2c1bu16UiRg,4618
+weenspace_queue-0.1.0.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+weenspace_queue-0.1.0.dist-info/licenses/LICENSE,sha256=aHFdqhTZFeswtMH5Fi6Owota-zZ_juV_37U2wuj_axU,1066
+weenspace_queue-0.1.0.dist-info/RECORD,,

weenspace_queue-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: true
+Tag: py3-none-any

weenspace_queue-0.1.0.dist-info/licenses/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.