rrq 0.3.7__tar.gz → 0.5.0__tar.gz

rrq-0.5.0/.claude/settings.local.json

@@ -0,0 +1,17 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(grep:*)",
+      "Bash(uv run pytest:*)",
+      "Bash(mkdir:*)",
+      "Bash(mv:*)",
+      "Bash(python -m pytest tests/test_worker.py::test_worker_handles_job_failure_max_retries_dlq -xvs)",
+      "Bash(rg:*)",
+      "Bash(uv run:*)",
+      "Bash(ruff format:*)",
+      "Bash(ruff check:*)"
+    ],
+    "deny": []
+  }
+}

rrq-0.5.0/CLAUDE.md

@@ -0,0 +1,115 @@
+---
+description: RRQ Development Guidelines
+globs: ["**/*", "!tests/**/*"]
+alwaysApply: true
+---
+# RRQ Development Guidelines
+
+## Project Overview
+
+**Important**: Also refer to:
+- `tests/CLAUDE.md` - Testing guidelines
+- `README.md` - Project setup and overview
+
+## Quick Start Commands
+```bash
+# Backend
+uv run pytest             # Running tests
+ruff check                # Lint backend code
+ruff format               # Format backend code
+
+# Package Management
+uv add package_name        # Add dependency
+uv sync --extra dev        # Sync dependencies
+```
+
+## Code References Format
+**CRITICAL**: Always use VS Code clickable format for code references:
+- `app/api/users.py:45` - Single line
+- `app/models/job.py:120-135` - Line range
+- Always use paths relative to project root
+
+### Python Code Style
+- Python 3.10+ with comprehensive type hints
+- Double quotes for strings
+- Max line length: 88 characters
+- PEP 8 naming: `snake_case` functions, `PascalCase` classes
+- Pydantic V2 for data validation
+- Import order: stdlib → third-party → local
+- Docstrings for public interfaces
+- Type annotations for all function signatures
+
+### Code Quality Practices
+- Early returns over nested conditions
+- Small, focused functions (single responsibility)
+- Descriptive variable names
+- Comprehensive error handling with specific exceptions
+- Consistent async/await patterns
+- Use `match/case` for complex conditionals
+
+## Self-Review Checklist for Large Changes
+
+Before submitting significant backend changes:
+
+### Code Quality
+- [ ] All functions have type hints
+- [ ] Complex logic is well-commented
+- [ ] No debug prints or commented code
+- [ ] Follows existing patterns in codebase
+- [ ] Proper error handling throughout
+- [ ] Idiomatic code using Python, Asyncio, and Pydantic best practices
+
+### Testing
+- [ ] Unit tests for new functionality
+- [ ] Integration tests for API changes
+- [ ] All tests pass with `--warnings-as-errors`
+- [ ] Edge cases covered
+- [ ] Mocked external dependencies
+
+### Performance
+- [ ] Database queries are optimized (N+1 prevention)
+- [ ] Async operations are properly awaited
+- [ ] No blocking I/O in async contexts
+- [ ] Background jobs for heavy operations
+
+### Security
+- [ ] Input validation on all endpoints
+- [ ] No sensitive data in logs
+- [ ] SQL injection prevention
+
+### Documentation
+- [ ] API endpoints documented
+- [ ] Complex functions have docstrings
+- [ ] Schema changes documented
+- [ ] Migration files created if needed
+
+## Linting and Pre-commit
+
+**Always run before committing:**
+```bash
+# Format and lint
+ruff format 
+ruff check  --fix
+
+```
+
+## Important Development Rules
+
+1. **Never commit broken tests** - Fix root causes
+2. **Ask before large changes** - Especially cross-domain
+3. **Follow existing patterns** - Check similar code first
+4. **Quality over speed** - Do it right the first time
+5. **Security first** - Never expose sensitive data
+
+## Performance Considerations
+- Profile before optimizing
+- Use async correctly (no sync in async)
+- Cache expensive operations
+- Paginate large result sets
+- Monitor query performance
+
+## Debugging Tips
+- Use `uv run pytest --maxfail=1` for failing tests
+- Use debugger with `import pdb; pdb.set_trace()`
+
+Remember: If unsure about implementation, check existing code patterns first!

