taraqueue 0.1.0__tar.gz → 0.3.0__tar.gz

{taraqueue-0.1.0 → taraqueue-0.3.0}/.github/workflows/publish.yml

@@ -41,7 +41,7 @@ jobs:
       - name: Set up the environment
         uses: ./.github/actions/setup-uv-env
         with:
-          extras: docs
+          extras: docs,test
 
       - name: Export tag
         id: vars

{taraqueue-0.1.0 → taraqueue-0.3.0}/.github/workflows/test.yml

@@ -88,7 +88,7 @@ jobs:
       - name: Set up the environment
         uses: ./.github/actions/setup-uv-env
         with:
-          extras: docs
+          extras: docs,test
 
       - name: Run docs target
         run: make docs

taraqueue-0.3.0/CHANGES.rst

@@ -0,0 +1,20 @@
+Version 0.3.0
+-------------
+
+Released 2026-05-04
+
+-   Rename REDISPASS to REDIS_PASSWORD.
+
+Version 0.2.0
+-------------
+
+Released 2026-05-04
+
+-   Split implementations.
+
+Version 0.1.0
+-------------
+
+Released 2026-05-01
+
+-   Initial release.

{taraqueue-0.1.0 → taraqueue-0.3.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: taraqueue
-Version: 0.1.0
+Version: 0.3.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.3.0/compose.yml

@@ -0,0 +1,4 @@
+services:
+  redis:
+    image: redis:8.6.2-alpine
+    command: redis-server --requirepass ${REDIS_PASSWORD:-test}

{taraqueue-0.1.0 → taraqueue-0.3.0}/docs/taraqueue.rst

@@ -1,13 +1,29 @@
 taraqueue package
 =================
 
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   taraqueue.testing
+
 Submodules
 ----------
 
-taraqueue.queue module
+taraqueue.memory module
+-----------------------
+
+.. automodule:: taraqueue.memory
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+taraqueue.redis module
 ----------------------
 
-.. automodule:: taraqueue.queue
+.. automodule:: taraqueue.redis
    :members:
    :show-inheritance:
    :undoc-members:

taraqueue-0.3.0/docs/taraqueue.testing.rst

@@ -0,0 +1,37 @@
+taraqueue.testing package
+=========================
+
+Submodules
+----------
+
+taraqueue.testing.compose module
+--------------------------------
+
+.. automodule:: taraqueue.testing.compose
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+taraqueue.testing.queue module
+------------------------------
+
+.. automodule:: taraqueue.testing.queue
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+taraqueue.testing.services module
+---------------------------------
+
+.. automodule:: taraqueue.testing.services
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+Module contents
+---------------
+
+.. automodule:: taraqueue.testing
+   :members:
+   :show-inheritance:
+   :undoc-members:

{taraqueue-0.1.0 → taraqueue-0.3.0}/pyproject.toml

@@ -8,7 +8,6 @@ authors = [
 readme = "README.rst"
 requires-python = ">=3.12,<4.0"
 dependencies = [
-    "attrs>=26.1.0",
     "yarl>=1.23.0",
 ]
 
@@ -46,8 +45,8 @@ taraqueue-services = "taraqueue.testing.services"
 taraqueue-queue = "taraqueue.testing.queue"
 
 [project.entry-points."taraqueue"]
-memory = "taraqueue.queue:MemoryQueue"
-redis = "taraqueue.queue:RedisQueue"
+memory = "taraqueue.memory:MemoryQueue"
+redis = "taraqueue.redis:RedisQueue"
 
 [build-system]
 requires = ["hatchling", "hatch-vcs"]

taraqueue-0.3.0/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-0.3.0/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-0.3.0/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("REDIS_PASSWORD")
+        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.1.0 → taraqueue-0.3.0}/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-0.1.0 → taraqueue-0.3.0}/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
@@ -20,7 +20,7 @@ def redis_queue(redis_service, env_vars):
         scheme="redis",
         host=redis_service.ip,
         port=6379,
-        password=env_vars["REDISPASS"],
+        password=env_vars["REDIS_PASSWORD"],
     )
     return Queue.from_url(url)
 

{taraqueue-0.1.0 → taraqueue-0.3.0}/taraqueue/testing/services.py

@@ -18,7 +18,7 @@ def env_vars(project):
     """Environment variables for the services."""
     return {
         "COMPOSE_PROJECT_NAME": project,
-        "REDISPASS": "test",
+        "REDIS_PASSWORD": "test",
     }
 
 
@@ -83,5 +83,5 @@ def redis_client(redis_service, env_vars):
         port=6379,
         decode_responses=True,
         db=0,
-        password=env_vars["REDISPASS"],
+        password=env_vars["REDIS_PASSWORD"],
     )

{taraqueue-0.1.0 → taraqueue-0.3.0}/tests/test_queue.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from taraqueue.queue import QueueEmpty
+from taraqueue import QueueEmpty
 
 
 async def test_queue_send_receive(queue, unique):