ltq 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

ltq-0.3.2.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.3
+Name: ltq
+Version: 0.3.2
+Summary: Add your description here
+Author: Tom Clesius
+Author-email: Tom Clesius <tomclesius@gmail.com>
+Requires-Dist: redis>=7.1.0
+Requires-Dist: croniter>=6.0.0 ; extra == 'scheduler'
+Requires-Dist: sentry-sdk>=2.0.0 ; extra == 'sentry'
+Requires-Python: >=3.13
+Provides-Extra: scheduler
+Provides-Extra: sentry
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/tclesius/ltq/refs/heads/main/assets/logo.png" alt="LTQ" width="400">
+</p>
+
+<p align="center">
+  A lightweight, Async-first task queue built on Redis.
+</p>
+
+## Installation
+
+```bash
+pip install ltq
+# or
+uv add ltq
+```
+
+## Broker Backends
+
+LTQ supports multiple broker backends:
+
+- **Redis** (default): `broker_url="redis://localhost:6379"`
+- **Memory**: `broker_url="memory://"` (useful for testing)
+
+All workers and schedulers accept a `broker_url` parameter.
+
+## Quick Start
+
+```python
+import asyncio
+import ltq
+
+worker = ltq.Worker("emails", broker_url="redis://localhost:6379")
+
+@worker.task()
+async def send_email(to: str, subject: str, body: str) -> None:
+    # your async code here
+    pass
+
+async def main():
+    # Enqueue a task
+    await send_email.send("user@example.com", "Hello", "World")
+
+    # Or enqueue multiple tasks
+    for email in ["a@example.com", "b@example.com"]:
+        await send_email.send(email, "Hi", "Message")
+
+asyncio.run(main())
+```
+
+Each worker has a namespace (e.g., `"emails"`), and tasks are automatically namespaced as `{namespace}:{function_name}`.
+
+## Running Workers
+
+```bash
+# Run a single worker
+ltq run myapp:worker
+
+# With options
+ltq run myapp:worker --concurrency 100 --log-level DEBUG
+```
+
+## Running an App
+
+Register multiple workers into an `App` to run them together:
+
+```python
+import ltq
+
+app = ltq.App()
+app.register_worker(emails_worker)
+app.register_worker(notifications_worker)
+```
+
+```bash
+ltq run --app myapp:app
+```
+
+### App Middleware
+
+Apply middleware globally to all workers in an app:
+
+```python
+from ltq.middleware import Sentry
+
+app = ltq.App(middlewares=[Sentry(dsn="https://...")])
+
+# Or register after creation
+app.register_middleware(Sentry(dsn="https://..."))
+app.register_middleware(MyMiddleware(), pos=0)
+
+# When workers are registered, app middlewares are prepended to each worker's stack
+app.register_worker(emails_worker)
+```
+
+### Threading Model
+
+By default, `App` runs each worker in its own thread with a separate event loop. This provides isolation between workers while keeping them in the same process. Workers won't block each other since each has its own async event loop.
+
+**For maximum isolation** (separate memory, crash protection), run each worker in its own process:
+
+```bash
+# Terminal 1
+ltq run myapp:emails_worker
+
+# Terminal 2
+ltq run myapp:notifications_worker
+```
+
+This gives you full process isolation at the cost of more overhead.
+
+## Queue Management
+
+Manage queues using the CLI:
+
+```bash
+# Clear a task queue
+ltq clear emails:send_email
+
+# Get queue size
+ltq size emails:send_email
+
+# With custom Redis URL
+ltq clear emails:send_email --redis-url redis://localhost:6380
+ltq size emails:send_email --redis-url redis://localhost:6380
+```
+
+Queue names are automatically namespaced as `{worker_name}:{function_name}`.
+
+## Scheduler
+
+Run tasks on a cron schedule (requires `ltq[scheduler]`):
+
+```python
+import ltq
+
+scheduler = ltq.Scheduler()
+scheduler.cron("*/5 * * * *", send_email.message("admin@example.com", "Report", "..."))
+scheduler.start()  # Runs scheduler in blocking mode with asyncio.run()
+```
+
+## Task Options
+
+Configure task behavior with options:
+
+```python
+from datetime import timedelta
+
+@worker.task(max_tries=3, max_age=timedelta(hours=1), max_rate="10/s")
+async def send_email(to: str, subject: str, body: str) -> None:
+    # your async code here
+    pass
+```
+
+**Available options:**
+
+- `max_tries` (int): Maximum retry attempts before rejecting the message
+- `max_age` (timedelta): Maximum message age before rejection
+- `max_rate` (str): Rate limit in format `"N/s"`, `"N/m"`, or `"N/h"` (requests per second/minute/hour)
+
+## Middleware
+
+Middleware are async context managers that wrap task execution. The default stack is `[MaxTries(), MaxAge(), MaxRate()]`, so you only need to specify middlewares if you want to customize or add additional ones:
+
+```python
+from ltq.middleware import MaxTries, MaxAge, MaxRate, Sentry
+
+worker = ltq.Worker(
+    "emails",
+    broker_url="redis://localhost:6379",
+    middlewares=[
+        MaxTries(),
+        MaxAge(),
+        MaxRate(),
+        Sentry(dsn="https://..."),
+    ],
+)
+```
+
+**Built-in:** `MaxTries`, `MaxAge`, `MaxRate`, `Sentry` (requires `ltq[sentry]`)
+
+You can also register middleware after creating the worker:
+
+```python
+worker.register_middleware(Sentry(dsn="https://..."))
+
+# Insert at specific position (default is -1 for append)
+worker.register_middleware(MyMiddleware(), pos=0)
+```
+
+**Custom middleware:**
+
+```python
+from contextlib import asynccontextmanager
+from ltq.middleware import Middleware
+from ltq.message import Message
+from ltq.task import Task
+
+class Logger(Middleware):
+    @asynccontextmanager
+    async def __call__(self, message: Message, task: Task):
+        print(f"Processing {message.task_name}")
+        yield
+        print(f"Completed {message.task_name}")
+```

