taraqueue 0.0.2.dev0__py3-none-any.whl → 0.2.0__py3-none-any.whl

taraqueue/__init__.py

@@ -0,0 +1,51 @@
+"""Queue abstraction."""
+
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+
+from yarl import URL
+
+from taraqueue.registry import registry_load
+
+
+class QueueEmpty(Exception):
+    """Raised when the queue is empty."""
+
+
+@dataclass
+class Queue(ABC):
+    """Base queue class."""
+
+    @classmethod
+    def from_url(cls, url: URL | str, registry=None) -> "Queue":
+        if registry is None:
+            registry = registry_load("taraqueue")
+        scheme = URL(url).scheme
+        queue_cls = registry["taraqueue"][scheme]
+        return queue_cls.from_url(url)
+
+    @abstractmethod
+    async def subscribe(self, topic: str) -> None:
+        """Subscribe to a topic before receiving messages."""
+
+    @abstractmethod
+    async def unsubscribe(self, topic: str) -> None:
+        """Unsubscribe from a topic after receiving messages."""
+
+    @abstractmethod
+    async def receive(self, timeout=None) -> str:
+        """Listen for messages on the subscribed topics."""
+
+    @abstractmethod
+    async def publish(self, topic: str, message: str) -> None:
+        """Publish a message to a topic."""
+
+    @asynccontextmanager
+    async def connect(self, topic: str):
+        """Context manager that subscribes on entry and unsubscribes on exit."""
+        await self.subscribe(topic)
+        try:
+            yield self
+        finally:
+            await self.unsubscribe(topic)

taraqueue/memory.py

@@ -0,0 +1,50 @@
+"""Memory queue implementation."""
+
+from collections import defaultdict
+from contextlib import suppress
+from dataclasses import dataclass, field
+
+from yarl import URL
+
+from taraqueue import Queue, QueueEmpty
+
+_global_memory_queues = defaultdict(list)
+
+
+@dataclass
+class MemoryQueue(Queue):
+
+    topics: list = field(default_factory=list)
+    queues: dict = field(default_factory=lambda: _global_memory_queues)
+
+    @classmethod
+    def from_url(cls, url: URL) -> "MemoryQueue":
+        return cls()
+
+    async def subscribe(self, topic: str) -> None:
+        """See `Queue.subscribe`."""
+        self.topics.append(topic)
+
+    async def unsubscribe(self, topic: str) -> None:
+        """See `Queue.unsubscribe`."""
+        with suppress(ValueError):
+            self.topics.remove(topic)
+
+    async def receive(self, timeout=None) -> str:
+        """See `Queue.receive`."""
+        for topic in self.topics[:]:
+            # Cycle through topics.
+            self.topics.append(self.topics.pop(0))
+            queue = self.queues[topic]
+            with suppress(IndexError):
+                return queue.pop(0)
+
+        raise QueueEmpty("Queue is empty")
+
+    async def publish(self, topic: str, message: str) -> None:
+        """See `Queue.publish`."""
+        queue = self.queues[topic]
+        queue.append(message)
+
+
+

taraqueue/redis.py

