taraqueue 0.3.0__tar.gz → 0.5.0__tar.gz

{taraqueue-0.3.0 → taraqueue-0.5.0}/CHANGES.rst

@@ -1,3 +1,17 @@
+Version 0.5.0
+-------------
+
+Released 2026-05-13
+
+-   Fix MemoryQueue to behave like RedisQueue.
+
+Version 0.4.0
+-------------
+
+Released 2026-05-07
+
+-   Namespace generic pytest fixtures.
+
 Version 0.3.0
 -------------
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taraqueue
-Version: 0.3.0
+Version: 0.5.0
 Summary: Python queue abstraction layer
 Project-URL: Repository, https://github.com/taradix/taraqueue
 Author-email: Marc Tardif <marc@taram.ca>

{taraqueue-0.3.0 → taraqueue-0.5.0}/compose.yml

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

taraqueue-0.5.0/taraqueue/memory.py

@@ -0,0 +1,58 @@
+"""Memory queue implementation."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import suppress
+from dataclasses import dataclass, field
+
+from yarl import URL
+
+from taraqueue import Queue, QueueEmpty
+
+_channels: dict[str, list[asyncio.Queue[str]]] = {}
+
+
+@dataclass
+class MemoryQueue(Queue):
+    """In-process queue with fan-out semantics."""
+
+    queue: asyncio.Queue[str] = field(default_factory=asyncio.Queue)
+
+    @classmethod
+    def from_url(cls, url: URL) -> MemoryQueue:
+        return cls()
+
+    async def subscribe(self, topic: str) -> None:
+        """See `Queue.subscribe`."""
+        subscribers = _channels.setdefault(topic, [])
+        if self.queue in subscribers:
+            return
+        subscribers.append(self.queue)
+
+    async def unsubscribe(self, topic: str) -> None:
+        """See `Queue.unsubscribe`."""
+        subscribers = _channels.get(topic)
+        if subscribers is None:
+            return
+        with suppress(ValueError):
+            subscribers.remove(self.queue)
+        if not subscribers:
+            _channels.pop(topic, None)
+
+    async def receive(self, timeout=None) -> str:
+        """See `Queue.receive`."""
+        if not timeout:
+            try:
+                return self.queue.get_nowait()
+            except asyncio.QueueEmpty as e:
+                raise QueueEmpty("Queue is empty") from e
+        try:
+            return await asyncio.wait_for(self.queue.get(), timeout=float(timeout))
+        except TimeoutError as e:
+            raise QueueEmpty("Timed out waiting for message") from e
+
+    async def publish(self, topic: str, message: str) -> None:
+        """See `Queue.publish`."""
+        for q in list(_channels.get(topic, [])):
+            await q.put(message)

{taraqueue-0.3.0 → taraqueue-0.5.0}/taraqueue/redis.py

@@ -1,15 +1,20 @@
 """Redis queue implementation."""
 
+from __future__ import annotations
+
 import os
 from dataclasses import dataclass, field
 from time import time
+from typing import TYPE_CHECKING
 
-from redis.asyncio import Redis
-from redis.asyncio.client import PubSub
 from yarl import URL
 
 from taraqueue import Queue, QueueEmpty
 
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+    from redis.asyncio.client import PubSub
+
 
 @dataclass
 class RedisQueue(Queue):
@@ -18,14 +23,14 @@ class RedisQueue(Queue):
     pubsub: PubSub = field()
 
     @classmethod
-    def from_env(cls, env=os.environ) -> "RedisQueue":
+    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":
+    def from_host(cls, host: str, port: int = 6379, password: str | None = None) -> RedisQueue:
         from redis.asyncio import StrictRedis
 
         client = StrictRedis(
@@ -39,7 +44,7 @@ class RedisQueue(Queue):
         return cls(client, pubsub)
 
     @classmethod
-    def from_url(cls, url: URL | str) -> "RedisQueue":
+    def from_url(cls, url: URL | str) -> RedisQueue:
         url = URL(url)
         return cls.from_host(url.host, url.port, password=url.password)
 

{taraqueue-0.3.0 → taraqueue-0.5.0}/taraqueue/testing/queue.py

@@ -14,13 +14,13 @@ def memory_queue():
 
 
 @pytest.fixture
-def redis_queue(redis_service, env_vars):
+def redis_queue(redis_service, taraqueue_env_vars):
     """Redis queue fixture."""
     url = URL.build(
         scheme="redis",
         host=redis_service.ip,
         port=6379,
-        password=env_vars["REDIS_PASSWORD"],
+        password=taraqueue_env_vars["REDIS_PASSWORD"],
     )
     return Queue.from_url(url)
 

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

@@ -1,6 +1,5 @@
 """Service fixtures."""
 
-from functools import partial
 from pathlib import Path
 
 import pytest
@@ -9,35 +8,31 @@ from taraqueue.testing.compose import ComposeServer
 
 
 @pytest.fixture(scope="session")
-def project():
-    return "test"
-
-
-@pytest.fixture(scope="session")
-def env_vars(project):
+def taraqueue_env_vars():
     """Environment variables for the services."""
     return {
-        "COMPOSE_PROJECT_NAME": project,
+        "COMPOSE_PROJECT_NAME": "test",
         "REDIS_PASSWORD": "test",
     }
 
 
 @pytest.fixture(scope="session")
-def env_file(env_vars, request):
-    """Environment file containing `env_vars`.
+def taraqueue_env_file(taraqueue_env_vars, request):
+    """Environment file containing `taraqueue_env_vars`.
 
     Cached for troubleshooting purposes.
     """
     env_file = request.config.cache.makedir("compose") / "env"
     with env_file.open("w") as f:
-        for k, v in env_vars.items():
+        for k, v in taraqueue_env_vars.items():
             f.write(f"{k}={v}\n")
 
     return env_file
 
 
 @pytest.fixture(scope="session")
-def compose_files(request):
+def taraqueue_compose_files(request):
+    """Use the compose files from the project - not this library."""
     directory = Path(request.config.rootdir)
     filenames = ["docker-compose.yml", "compose.yaml", "compose.yml"]
     while True:
@@ -55,26 +50,20 @@ def compose_files(request):
 
 
 @pytest.fixture(scope="session")
-def compose_server(project, env_file, compose_files, process):
-    return partial(
-        ComposeServer,
-        project=project,
-        env_file=env_file,
-        compose_files=compose_files,
+def redis_service(process, taraqueue_env_file, taraqueue_compose_files):
+    """Redis service fixture."""
+    server = ComposeServer(
+        pattern="Ready to accept connections tcp",
+        env_file=taraqueue_env_file,
+        compose_files=taraqueue_compose_files,
         process=process,
     )
-
-
-@pytest.fixture(scope="session")
-def redis_service(compose_server):
-    """Redis service fixture."""
-    server = compose_server("Ready to accept connections tcp")
     with server.run("redis") as service:
         yield service
 
 
 @pytest.fixture(scope="session")
-def redis_client(redis_service, env_vars):
+def redis_client(redis_service, taraqueue_env_vars):
     """Redis client to the service fixture."""
     from redis import StrictRedis
 
@@ -83,5 +72,5 @@ def redis_client(redis_service, env_vars):
         port=6379,
         decode_responses=True,
         db=0,
-        password=env_vars["REDIS_PASSWORD"],
+        password=taraqueue_env_vars["REDIS_PASSWORD"],
     )

taraqueue-0.5.0/tests/test_queue.py

@@ -0,0 +1,75 @@
+"""Integration tests for the queue module."""
+
+
+import pytest
+
+from taraqueue import Queue, QueueEmpty
+
+
+async def test_queue_send_receive(queue, unique):
+    """Sending a message to a queue should be the next received message."""
+    topic = unique("text")
+    async with queue.connect(topic) as session:
+        await session.publish(topic, "test")
+        result = await session.receive(5)
+    assert result == "test"
+
+
+async def test_queue_receive_empty(queue, unique):
+    """Receiving from an empty queue should raise a QueueEmpty error."""
+    topic = unique("text")
+    async with queue.connect(topic) as session:
+        with pytest.raises(QueueEmpty):
+            await session.receive()
+
+
+async def test_queue_two_subscribers_both_receive(unique):
+    """Every active subscriber should independently receive each published message.
+
+    This verifies fan-out semantics: two separate Queue instances subscribed to
+    the same channel both receive the message, rather than one consuming it and
+    the other seeing nothing.
+    """
+    topic = unique("text")
+    sub1 = Queue.from_url("memory://")
+    sub2 = Queue.from_url("memory://")
+    publisher = Queue.from_url("memory://")
+
+    async with sub1.connect(topic), sub2.connect(topic):
+        await publisher.publish(topic, "hello")
+        msg1 = await sub1.receive(timeout=5)
+        msg2 = await sub2.receive(timeout=5)
+
+    assert msg1 == "hello"
+    assert msg2 == "hello"
+
+
+async def test_queue_subscribe_two_topics_receives_from_both(unique):
+    """A single subscriber connected to two topics should receive from either."""
+    topic_a = unique("text")
+    topic_b = unique("text")
+    sub = Queue.from_url("memory://")
+    publisher = Queue.from_url("memory://")
+
+    async with sub.connect(topic_a), sub.connect(topic_b):
+        await publisher.publish(topic_a, "from-a")
+        await publisher.publish(topic_b, "from-b")
+        msg1 = await sub.receive(timeout=5)
+        msg2 = await sub.receive(timeout=5)
+
+    assert {msg1, msg2} == {"from-a", "from-b"}
+
+    """A subscriber that connects after a publish should not receive that message.
+
+    This matches Redis pub/sub behaviour: messages are only delivered to
+    subscribers that are active at the moment of publishing.
+    """
+    topic = unique("text")
+    publisher = Queue.from_url("memory://")
+    late_sub = Queue.from_url("memory://")
+
+    await publisher.publish(topic, "early")
+
+    async with late_sub.connect(topic):
+        with pytest.raises(QueueEmpty):
+            await late_sub.receive()

taraqueue-0.5.0/tests/test_redis.py

@@ -0,0 +1,6 @@
+"""Integration tests for the Redis service."""
+
+
+def test_redis_service(redis_client):
+    """The Redis service should return true on PING."""
+    assert redis_client.ping()