ltq-0.3.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+ltq/__init__.py,sha256=dMoQtB1-odVRCDWDijNft-DlCverh8y83iQd-hDJxhw,491
+ltq/app.py,sha256=l045sTXKHQo-pv5JDi8pE90wHGoCX7vsxrTQZIx7o5s,1335
+ltq/broker.py,sha256=oNZwmugFHB2PbdDiLt4db4MYUxwNOhdOIDto4vLb8uU,4062
+ltq/cli.py,sha256=8pt6_aP6RFi0Xi2garzefOlsBuPRXuJjpu_-ohG-__o,5282
+ltq/errors.py,sha256=Oo6fVTFoNhO7xlXJLj4NwBBD4UsrYU_f4msoeS2GsM0,320
+ltq/logger.py,sha256=XEcjvuZz_drfVyKAQj4r1Dz-gRwZcffkN_xTLg_h4hk,2088
+ltq/message.py,sha256=vkF17yfTE7sWjqsn5PE9LpGh6FOIlwOJLS4OZ4iGD5k,829
+ltq/middleware.py,sha256=uHNCJoohgHnPV2cPbaKOL0i-wU9D8WIhfoc07c78ve4,3475
+ltq/scheduler.py,sha256=FauNClAN-N7A6hUCBI0oAGe8at1fohDLzXuFI1hF1-I,3111
+ltq/task.py,sha256=0JUY55JezhrtUvAiZLtRPMap77nua09-D3S5VdOA9uY,944
+ltq/utils.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+ltq/worker.py,sha256=6RPiNgPiJmdX38p8Iw_xpbExhYvE5VKqV_g-oC_nctc,3921
+ltq-0.3.2.dist-info/WHEEL,sha256=iHtWm8nRfs0VRdCYVXocAWFW8ppjHL-uTJkAdZJKOBM,80
+ltq-0.3.2.dist-info/entry_points.txt,sha256=OogYaOJ_RORrWtrLlEL_gTN9Vx5tkgawl8BO7G9FKcg,38
+ltq-0.3.2.dist-info/METADATA,sha256=8PubjxCurEHvtFF4L7enJM7D9OF65Tg0exeUd_Tt2rY,5326
+ltq-0.3.2.dist-info/RECORD,,