@@ -0,0 +1,67 @@
+"""Redis queue implementation."""
+
+import os
+from dataclasses import dataclass, field
+from time import time
+
+from redis.asyncio import Redis
+from redis.asyncio.client import PubSub
+from yarl import URL
+
+from taraqueue import Queue, QueueEmpty
+
+
+@dataclass
+class RedisQueue(Queue):
+
+    client: Redis = field()
+    pubsub: PubSub = field()
+
+    @classmethod
+    def from_env(cls, env=os.environ) -> "RedisQueue":
+        host = env.get("REDIS_SLAVEOF_IP", "") or env.get("IPV4_NETWORK", "172.22.1") + ".249"
+        port = int(env.get("REDIS_SLAVEOF_PORT", "") or "6379")
+        password = env.get("REDISPASS")
+        return cls.from_host(host, port, password=password)
+
+    @classmethod
+    def from_host(cls, host: str, port: int = 6379, password: str | None = None) -> "RedisQueue":
+        from redis.asyncio import StrictRedis
+
+        client = StrictRedis(
+            host=host,
+            port=port,
+            decode_responses=True,
+            db=0,
+            password=password,
+        )
+        pubsub = client.pubsub(ignore_subscribe_messages=True)
+        return cls(client, pubsub)
+
+    @classmethod
+    def from_url(cls, url: URL | str) -> "RedisQueue":
+        url = URL(url)
+        return cls.from_host(url.host, url.port, password=url.password)
+
+    async def subscribe(self, topic: str) -> None:
+        """See `Queue.subscribe`."""
+        await self.pubsub.subscribe(topic)
+
+    async def unsubscribe(self, topic: str) -> None:
+        """See `Queue.unsubscribe`."""
+        await self.pubsub.unsubscribe(topic)
+
+    async def receive(self, timeout=0) -> str:
+        """See `Queue.receive`."""
+        stop_time = time() + timeout
+        while True:
+            remaining_timeout = max(0.0, stop_time - time())
+            message = await self.pubsub.get_message(ignore_subscribe_messages=True, timeout=remaining_timeout)
+            if message:
+                return message["data"]
+            if time() >= stop_time:
+                raise QueueEmpty("Queue is empty")
+
+    async def publish(self, topic: str, message: str) -> None:
+        """See `Queue.publish`."""
+        await self.client.publish(topic, message)

taraqueue/testing/compose.py

@@ -1,16 +1,16 @@
 """Compose server module."""
 
 from contextlib import contextmanager
+from dataclasses import dataclass
 from datetime import datetime
 
-from attrs import define
 from more_itertools import only
 from pytest_xdocker.docker import DockerContainer
 from pytest_xdocker.process import ProcessData, ProcessServer
 from pytest_xdocker.xdocker import xdocker
 
 