{rrq-0.3.7 → rrq-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rrq
-Version: 0.3.7
+Version: 0.5.0
 Summary: RRQ is a Python library for creating reliable job queues using Redis and asyncio
 Project-URL: Homepage, https://github.com/getresq/rrq
 Project-URL: Bug Tracker, https://github.com/getresq/rrq/issues
@@ -20,7 +20,7 @@ Requires-Dist: pydantic>=2.11.4
 Requires-Dist: redis[hiredis]<6,>=4.2.0
 Requires-Dist: watchfiles>=0.19.0
 Provides-Extra: dev
-Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.0.0; extra == 'dev'
 Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.5; extra == 'dev'
 Description-Content-Type: text/markdown
@@ -40,6 +40,7 @@ RRQ is a Python library for creating reliable job queues using Redis and `asynci
 *   **Graceful Shutdown**: Workers listen for SIGINT/SIGTERM and attempt to finish active jobs within a grace period before exiting. Interrupted jobs are re-queued.
 *   **Worker Health Checks**: Workers periodically update a health key in Redis with a TTL, allowing monitoring systems to track active workers.
 *   **Deferred Execution**: Jobs can be scheduled to run at a future time using `_defer_by` or `_defer_until`.
+*   **Cron Jobs**: Periodic jobs can be defined in `RRQSettings.cron_jobs` using a simple cron syntax.
 
     - Using deferral with a specific `_job_id` will effectively reschedule the job associated with that ID to the new time, overwriting its previous definition and score. It does not create multiple distinct scheduled jobs with the same ID.
 
@@ -138,6 +139,125 @@ if __name__ == "__main__":
 
 You can run multiple instances of `worker_script.py` for concurrent processing.
 
+## Cron Jobs
+
+Add instances of `CronJob` to `RRQSettings.cron_jobs` to run periodic jobs. The
+`schedule` string follows the typical five-field cron format `minute hour day-of-month month day-of-week`.
+It supports the most common features from Unix cron:
+
+- numeric values
+- ranges (e.g. `8-11`)
+- lists separated by commas (e.g. `mon,wed,fri`)
+- step values using `/` (e.g. `*/15`)
+- names for months and days (`jan-dec`, `sun-sat`)
+
+Jobs are evaluated in the server's timezone and run with minute resolution.
+
+### Cron Schedule Examples
+
+```python
+# Every minute
+"* * * * *"
+
+# Every hour at minute 30
+"30 * * * *"
+
+# Every day at 2:30 AM
+"30 2 * * *"
+
+# Every Monday at 9:00 AM
+"0 9 * * mon"
+
+# Every 15 minutes
+"*/15 * * * *"
+
+# Every weekday at 6:00 PM
+"0 18 * * mon-fri"
+
+# First day of every month at midnight
+"0 0 1 * *"
+
+# Every 2 hours during business hours on weekdays
+"0 9-17/2 * * mon-fri"
+```
+
+### Defining Cron Jobs
+
+```python
+from rrq.settings import RRQSettings
+from rrq.cron import CronJob
+
+# Define your cron jobs
+cron_jobs = [
+    # Daily cleanup at 2 AM
+    CronJob(
+        function_name="daily_cleanup",
+        schedule="0 2 * * *",
+        args=["temp_files"],
+        kwargs={"max_age_days": 7}
+    ),
+    
+    # Weekly report every Monday at 9 AM
+    CronJob(
+        function_name="generate_weekly_report",
+        schedule="0 9 * * mon",
+        unique=True  # Prevent duplicate reports if worker restarts
+    ),
+    
+    # Health check every 15 minutes on a specific queue
+    CronJob(
+        function_name="system_health_check",
+        schedule="*/15 * * * *",
+        queue_name="monitoring"
+    ),
+    
+    # Backup database every night at 1 AM
+    CronJob(
+        function_name="backup_database",
+        schedule="0 1 * * *",
+        kwargs={"backup_type": "incremental"}
+    ),
+]
+
+# Add to your settings
+rrq_settings = RRQSettings(
+    redis_dsn="redis://localhost:6379/0",
+    cron_jobs=cron_jobs
+)
+```
+
+### Cron Job Handlers
+
+Your cron job handlers are regular async functions, just like other job handlers:
+
+```python
+async def daily_cleanup(ctx, file_type: str, max_age_days: int = 7):
+    """Clean up old files."""
+    job_id = ctx['job_id']
+    print(f"Job {job_id}: Cleaning up {file_type} files older than {max_age_days} days")
+    # Your cleanup logic here
+    return {"cleaned_files": 42, "status": "completed"}
+
+async def generate_weekly_report(ctx):
+    """Generate and send weekly report."""
+    job_id = ctx['job_id']
+    print(f"Job {job_id}: Generating weekly report")
+    # Your report generation logic here
+    return {"report_id": "weekly_2024_01", "status": "sent"}
+
+# Register your handlers
+from rrq.registry import JobRegistry
+
+job_registry = JobRegistry()
+job_registry.register("daily_cleanup", daily_cleanup)
+job_registry.register("generate_weekly_report", generate_weekly_report)
+
+# Add the registry to your settings
+rrq_settings.job_registry = job_registry
+```
+
+**Note:** Cron jobs are automatically enqueued by the worker when they become due. The worker checks for due cron jobs every 30 seconds and enqueues them as regular jobs to be processed.
+
 ## Command Line Interface
 
 RRQ provides a command-line interface (CLI) for managing workers and performing health checks:
@@ -145,7 +265,8 @@ RRQ provides a command-line interface (CLI) for managing workers and performing
 - **`rrq worker run`** - Run an RRQ worker process.
   - `--settings` (optional): Specify the Python path to your settings object (e.g., `myapp.worker_config.rrq_settings`). If not provided, it will use the `RRQ_SETTINGS` environment variable or default to a basic `RRQSettings` object.
   - `--queue` (optional, multiple): Specify queue(s) to poll. Defaults to the `default_queue_name` in settings.
-  - `--burst` (flag): Run the worker in burst mode to process one job or batch and then exit.
+  - `--burst` (flag): Run the worker in burst mode to process one job or batch and then exit. Cannot be used with `--num-workers > 1`.
+  - `--num-workers` (optional, integer): Number of parallel worker processes to start. Defaults to the number of CPU cores available on the machine. Cannot be used with `--burst` mode.
 - **`rrq worker watch`** - Run an RRQ worker with auto-restart on file changes.
   - `--path` (optional): Directory path to watch for changes. Defaults to the current directory.
   - `--settings` (optional): Same as above.
@@ -178,7 +299,4 @@ RRQ can be configured in several ways, with the following precedence:
 *   **`JobRegistry` (`registry.py`)**: A simple registry to map string function names (used when enqueuing) to the actual asynchronous handler functions the worker should execute.
 *   **`JobStore` (`store.py`)**: An abstraction layer handling all direct interactions with Redis. It manages job definitions (Hashes), queues (Sorted Sets), processing locks (Strings with TTL), unique job locks, and worker health checks.
 *   **`Job` (`job.py`)**: A Pydantic model representing a job, containing its ID, handler name, arguments, status, retry counts, timestamps, results, etc.
-*   **`JobStatus` (`job.py`)**: An Enum defining the possible states of a job (`PENDING`, `ACTIVE`, `COMPLETED`, `FAILED`, `RETRYING`).
-*   **`RRQSettings` (`settings.py`)**: A Pydantic `BaseSettings` model for configuring RRQ behavior (Redis DSN, queue names, timeouts, retry policies, concurrency, etc.). Loadable from environment variables (prefix `RRQ_`).
-*   **`constants.py`**: Defines shared constants like Redis key prefixes and default configuration values.
-*   **`exc.py`**: Defines custom exceptions, notably `RetryJob` which handlers can raise to explicitly request a retry, potentially with a custom delay.
+*   **`JobStatus` (`job.py`)**: An Enum defining the possible states of a job (`PENDING`, `ACTIVE`, `COMPLETED`, `FAILED`, `

{rrq-0.3.7 → rrq-0.5.0}/README.md

@@ -13,6 +13,7 @@ RRQ is a Python library for creating reliable job queues using Redis and `asynci
 *   **Graceful Shutdown**: Workers listen for SIGINT/SIGTERM and attempt to finish active jobs within a grace period before exiting. Interrupted jobs are re-queued.
 *   **Worker Health Checks**: Workers periodically update a health key in Redis with a TTL, allowing monitoring systems to track active workers.
 *   **Deferred Execution**: Jobs can be scheduled to run at a future time using `_defer_by` or `_defer_until`.
+*   **Cron Jobs**: Periodic jobs can be defined in `RRQSettings.cron_jobs` using a simple cron syntax.
 
     - Using deferral with a specific `_job_id` will effectively reschedule the job associated with that ID to the new time, overwriting its previous definition and score. It does not create multiple distinct scheduled jobs with the same ID.
 
@@ -111,6 +112,125 @@ if __name__ == "__main__":
 
 You can run multiple instances of `worker_script.py` for concurrent processing.
 
+## Cron Jobs
+
+Add instances of `CronJob` to `RRQSettings.cron_jobs` to run periodic jobs. The
+`schedule` string follows the typical five-field cron format `minute hour day-of-month month day-of-week`.
+It supports the most common features from Unix cron:
+
+- numeric values
+- ranges (e.g. `8-11`)
+- lists separated by commas (e.g. `mon,wed,fri`)
+- step values using `/` (e.g. `*/15`)
+- names for months and days (`jan-dec`, `sun-sat`)
+
+Jobs are evaluated in the server's timezone and run with minute resolution.
+
+### Cron Schedule Examples
+
+```python
+# Every minute
+"* * * * *"
+
+# Every hour at minute 30
+"30 * * * *"
+
+# Every day at 2:30 AM
+"30 2 * * *"
+
+# Every Monday at 9:00 AM
+"0 9 * * mon"
+
+# Every 15 minutes
+"*/15 * * * *"
+
+# Every weekday at 6:00 PM
+"0 18 * * mon-fri"
+
+# First day of every month at midnight
+"0 0 1 * *"
+
+# Every 2 hours during business hours on weekdays
+"0 9-17/2 * * mon-fri"
+```
+
+### Defining Cron Jobs
+
+```python
+from rrq.settings import RRQSettings
+from rrq.cron import CronJob
+
+# Define your cron jobs
+cron_jobs = [
+    # Daily cleanup at 2 AM
+    CronJob(
+        function_name="daily_cleanup",
+        schedule="0 2 * * *",
+        args=["temp_files"],
+        kwargs={"max_age_days": 7}
+    ),
+    
+    # Weekly report every Monday at 9 AM
+    CronJob(
+        function_name="generate_weekly_report",
+        schedule="0 9 * * mon",
+        unique=True  # Prevent duplicate reports if worker restarts
+    ),
+    
+    # Health check every 15 minutes on a specific queue
+    CronJob(
+        function_name="system_health_check",
+        schedule="*/15 * * * *",
+        queue_name="monitoring"
+    ),
+    
+    # Backup database every night at 1 AM
+    CronJob(
+        function_name="backup_database",
+        schedule="0 1 * * *",
+        kwargs={"backup_type": "incremental"}
+    ),
+]
+
+# Add to your settings
+rrq_settings = RRQSettings(
+    redis_dsn="redis://localhost:6379/0",
+    cron_jobs=cron_jobs
+)
+```
+
+### Cron Job Handlers
+
+Your cron job handlers are regular async functions, just like other job handlers:
+
+```python
+async def daily_cleanup(ctx, file_type: str, max_age_days: int = 7):
+    """Clean up old files."""
+    job_id = ctx['job_id']
+    print(f"Job {job_id}: Cleaning up {file_type} files older than {max_age_days} days")
+    # Your cleanup logic here
+    return {"cleaned_files": 42, "status": "completed"}
+
+async def generate_weekly_report(ctx):
+    """Generate and send weekly report."""
+    job_id = ctx['job_id']
+    print(f"Job {job_id}: Generating weekly report")
+    # Your report generation logic here
+    return {"report_id": "weekly_2024_01", "status": "sent"}
+
+# Register your handlers
+from rrq.registry import JobRegistry
+
+job_registry = JobRegistry()
+job_registry.register("daily_cleanup", daily_cleanup)
+job_registry.register("generate_weekly_report", generate_weekly_report)
+
+# Add the registry to your settings
+rrq_settings.job_registry = job_registry
+```
+
+**Note:** Cron jobs are automatically enqueued by the worker when they become due. The worker checks for due cron jobs every 30 seconds and enqueues them as regular jobs to be processed.
+
 ## Command Line Interface
 
 RRQ provides a command-line interface (CLI) for managing workers and performing health checks:
@@ -118,7 +238,8 @@ RRQ provides a command-line interface (CLI) for managing workers and performing
 - **`rrq worker run`** - Run an RRQ worker process.
   - `--settings` (optional): Specify the Python path to your settings object (e.g., `myapp.worker_config.rrq_settings`). If not provided, it will use the `RRQ_SETTINGS` environment variable or default to a basic `RRQSettings` object.
   - `--queue` (optional, multiple): Specify queue(s) to poll. Defaults to the `default_queue_name` in settings.
-  - `--burst` (flag): Run the worker in burst mode to process one job or batch and then exit.
+  - `--burst` (flag): Run the worker in burst mode to process one job or batch and then exit. Cannot be used with `--num-workers > 1`.
+  - `--num-workers` (optional, integer): Number of parallel worker processes to start. Defaults to the number of CPU cores available on the machine. Cannot be used with `--burst` mode.
 - **`rrq worker watch`** - Run an RRQ worker with auto-restart on file changes.
   - `--path` (optional): Directory path to watch for changes. Defaults to the current directory.
   - `--settings` (optional): Same as above.
@@ -151,7 +272,4 @@ RRQ can be configured in several ways, with the following precedence:
 *   **`JobRegistry` (`registry.py`)**: A simple registry to map string function names (used when enqueuing) to the actual asynchronous handler functions the worker should execute.
 *   **`JobStore` (`store.py`)**: An abstraction layer handling all direct interactions with Redis. It manages job definitions (Hashes), queues (Sorted Sets), processing locks (Strings with TTL), unique job locks, and worker health checks.
 *   **`Job` (`job.py`)**: A Pydantic model representing a job, containing its ID, handler name, arguments, status, retry counts, timestamps, results, etc.
-*   **`JobStatus` (`job.py`)**: An Enum defining the possible states of a job (`PENDING`, `ACTIVE`, `COMPLETED`, `FAILED`, `RETRYING`).
-*   **`RRQSettings` (`settings.py`)**: A Pydantic `BaseSettings` model for configuring RRQ behavior (Redis DSN, queue names, timeouts, retry policies, concurrency, etc.). Loadable from environment variables (prefix `RRQ_`).
-*   **`constants.py`**: Defines shared constants like Redis key prefixes and default configuration values.
-*   **`exc.py`**: Defines custom exceptions, notably `RetryJob` which handlers can raise to explicitly request a retry, potentially with a custom delay.
+*   **`JobStatus` (`job.py`)**: An Enum defining the possible states of a job (`PENDING`, `ACTIVE`, `COMPLETED`, `FAILED`, `

{rrq-0.3.7 → rrq-0.5.0}/example/example_rrq_settings.py

@@ -1,8 +1,9 @@
-'''example_rrq_settings.py: Example RRQ Application Settings'''
+"""example_rrq_settings.py: Example RRQ Application Settings"""
 
 import asyncio
 import logging
 
+from rrq.cron import CronJob
 from rrq.settings import RRQSettings
 
 logger = logging.getLogger("rrq")
@@ -15,24 +16,43 @@ logger.addHandler(console_handler)
 redis_dsn = "redis://localhost:6379/0"
 
 
-
-
 async def on_startup_hook():
     logger.info("Executing 'on_startup_hook' (application-specific startup)...")
     await asyncio.sleep(0.1)
     logger.info("'on_startup_hook' complete.")
 
+
 async def on_shutdown_hook():
     logger.info("Executing 'on_shutdown_hook' (application-specific shutdown)...")
     await asyncio.sleep(0.1)
     logger.info("'on_shutdown_hook' complete.")
 
 
-
 # RRQ Settings
 rrq_settings = RRQSettings(
     redis_dsn=redis_dsn,
     on_startup=on_startup_hook,
     on_shutdown=on_shutdown_hook,
+    # Example cron jobs - these would run periodically when a worker is running
+    cron_jobs=[
+        # Run a cleanup task every day at 2 AM
+        CronJob(
+            function_name="daily_cleanup",
+            schedule="0 2 * * *",
+            args=["cleanup_logs"],
+            kwargs={"max_age_days": 30},
+        ),
+        # Send a status report every Monday at 9 AM
+        CronJob(
+            function_name="send_status_report",
+            schedule="0 9 * * mon",
+            unique=True,  # Prevent duplicate reports if worker restarts
+        ),
+        # Health check every 15 minutes
+        CronJob(
+            function_name="health_check",
+            schedule="*/15 * * * *",
+            queue_name="monitoring",  # Use a specific queue for monitoring tasks
+        ),
+    ],
 )
-

{rrq-0.3.7 → rrq-0.5.0}/example/rrq_example.py

@@ -8,6 +8,7 @@ from contextlib import suppress
 from datetime import timedelta
 
 from rrq.client import RRQClient
+from rrq.cron import CronJob
 from rrq.exc import RetryJob
 from rrq.registry import JobRegistry
 from rrq.settings import RRQSettings
@@ -62,6 +63,37 @@ async def retry_task(ctx, counter_limit: int):
         return {"status": "completed_after_retries", "attempts": attempt}
 
 
+# --- Example Cron Job Handlers ---
+async def daily_cleanup(ctx, task_type: str, max_age_days: int = 30):
+    """Example cron job handler for daily cleanup tasks."""
+    logger.info(
+        f"DAILY_CLEANUP (Job {ctx['job_id']}): Running {task_type} cleanup, max age: {max_age_days} days"
+    )
+    await asyncio.sleep(0.5)  # Simulate cleanup work
+    logger.info(f"DAILY_CLEANUP (Job {ctx['job_id']}): Cleanup completed")
+    return {"task_type": task_type, "max_age_days": max_age_days, "status": "completed"}
+
+
+async def send_status_report(ctx):
+    """Example cron job handler for sending status reports."""
+    logger.info(
+        f"STATUS_REPORT (Job {ctx['job_id']}): Generating and sending status report"
+    )
+    await asyncio.sleep(0.3)  # Simulate report generation
+    logger.info(f"STATUS_REPORT (Job {ctx['job_id']}): Status report sent")
+    return {"report_type": "weekly", "status": "sent"}
+
+
+async def health_check(ctx):
+    """Example cron job handler for health checks."""
+    logger.info(f"HEALTH_CHECK (Job {ctx['job_id']}): Running system health check")
+    await asyncio.sleep(0.1)  # Simulate health check
+    logger.info(
+        f"HEALTH_CHECK (Job {ctx['job_id']}): Health check completed - all systems OK"
+    )
+    return {"status": "healthy", "timestamp": ctx.get("job_start_time")}
+
+
 # --- Main Execution ---
 async def main():
     logger.info("--- Starting RRQ Example ---")
@@ -72,8 +104,24 @@ async def main():
         default_max_retries=3,  # Lower retries for example
         worker_health_check_interval_seconds=5,  # Frequent health check
         worker_shutdown_grace_period_seconds=5,
+        # Example cron jobs - these will run periodically when the worker is running
+        cron_jobs=[
+            # Run a health check every 2 minutes (for demo purposes)
+            CronJob(
+                function_name="health_check",
+                schedule="*/2 * * * *",  # Every 2 minutes
+                queue_name="monitoring",
+            ),
+            # Send a status report every 5 minutes (for demo purposes)
+            CronJob(
+                function_name="send_status_report",
+                schedule="*/5 * * * *",  # Every 5 minutes
+                unique=True,  # Prevent duplicate reports
+            ),
+        ],
     )
     logger.info(f"Using Redis DB: {settings.redis_dsn}")