{ltq-0.3.1.dist-info → ltq-0.3.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.27
+Generator: uv 0.9.30
 Root-Is-Purelib: true
 Tag: py3-none-any

ltq/q.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from typing import TYPE_CHECKING
-
-from .message import Message
-
-if TYPE_CHECKING:
-    from redis.asyncio import Redis
-
-
-class Queue:
-    _GET_SCRIPT = """
-        local items = {}
-        for i = 1, ARGV[1] do
-            local item = redis.call("RPOP", KEYS[1])
-            if not item then break end
-            table.insert(items, item)
-        end
-        for i = 1, #items, 5000 do
-            local chunk = {unpack(items, i, math.min(i + 4999, #items))}
-            redis.call("SADD", KEYS[2], unpack(chunk))
-        end
-        return items
-    """
-
-    def __init__(self, client: Redis, name: str) -> None:
-        self.client = client
-        self.name = name
-        self.queue_key = f"queue:{name}"
-        self.processing_key = f"queue:{name}:processing"
-        self._get = client.register_script(self._GET_SCRIPT)
-
-    @staticmethod
-    def _serialize(messages: list[Message]) -> list[str]:
-        return [msg.to_json() for msg in messages]
-
-    async def put(
-        self,
-        messages: list[Message],
-        delay: float = 0.0,
-        ttl: int | None = None,
-    ) -> None:
-        if not messages:
-            return
-        if delay > 0:
-            await asyncio.sleep(delay)
-        pipe = self.client.pipeline()
-        for item in self._serialize(messages):
-            pipe.lpush(self.queue_key, item)
-        if ttl:
-            pipe.expire(self.queue_key, ttl)
-        await pipe.execute()  # type: ignore
-
-    async def get(self, count: int) -> list[Message]:
-        results = await self._get(
-            keys=[self.queue_key, self.processing_key],
-            args=[count],
-        )  # type: ignore
-        return [Message.from_json(r) for r in results]
-
-    async def ack(self, messages: list[Message]) -> None:
-        if not messages:
-            return
-        items = self._serialize(messages)
-        await self.client.srem(self.processing_key, *items)  # type: ignore
-
-    async def nack(self, messages: list[Message]) -> None:
-        if not messages:
-            return
-        items = self._serialize(messages)
-        pipe = self.client.pipeline()
-        pipe.srem(self.processing_key, *items)
-        for item in items:
-            pipe.lpush(self.queue_key, item)
-        await pipe.execute()  # type: ignore
-
-    async def len(self) -> int:
-        return await self.client.llen(self.queue_key)  # type: ignore
-
-    async def clear(self) -> None:
-        await self.client.delete(self.queue_key, self.processing_key)  # type: ignore

ltq-0.3.1.dist-info/METADATA

@@ -1,137 +0,0 @@
-Metadata-Version: 2.3
-Name: ltq
-Version: 0.3.1
-Summary: Add your description here
-Author: Tom Clesius
-Author-email: Tom Clesius <tomclesius@gmail.com>
-Requires-Dist: redis>=7.1.0
-Requires-Dist: croniter>=6.0.0 ; extra == 'scheduler'
-Requires-Dist: sentry-sdk>=2.0.0 ; extra == 'sentry'
-Requires-Python: >=3.13
-Provides-Extra: scheduler
-Provides-Extra: sentry
-Description-Content-Type: text/markdown
-
-<p align="center">
-  <img src="https://raw.githubusercontent.com/tclesius/ltq/refs/heads/main/assets/logo.png" alt="LTQ" width="400">
-</p>
-
-<p align="center">
-  A lightweight, Async-first task queue built on Redis.
-</p>
-
-## Installation
-
-```bash
-pip install ltq
-# or
-uv add ltq
-```
-
-## Quick Start
-
-```python
-import asyncio
-import ltq
-
-worker = ltq.Worker(url="redis://localhost:6379")
-
-@worker.task()
-async def send_email(to: str, subject: str, body: str) -> None:
-    # your async code here
-    pass
-
-async def main():
-    # Enqueue a task
-    await send_email.send("user@example.com", "Hello", "World")
-
-    # Or dispatch in bulk
-    messages = [
-        send_email.message("a@example.com", "Hi", "A"),
-        send_email.message("b@example.com", "Hi", "B"),
-    ]
-    await ltq.dispatch(messages)
-
-asyncio.run(main())
-```
-
-Each task gets its own queue by default. To share a queue between tasks, pass `queue_name`:
-
-```python
-@worker.task(queue_name="emails")
-async def send_email(...): ...
-
-@worker.task(queue_name="emails")
-async def send_newsletter(...): ...
-```
-
-## Running Workers
-
-```bash
-# Run a single worker
-ltq myapp:worker
-
-# With options
-ltq myapp:worker --concurrency 100 --log-level DEBUG
-```
-
-## Running an App
-
-Register multiple workers into an `App` to run them together:
-
-```python
-import ltq
-
-app = ltq.App()
-app.register_worker(emails_worker)
-app.register_worker(notifications_worker)
-```
-
-```bash
-ltq --app myapp:app
-```
-
-## Scheduler
-
-Run tasks on a cron schedule (requires `ltq[scheduler]`):
-
-```python
-import ltq
-
-scheduler = ltq.Scheduler()
-scheduler.cron("*/5 * * * *", send_email.message("admin@example.com", "Report", "..."))
-scheduler.run()
-```
-
-## Middleware
-
-Add middleware to handle cross-cutting concerns:
-
-```python
-from ltq.middleware import Retry, RateLimit, Timeout
-
-worker = ltq.Worker(
-    url="redis://localhost:6379",
-    middlewares=[
-        Retry(max_retries=3, min_delay=1.0),
-        RateLimit(requests_per_second=10),
-        Timeout(timeout=30.0),
-    ],
-)
-```
-
-**Built-in:** `Retry`, `RateLimit`, `Timeout`, `Sentry` (requires `ltq[sentry]`)
-
-**Custom middleware:**
-
-```python
-from ltq.middleware import Middleware, Handler
-from ltq.message import Message
-
-class Logger(Middleware):
-    async def handle(self, message: Message, next_handler: Handler):
-        print(f"Processing {message.task}")
-        result = await next_handler(message)
-        print(f"Completed {message.task}")
-        return result
-```

ltq-0.3.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-ltq/__init__.py,sha256=yZ65BhEtoQApFCOPWCL5_5b2rAIfBkw6XW5ppSpurW0,355
-ltq/app.py,sha256=PI9Zti37qpgYVzLRIbRoAMmhJ3wLdIY05bTQCkUzehA,316
-ltq/cli.py,sha256=JD_iHStkP2WuVlOz0L90Sako-oHPafTzV08INDJsHio,3219
-ltq/errors.py,sha256=i9kXtSVMpam_0VpyL5eaSfBwkGF6dK7xouAcLdc_eNc,324
-ltq/logger.py,sha256=HPClhDt3ecwZqE0Vq2oYF8Nr9jj-xrsSX9tM6enVgkA,1791
-ltq/message.py,sha256=hY_oPNMicSICV9-_o8Rma_kJO3DGJu_PFxyt1xZKMJE,871
-ltq/middleware.py,sha256=xy4VXy8uXp0vBMhdD6aSOQdzwCdbUkcuFw7FwPsqabU,3641
-ltq/q.py,sha256=3jRlPZKO4Zd5IYnb24jO_oRHtHBbG1la5SCZPI6QLI4,2537
-ltq/scheduler.py,sha256=6l53-Hf-2sURxTEpY1MOM5z18slQTl4450f-aLHF1sY,2516
-ltq/task.py,sha256=ZKKag4u9k9hQ-lNdIWZygmGCc01DRt8a6kMQlQr_yaw,1000
-ltq/utils.py,sha256=M7EWJ-n9J3MMwofWwtxVkwgHmGeP66eoWuWDhjbx67k,536
-ltq/worker.py,sha256=WIxLBCZYaVH_KVdexx77J607EEfQm1OKdtjmzCirvPM,3344
-ltq-0.3.1.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-ltq-0.3.1.dist-info/entry_points.txt,sha256=OogYaOJ_RORrWtrLlEL_gTN9Vx5tkgawl8BO7G9FKcg,38
-ltq-0.3.1.dist-info/METADATA,sha256=WJzVlmvsEHVuUl4HovJ9Ip1EU2HERuarIcGpfcpOKAc,2863
-ltq-0.3.1.dist-info/RECORD,,