-@define(frozen=True)
+@dataclass(frozen=True)
 class ComposeService:
     """Compose service.
 

taraqueue/testing/queue.py

@@ -3,7 +3,7 @@
 import pytest
 from yarl import URL
 
-from taraqueue.queue import Queue
+from taraqueue import Queue
 
 
 @pytest.fixture

{taraqueue-0.0.2.dev0.dist-info → taraqueue-0.2.0.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: taraqueue
-Version: 0.0.2.dev0
+Version: 0.2.0
 Summary: Python queue abstraction layer
 Project-URL: Repository, https://github.com/taradix/taraqueue
 Author-email: Marc Tardif <marc@taram.ca>
 License-File: LICENSE.rst
 Requires-Python: <4.0,>=3.12
-Requires-Dist: attrs>=26.1.0
 Requires-Dist: yarl>=1.23.0
 Provides-Extra: check
 Requires-Dist: ruff<1.0.0,>=0.15.0; extra == 'check'

taraqueue-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+taraqueue/__init__.py,sha256=kCe0aTFoyiVQdilCJjUDsO3mYh2EjBIqxkcQQBRnM0s,1434
+taraqueue/memory.py,sha256=JpxH_Ru6VMLehtiVh7KbcvRsCVsuUKKtEHIp-BOKaP8,1323
+taraqueue/redis.py,sha256=AiGN7PUW8bdpuj3FwfXSz9KWq69QAyaMQ8GSHiNKwHM,2151
+taraqueue/registry.py,sha256=YcF9FE21HWfzoFbGGtC4GBozj-g5YbQuWdOor9XoPrU,2036
+taraqueue/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+taraqueue/testing/compose.py,sha256=-AjhI5mOF1BzFfBweK1a1sZQo_V4uM7QM6-V1QLaACY,2908
+taraqueue/testing/queue.py,sha256=mTJVCBHS5B2QF0rillW2uPx227JcoDWyFEIxxMhKpWs,671
+taraqueue/testing/services.py,sha256=YmbsbAiX_kBVziwnNwkuvxn-82zhNE926oxF6V0SfzU,2213
+taraqueue-0.2.0.dist-info/METADATA,sha256=Q46HXLE76L_bwqeVrQJQbQmiDTdx0qh_VeQoG1t5qOM,2102
+taraqueue-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+taraqueue-0.2.0.dist-info/entry_points.txt,sha256=xqxmScNzMBHMqUEDuTaNXhDzytsrwwvRVujNbdnEOZc,187
+taraqueue-0.2.0.dist-info/licenses/LICENSE.rst,sha256=aBUUonOC9jBjhQb0VIObBylPnlIVph0P0QnlnZ8z4BM,1068
+taraqueue-0.2.0.dist-info/RECORD,,

{taraqueue-0.0.2.dev0.dist-info → taraqueue-0.2.0.dist-info}/entry_points.txt

@@ -3,5 +3,5 @@ taraqueue-queue = taraqueue.testing.queue
 taraqueue-services = taraqueue.testing.services
 
 [taraqueue]
-memory = taraqueue.queue:MemoryQueue
-redis = taraqueue.queue:RedisQueue
+memory = taraqueue.memory:MemoryQueue
+redis = taraqueue.redis:RedisQueue

taraqueue/queue.py

@@ -1,149 +0,0 @@
-"""Queue abstraction and implementation."""
-
-import os
-from abc import ABC, abstractmethod
-from collections import defaultdict
-from contextlib import asynccontextmanager, suppress
-from time import time
-
-from attrs import define, field
-from yarl import URL
-
-from taraqueue.registry import registry_load
-
-
-class QueueEmpty(Exception):
-    """Raised when the queue is empty."""
-
-
-@define
-class Queue(ABC):
-    """Base queue class."""
-
-    @classmethod
-    def from_url(cls, url: URL | str, registry=None) -> "Queue":
-        if registry is None:
-            registry = registry_load("taraqueue")
-        scheme = URL(url).scheme
-        queue_cls = registry["taraqueue"][scheme]
-        return queue_cls.from_url(url)
-
-    @abstractmethod
-    async def subscribe(self, topic: str) -> None:
-        """Subscribe to a topic before receiving messages."""
-
-    @abstractmethod
-    async def unsubscribe(self, topic: str) -> None:
-        """Unsubscribe from a topic after receiving messages."""
-
-    @abstractmethod
-    async def receive(self, timeout=None) -> str:
-        """Listen for messages on the subscribed topics."""
-
-    @abstractmethod
-    async def publish(self, topic: str, message: str) -> None:
-        """Publish a message to a topic."""
-
-    @asynccontextmanager
-    async def connect(self, topic: str):
-        """Context manager that subscribes on entry and unsubscribes on exit."""
-        await self.subscribe(topic)
-        try:
-            yield self
-        finally:
-            await self.unsubscribe(topic)
-
-
-_global_memory_queues = defaultdict(list)
-
-
-@define
-class MemoryQueue(Queue):
-
-    topics = field(factory=list)
-    queues = field(default=_global_memory_queues)
-
-    @classmethod
-    def from_url(cls, url: URL) -> "MemoryQueue":
-        return cls()
-
-    async def subscribe(self, topic: str) -> None:
-        """See `Queue.subscribe`."""
-        self.topics.append(topic)
-
-    async def unsubscribe(self, topic: str) -> None:
-        """See `Queue.unsubscribe`."""
-        with suppress(ValueError):
-            self.topics.remove(topic)
-
-    async def receive(self, timeout=None) -> str:
-        """See `Queue.receive`."""
-        for topic in self.topics[:]:
-            # Cycle through topics.
-            self.topics.append(self.topics.pop(0))
-            queue = self.queues[topic]
-            with suppress(IndexError):
-                return queue.pop(0)
-
-        raise QueueEmpty("Queue is empty")
-
-    async def publish(self, topic: str, message: str) -> None:
-        """See `Queue.publish`."""
-        queue = self.queues[topic]
-        queue.append(message)
-
-
-@define
-class RedisQueue(Queue):
-
-    client = field()
-    pubsub = field()
-
-    @classmethod
-    def from_env(cls, env=os.environ) -> "RedisQueue":
-        host = env.get("REDIS_SLAVEOF_IP", "") or env.get("IPV4_NETWORK", "172.22.1") + ".249"
-        port = int(env.get("REDIS_SLAVEOF_PORT", "") or "6379")
-        password = env.get("REDISPASS")
-        return cls.from_host(host, port, password=password)
-
-    @classmethod
-    def from_host(cls, host: str, port: int = 6379, password: str | None = None) -> "RedisQueue":
-        from redis.asyncio import StrictRedis
-
-        client = StrictRedis(
-            host=host,
-            port=port,
-            decode_responses=True,
-            db=0,
-            password=password,
-        )
-        pubsub = client.pubsub(ignore_subscribe_messages=True)
-        return cls(client, pubsub)
-
-    @classmethod
-    def from_url(cls, url: URL | str) -> "RedisQueue":
-        url = URL(url)
-        return cls.from_host(url.host, url.port, password=url.password)
-
-    async def subscribe(self, topic: str) -> None:
-        """See `Queue.subscribe`."""
-        await self.pubsub.subscribe(topic)
-
-    async def unsubscribe(self, topic: str) -> None:
-        """See `Queue.unsubscribe`."""
-        await self.pubsub.unsubscribe(topic)
-
-    async def receive(self, timeout=0) -> str:
-        """See `Queue.receive`."""
-        stop_time = time() + timeout
-        while True:
-            remaining_timeout = max(0.0, stop_time - time())
-            message = await self.pubsub.get_message(ignore_subscribe_messages=True, timeout=remaining_timeout)
-            if message:
-                return message["data"]
-            if time() >= stop_time:
-                raise QueueEmpty("Queue is empty")
-
-    async def publish(self, topic: str, message: str) -> None:
-        """See `Queue.publish`."""
-        await self.client.publish(topic, message)

taraqueue-0.0.2.dev0.dist-info/RECORD

@@ -1,12 +0,0 @@
-taraqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-taraqueue/queue.py,sha256=-ya3DVSLTjNQ1nmL1ltpJgPmTkdmQe2W2UHvhUGKfzI,4490
-taraqueue/registry.py,sha256=YcF9FE21HWfzoFbGGtC4GBozj-g5YbQuWdOor9XoPrU,2036
-taraqueue/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-taraqueue/testing/compose.py,sha256=wyI7dkhdXgQra0RcrYqye7RnYSv4WRSOMUVJRloKfDk,2896
-taraqueue/testing/queue.py,sha256=ryIcwE7Txeybairo6HkW9bO9mH7A6Qj9RU3YDiUpG8M,677
-taraqueue/testing/services.py,sha256=YmbsbAiX_kBVziwnNwkuvxn-82zhNE926oxF6V0SfzU,2213
-taraqueue-0.0.2.dev0.dist-info/METADATA,sha256=DScT2V7LJ2g4fdxQ22WmwsR5IDljc3qbfcXydQ9gVJM,2136
-taraqueue-0.0.2.dev0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-taraqueue-0.0.2.dev0.dist-info/entry_points.txt,sha256=IDp7ErMVJHagqZeDuawQyIxa6ZmLF9Kh3Wv3is1up6c,186
-taraqueue-0.0.2.dev0.dist-info/licenses/LICENSE.rst,sha256=aBUUonOC9jBjhQb0VIObBylPnlIVph0P0QnlnZ8z4BM,1068
-taraqueue-0.0.2.dev0.dist-info/RECORD,,