+    logger.info(f"Configured {len(settings.cron_jobs)} cron jobs")
 
     # Ensure Redis DB is clean before starting (optional, good for examples)
     try:
@@ -90,6 +138,10 @@ async def main():
     registry.register("handle_success", successful_task)
     registry.register("handle_failure", failing_task)
     registry.register("handle_retry", retry_task)
+    # Register cron job handlers
+    registry.register("daily_cleanup", daily_cleanup)
+    registry.register("send_status_report", send_status_report)
+    registry.register("health_check", health_check)
     logger.info(f"Registered handlers: {registry.get_registered_functions()}")
 
     # 3. Client
@@ -131,7 +183,7 @@ async def main():
     worker = RRQWorker(
         settings=settings,
         job_registry=registry,
-        queues=[settings.default_queue_name, "high_priority"],
+        queues=[settings.default_queue_name, "high_priority", "monitoring"],
     )
 
     # 6. Run Worker (with graceful shutdown handling)
@@ -162,7 +214,8 @@ async def main():
 
     # Wait for stop event or worker task completion (e.g., if it errors out)
     done, pending = await asyncio.wait(
-        [worker_task, asyncio.create_task(stop_event.wait())], return_when=asyncio.FIRST_COMPLETED
+        [worker_task, asyncio.create_task(stop_event.wait())],
+        return_when=asyncio.FIRST_COMPLETED,
     )
 
     logger.info("Stop event triggered or worker task finished.")

