taraqueue 0.0.2.dev0__tar.gz → 0.2.0__tar.gz

{taraqueue-0.0.2.dev0 → taraqueue-0.2.0}/.github/actions/setup-uv-env/action.yml

@@ -14,6 +14,10 @@ inputs:
     required: false
     description: "Include optional dependencies"
     default: ""
+  sync:
+    required: false
+    description: "Run uv sync"
+    default: "true"
   working-directory:
     required: false
     description: "Working directory"
@@ -36,6 +40,7 @@ runs:
         enable-cache: true
 
     - name: Install dependencies
+      if: ${{ inputs.sync == 'true' }}
       shell: bash
       working-directory: ${{ inputs.working-directory }}
       run: |

{taraqueue-0.0.2.dev0 → taraqueue-0.2.0}/.github/workflows/publish.yml

@@ -1,10 +1,9 @@
 name: Publish
 
 on:
-  release:
-    types: [published]
-    branches: [main]
-  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
 
 permissions:
   contents: write
@@ -21,6 +20,8 @@ jobs:
 
       - name: Set up the environment
         uses: ./.github/actions/setup-uv-env
+        with:
+          sync: "false"
 
       - name: Build
         run: uv build

{taraqueue-0.0.2.dev0 → taraqueue-0.2.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.2.0/CHANGES.rst

@@ -0,0 +1,13 @@
+Version 0.2.0
+-------------
+
+Released 2026-05-04
+
+-   Split implementations.
+
+Version 0.1.0
+-------------
+
+Released 2026-05-01
+
+-   Initial release.

{taraqueue-0.0.2.dev0 → taraqueue-0.2.0}/PKG-INFO

@@ -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.0.2.dev0 → taraqueue-0.2.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.2.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.0.2.dev0 → taraqueue-0.2.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"]
@@ -58,6 +57,7 @@ source = "vcs"
 
 [tool.hatch.version.raw-options]
 local_scheme = "no-local-version"
+tag_regex = "^v(?P<version>\\d+\\.\\d+\\.\\d+)$"
 
 [tool.ruff]
 target-version = "py312"

taraqueue-0.2.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.2.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.2.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("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 → taraqueue-0.2.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.0.2.dev0 → taraqueue-0.2.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

{taraqueue-0.0.2.dev0 → taraqueue-0.2.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):

{taraqueue-0.0.2.dev0 → taraqueue-0.2.0}/uv.lock

@@ -859,7 +859,6 @@ wheels = [
 name = "taraqueue"
 source = { editable = "." }
 dependencies = [
-    { name = "attrs" },
     { name = "yarl" },
 ]
 
@@ -887,7 +886,6 @@ test = [
 
 [package.metadata]
 requires-dist = [
-    { name = "attrs", specifier = ">=26.1.0" },
     { name = "coverage", marker = "extra == 'test'", specifier = ">=7.2.3,<8.0.0" },
     { name = "more-itertools", marker = "extra == 'test'", specifier = ">=11.0.1,<11.1.0" },
     { name = "pytest", marker = "extra == 'test'", specifier = ">=9.0.0,<10.0.0" },

taraqueue-0.0.2.dev0/CHANGES.rst

@@ -1,6 +0,0 @@
-Version 0.1.0
--------------
-
-Released 2026-05-01
-
--   Initial release.

taraqueue-0.0.2.dev0/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)