{rrq-0.3.7 → rrq-0.5.0}/pyproject.toml

@@ -4,10 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rrq"
-version = "0.3.7"
-authors = [
-    { name = "Mazdak Rezvani", email = "mazdak@me.com" },
-]
+version = "0.5.0"
+authors = [{ name = "Mazdak Rezvani", email = "mazdak@me.com" }]
 description = "RRQ is a Python library for creating reliable job queues using Redis and asyncio"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -30,11 +28,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = [
-    "pytest>=8.3.5",
-    "pytest-asyncio>=0.26.0",
-    "pytest-cov>=6.0.0",
-]
+dev = ["pytest>=8.3.5", "pytest-asyncio>=1.0.0", "pytest-cov>=6.0.0"]
 
 [project.urls]
 "Homepage" = "https://github.com/getresq/rrq"
@@ -44,4 +38,8 @@ dev = [
 rrq = "rrq.cli:rrq"
 
 [tool.pytest.ini_options]
+asyncio_mode = "strict"
 asyncio_default_fixture_loop_scope = "function"
+
+[tool.pyrefly]
+python_interpreter = ".venv/bin/python"

rrq-0.5.0/rrq/__init__.py

@@ -0,0 +1,14 @@
+from .cron import CronJob, CronSchedule
+from .worker import RRQWorker
+from .client import RRQClient
+from .registry import JobRegistry
+from .settings import RRQSettings
+
+__all__ = [
+    "CronJob",
+    "CronSchedule",
+    "RRQWorker",
+    "RRQClient",
+    "JobRegistry",
+    "RRQSettings",
+]