pyworkflow-engine 0.1.15__tar.gz → 0.1.16__tar.gz

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyworkflow-engine
-Version: 0.1.15
+Version: 0.1.16
 Summary: A Python implementation of durable, event-sourced workflows inspired by Vercel Workflow
 Author: PyWorkflow Contributors
 License: MIT

pyworkflow_engine-0.1.16/docs/guides/brokers.mdx

@@ -0,0 +1,367 @@
+---
+title: 'Celery Brokers'
+description: 'Configure message brokers for distributed workflow execution with Celery runtime'
+---
+
+## Overview
+
+When using the **Celery runtime** (`runtime: celery`), PyWorkflow requires a **message broker** to
+transport messages between your application and workers, and optionally a **result backend** to
+store task results.
+
+<Note>
+  This guide only applies when using the Celery runtime for distributed execution. The local runtime
+  (`runtime: local`) runs workflows in-process and does not require a broker.
+</Note>
+
+PyWorkflow supports several broker configurations:
+
+<CardGroup cols={2}>
+  <Card title="Redis" icon="database">
+    Simple, fast, and recommended for most deployments
+  </Card>
+  <Card title="Redis Sentinel" icon="shield-halved">
+    High-availability Redis with automatic failover
+  </Card>
+</CardGroup>
+
+---
+
+## Redis
+
+Redis is the recommended broker for most PyWorkflow deployments. It's simple to set up, provides
+excellent performance, and supports both broker and result backend functionality.
+
+### Basic Configuration
+
+<Tabs>
+  <Tab title="Config File">
+    ```yaml
+    # pyworkflow.config.yaml
+    runtime: celery
+
+    celery:
+      broker: redis://localhost:6379/0
+      result_backend: redis://localhost:6379/1
+    ```
+  </Tab>
+  <Tab title="Environment Variables">
+    ```bash
+    export PYWORKFLOW_CELERY_BROKER=redis://localhost:6379/0
+    export PYWORKFLOW_CELERY_RESULT_BACKEND=redis://localhost:6379/1
+    ```
+  </Tab>
+  <Tab title="Programmatic">
+    ```python
+    import pyworkflow
+
+    pyworkflow.configure(
+        default_runtime="celery",
+        celery_broker="redis://localhost:6379/0",
+    )
+    ```
+  </Tab>
+</Tabs>
+
+### URL Format
+
+```
+redis://[[username:]password@]host[:port][/database]
+```
+
+| Component | Description | Default |
+|-----------|-------------|---------|
+| `username` | Redis username (Redis 6+ ACL) | None |
+| `password` | Redis password | None |
+| `host` | Redis server hostname | `localhost` |
+| `port` | Redis server port | `6379` |
+| `database` | Redis database number | `0` |
+
+### Examples
+
+```yaml
+# Local Redis (default)
+celery:
+  broker: redis://localhost:6379/0
+
+# Redis with password
+celery:
+  broker: redis://:mypassword@localhost:6379/0
+
+# Redis with username and password (Redis 6+ ACL)
+celery:
+  broker: redis://myuser:mypassword@localhost:6379/0
+
+# Remote Redis
+celery:
+  broker: redis://redis.example.com:6379/0
+
+# Different databases for broker and backend
+celery:
+  broker: redis://localhost:6379/0
+  result_backend: redis://localhost:6379/1
+```
+
+### TLS/SSL Connection
+
+For encrypted connections, use the `rediss://` scheme:
+
+```yaml
+celery:
+  broker: rediss://redis.example.com:6379/0
+  result_backend: rediss://redis.example.com:6379/1
+```
+
+<Note>
+  When using `rediss://`, ensure your Redis server is configured with TLS certificates.
+</Note>
+
+---
+
+## Redis Sentinel
+
+[Redis Sentinel](https://redis.io/docs/management/sentinel/) provides high availability for Redis
+through automatic failover. When a master node fails, Sentinel automatically promotes a replica
+to master, ensuring your workflows continue processing with minimal interruption.
+
+### When to Use Sentinel
+
+Use Redis Sentinel when you need:
+
+- **High availability**: Automatic failover when master fails
+- **Monitoring**: Constant health checks on Redis instances
+- **Notification**: Alerts when Redis instances change state
+- **Configuration provider**: Clients discover current master automatically
+
+### Basic Configuration
+
+<Tabs>
+  <Tab title="Config File">
+    ```yaml
+    # pyworkflow.config.yaml
+    runtime: celery
+
+    celery:
+      broker: sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/0
+      result_backend: sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/1
+      sentinel_master: mymaster
+    ```
+  </Tab>
+  <Tab title="Environment Variables">
+    ```bash
+    export PYWORKFLOW_CELERY_BROKER=sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/0
+    export PYWORKFLOW_CELERY_RESULT_BACKEND=sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/1
+    export PYWORKFLOW_CELERY_SENTINEL_MASTER=mymaster
+    ```
+  </Tab>
+  <Tab title="CLI Arguments">
+    ```bash
+    pyworkflow worker run --sentinel-master mymaster
+    ```
+  </Tab>
+</Tabs>
+
+### URL Format
+
+```
+sentinel://[[password@]host1[:port1],host2[:port2],...]/database
+```
+
+| Component | Description | Default |
+|-----------|-------------|---------|
+| `password` | Sentinel password | None |
+| `host1,host2,...` | Comma-separated Sentinel hosts | Required |
+| `port` | Sentinel port for each host | `26379` |
+| `database` | Redis database number | `0` |
+
+### Configuration Options
+
+| Option | Environment Variable | CLI Flag | Default | Description |
+|--------|---------------------|----------|---------|-------------|
+| `sentinel_master` | `PYWORKFLOW_CELERY_SENTINEL_MASTER` | `--sentinel-master` | `mymaster` | Name of the Sentinel master group |
+
+### Examples
+
+```yaml
+# Basic Sentinel setup
+celery:
+  broker: sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/0
+  result_backend: sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/1
+  sentinel_master: mymaster
+
+# Sentinel with password
+celery:
+  broker: sentinel://sentinelpassword@sentinel1:26379,sentinel2:26379/0
+  sentinel_master: mymaster
+
+# Sentinel with custom ports
+celery:
+  broker: sentinel://sentinel1:26380,sentinel2:26381,sentinel3:26382/0
+  sentinel_master: redis-primary
+
+# Single Sentinel (not recommended for production)
+celery:
+  broker: sentinel://sentinel1:26379/0
+  sentinel_master: mymaster
+```
+
+### TLS/SSL with Sentinel
+
+For encrypted connections to Sentinel, use the `sentinel+ssl://` scheme:
+
+```yaml
+celery:
+  broker: sentinel+ssl://sentinel1:26379,sentinel2:26379,sentinel3:26379/0
+  result_backend: sentinel+ssl://sentinel1:26379,sentinel2:26379,sentinel3:26379/1
+  sentinel_master: mymaster
+```
+
+### Sentinel Architecture
+
+A typical Sentinel deployment consists of:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     Sentinel Cluster                        │
+│  ┌──────────┐    ┌──────────┐    ┌──────────┐              │
+│  │Sentinel 1│    │Sentinel 2│    │Sentinel 3│              │
+│  └────┬─────┘    └────┬─────┘    └────┬─────┘              │
+│       │               │               │                     │
+│       └───────────────┼───────────────┘                     │
+│                       │                                     │
+│                       ▼                                     │
+│              ┌────────────────┐                             │
+│              │  Redis Master  │◄──── Writes                 │
+│              └───────┬────────┘                             │
+│                      │ Replication                          │
+│         ┌────────────┼────────────┐                         │
+│         ▼            ▼            ▼                         │
+│  ┌────────────┐ ┌────────────┐ ┌────────────┐              │
+│  │  Replica 1 │ │  Replica 2 │ │  Replica 3 │              │
+│  └────────────┘ └────────────┘ └────────────┘              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+<Warning>
+  Always deploy at least **3 Sentinel instances** in production. Sentinel uses quorum-based
+  decision making, and a single Sentinel cannot reliably detect failures.
+</Warning>
+
+---
+
+## Configuration Reference
+
+### Environment Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `PYWORKFLOW_CELERY_BROKER` | Celery broker URL | `redis://localhost:6379/0` |
+| `PYWORKFLOW_CELERY_RESULT_BACKEND` | Celery result backend URL | `redis://localhost:6379/1` |
+| `PYWORKFLOW_CELERY_SENTINEL_MASTER` | Sentinel master name | `mymaster` |
+
+### CLI Options
+
+| Option | Description |
+|--------|-------------|
+| `--sentinel-master` | Redis Sentinel master name (required for `sentinel://` URLs) |
+
+See the [CLI Guide](/guides/cli#worker-run) for all available worker options including
+autoscaling, task limits, and arbitrary Celery argument passthrough.
+
+### Config File Options
+
+```yaml
+celery:
+  # Broker URL (required)
+  broker: redis://localhost:6379/0
+
+  # Result backend URL (optional, defaults to broker)
+  result_backend: redis://localhost:6379/1
+
+  # Sentinel master name (required for sentinel:// URLs)
+  sentinel_master: mymaster
+```
+
+---
+
+## Choosing a Broker
+
+| Requirement | Recommended Broker |
+|-------------|-------------------|
+| Development/Testing | Redis (single instance) |
+| Production (simple) | Redis (single instance or managed service) |
+| Production (HA required) | Redis Sentinel |
+| Cloud deployment | Managed Redis (AWS ElastiCache, Azure Cache, GCP Memorystore) |
+
+<Tip>
+  Most cloud providers offer managed Redis services with built-in high availability.
+  These are often easier to operate than self-managed Sentinel clusters.
+</Tip>
+
+---
+
+## Troubleshooting
+
+### Connection Refused
+
+```
+Error: Connection refused (redis://localhost:6379/0)
+```
+
+**Solution**: Ensure Redis is running and accessible:
+
+```bash
+# Check if Redis is running
+redis-cli ping
+
+# Start Redis (if using Docker)
+docker run -d -p 6379:6379 redis:7-alpine
+```
+
+### Sentinel Master Not Found
+
+```
+Error: No master found for 'mymaster'
+```
+
+**Solutions**:
+1. Verify the master name matches your Sentinel configuration
+2. Check that Sentinel instances are running and healthy
+3. Ensure network connectivity between your application and Sentinel
+
+```bash
+# Check Sentinel status
+redis-cli -p 26379 SENTINEL master mymaster
+```
+
+### Authentication Failed
+
+```
+Error: NOAUTH Authentication required
+```
+
+**Solution**: Include password in the URL:
+
+```yaml
+celery:
+  broker: redis://:yourpassword@localhost:6379/0
+```
+
+---
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="CLI Guide" icon="terminal" href="/guides/cli">
+    Learn CLI commands for worker management
+  </Card>
+  <Card title="Configuration" icon="gear" href="/guides/configuration">
+    Complete configuration reference
+  </Card>
+  <Card title="Fault Tolerance" icon="shield" href="/concepts/fault-tolerance">
+    Learn about automatic recovery
+  </Card>
+  <Card title="Workflows" icon="diagram-project" href="/concepts/workflows">
+    Learn workflow concepts
+  </Card>
+</CardGroup>

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/docs/guides/cli.mdx

@@ -416,10 +416,15 @@ pyworkflow worker run
 | `--workflow` | Only process workflow orchestration tasks |
 | `--step` | Only process step execution tasks |
 | `--schedule` | Only process scheduled resumption tasks |
-| `--concurrency N` | Number of worker processes (default: auto) |
+| `--concurrency N` | Number of worker processes (default: 1) |
 | `--loglevel LEVEL` | Log level: `debug`, `info`, `warning`, `error` |
 | `--hostname NAME` | Custom worker hostname |
 | `--beat` | Also start Celery Beat scheduler |
+| `--autoscale MIN,MAX` | Enable worker autoscaling (e.g., `2,10`) |
+| `--max-tasks-per-child N` | Replace worker child after N tasks |
+| `--prefetch-multiplier N` | Task prefetch count per worker process |
+| `--time-limit SECONDS` | Hard time limit for tasks |
+| `--soft-time-limit SECONDS` | Soft time limit for tasks |
 
 <Tabs>
   <Tab title="All Queues (Default)">
@@ -440,6 +445,21 @@ pyworkflow worker run
     pyworkflow worker run --schedule
     ```
   </Tab>
+  <Tab title="Advanced Celery Options">
+    ```bash
+    # Enable autoscaling (min 2, max 10 workers)
+    pyworkflow worker run --step --autoscale 2,10
+
+    # Set task limits
+    pyworkflow worker run --max-tasks-per-child 100 --time-limit 300
+
+    # Pass arbitrary Celery arguments after --
+    pyworkflow worker run -- --max-memory-per-child=200000
+
+    # Combine PyWorkflow options with Celery passthrough
+    pyworkflow worker run --step --autoscale 2,8 -- --max-memory-per-child=150000
+    ```
+  </Tab>
 </Tabs>
 
 <Tip>

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/docs/guides/configuration.mdx

@@ -542,19 +542,39 @@ print(f"Celery Broker: {config.celery_broker}")
 
 ---
 
+## Worker Configuration
+
+When running Celery workers, you can configure worker behavior through CLI options.
+See the [CLI Guide](/guides/cli#worker-run) for all available options including:
+
+- **Autoscaling**: Automatically scale worker processes based on load
+- **Task limits**: Control tasks per child and prefetch multiplier
+- **Time limits**: Set hard and soft time limits for tasks
+- **Celery passthrough**: Forward arbitrary arguments to Celery
+
+```bash
+# Example: Production worker with autoscaling and task limits
+pyworkflow worker run --step --autoscale 2,10 --max-tasks-per-child 100
+
+# Example: Pass arbitrary Celery options
+pyworkflow worker run -- --max-memory-per-child=200000
+```
+
+---
+
 ## Next Steps
 
 <CardGroup cols={2}>
   <Card title="CLI Guide" icon="terminal" href="/guides/cli">
     Learn CLI commands and options.
   </Card>
-  <Card title="Celery Runtime" icon="server" href="/guides/celery">
-    Configure distributed execution with Celery.
+  <Card title="Celery Brokers" icon="server" href="/guides/brokers">
+    Configure message brokers for distributed execution.
   </Card>
   <Card title="Storage Backends" icon="database" href="/concepts/storage">
     Choose the right storage backend.
   </Card>
-  <Card title="Deployment" icon="cloud" href="/guides/deployment">
-    Deploy workflows to production.
+  <Card title="Fault Tolerance" icon="shield" href="/concepts/fault-tolerance">
+    Learn about automatic recovery.
   </Card>
 </CardGroup>

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/docs/quickstart.mdx

@@ -51,7 +51,7 @@ Project Created!
 Next steps:
 
   1. Start a worker:
-     $ pyworkflow worker start
+     $ pyworkflow worker run
 
   2. Run a workflow:
      $ pyworkflow workflows run process_order \
@@ -117,7 +117,7 @@ If you prefer to set up manually or need more control:
     EOF
 
     # 3. Start Celery worker
-    pyworkflow worker start
+    pyworkflow worker run
     ```
   </Tab>
 </Tabs>

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/pyproject.toml

@@ -7,7 +7,7 @@ packages = [{include = "pyworkflow"}]
 
 [project]
 name = "pyworkflow-engine"
-version = "0.1.15"
+version = "0.1.16"
 description = "A Python implementation of durable, event-sourced workflows inspired by Vercel Workflow"
 readme = "README.md"
 requires-python = ">=3.11"

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/pyworkflow/__init__.py

@@ -29,7 +29,7 @@ Quick Start:
     >>> run_id = await start(my_workflow, "Alice")
 """
 
-__version__ = "0.1.15"
+__version__ = "0.1.16"
 
 # Configuration
 from pyworkflow.config import (

{pyworkflow_engine-0.1.15 → pyworkflow_engine-0.1.16}/pyworkflow/celery/app.py

@@ -13,6 +13,7 @@ garbage collector and Celery's saferepr module. It does not affect functionality
 """
 
 import os
+from typing import Any
 
 from celery import Celery
 from celery.signals import worker_init, worker_process_init, worker_shutdown
@@ -38,6 +39,74 @@ def _configure_worker_logging() -> None:
         _logging_configured = True
 
 
+def is_sentinel_url(url: str) -> bool:
+    """Check if URL uses sentinel:// or sentinel+ssl:// protocol."""
+    return url.startswith("sentinel://") or url.startswith("sentinel+ssl://")
+
+
+def parse_sentinel_url(url: str) -> tuple[list[tuple[str, int]], int, str | None]:
+    """
+    Parse a sentinel:// URL into sentinel hosts, database number, and password.
+
+    Format: sentinel://[password@]host1:port1,host2:port2/db_number
+
+    Args:
+        url: Sentinel URL (sentinel:// or sentinel+ssl://)
+
+    Returns:
+        Tuple of ([(host, port), ...], db_number, password or None)
+
+    Examples:
+        >>> parse_sentinel_url("sentinel://host1:26379,host2:26379/0")
+        ([('host1', 26379), ('host2', 26379)], 0, None)
+
+        >>> parse_sentinel_url("sentinel://mypassword@host1:26379/0")
+        ([('host1', 26379)], 0, 'mypassword')
+    """
+    # Remove protocol prefix
+    if url.startswith("sentinel+ssl://"):
+        url_without_protocol = url[len("sentinel+ssl://") :]
+    elif url.startswith("sentinel://"):
+        url_without_protocol = url[len("sentinel://") :]
+    else:
+        raise ValueError(f"Invalid sentinel URL: {url}")
+
+    # Extract password if present (password@hosts)
+    password: str | None = None
+    if "@" in url_without_protocol:
+        password, url_without_protocol = url_without_protocol.split("@", 1)
+
+    # Extract database number from path
+    db_number = 0
+    if "/" in url_without_protocol:
+        hosts_part, db_part = url_without_protocol.rsplit("/", 1)
+        # Handle query params in db part
+        if "?" in db_part:
+            db_part = db_part.split("?")[0]
+        if db_part:
+            db_number = int(db_part)
+    else:
+        hosts_part = url_without_protocol
+        # Handle query params
+        if "?" in hosts_part:
+            hosts_part = hosts_part.split("?")[0]
+
+    # Parse hosts
+    sentinels: list[tuple[str, int]] = []
+    for host_port in hosts_part.split(","):
+        host_port = host_port.strip()
+        if not host_port:
+            continue
+        if ":" in host_port:
+            host, port_str = host_port.rsplit(":", 1)
+            sentinels.append((host, int(port_str)))
+        else:
+            # Default Sentinel port
+            sentinels.append((host_port, 26379))
+
+    return sentinels, db_number, password
+
+
 def discover_workflows(modules: list[str] | None = None) -> None:
     """
     Discover and import workflow modules to register workflows with Celery workers.
@@ -79,6 +148,9 @@ def create_celery_app(
     broker_url: str | None = None,
     result_backend: str | None = None,
     app_name: str = "pyworkflow",
+    sentinel_master_name: str | None = None,
+    broker_transport_options: dict[str, Any] | None = None,
+    result_backend_transport_options: dict[str, Any] | None = None,
 ) -> Celery:
     """
     Create and configure a Celery application for PyWorkflow.
@@ -87,6 +159,9 @@ def create_celery_app(
         broker_url: Celery broker URL. Priority: parameter > PYWORKFLOW_CELERY_BROKER env var > redis://localhost:6379/0
         result_backend: Result backend URL. Priority: parameter > PYWORKFLOW_CELERY_RESULT_BACKEND env var > redis://localhost:6379/1
         app_name: Application name
+        sentinel_master_name: Redis Sentinel master name. Priority: parameter > PYWORKFLOW_CELERY_SENTINEL_MASTER env var > "mymaster"
+        broker_transport_options: Additional transport options for the broker (merged with defaults)
+        result_backend_transport_options: Additional transport options for the result backend (merged with defaults)
 
     Returns:
         Configured Celery application
@@ -94,6 +169,7 @@ def create_celery_app(
     Environment Variables:
         PYWORKFLOW_CELERY_BROKER: Celery broker URL (used if broker_url param not provided)
         PYWORKFLOW_CELERY_RESULT_BACKEND: Result backend URL (used if result_backend param not provided)
+        PYWORKFLOW_CELERY_SENTINEL_MASTER: Sentinel master name (used if sentinel_master_name param not provided)
 
     Examples:
         # Default configuration (uses env vars if set, otherwise localhost Redis)
@@ -110,6 +186,13 @@ def create_celery_app(
             broker_url="amqp://guest:guest@rabbitmq:5672//",
             result_backend="redis://localhost:6379/1"
         )
+
+        # Redis Sentinel for high availability
+        app = create_celery_app(
+            broker_url="sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/0",
+            result_backend="sentinel://sentinel1:26379,sentinel2:26379,sentinel3:26379/1",
+            sentinel_master_name="mymaster"
+        )
     """
     # Priority: parameter > environment variable > hardcoded default
     broker_url = broker_url or os.getenv("PYWORKFLOW_CELERY_BROKER") or "redis://localhost:6379/0"
@@ -119,6 +202,45 @@ def create_celery_app(
         or "redis://localhost:6379/1"
     )
 
+    # Detect broker and backend types
+    is_sentinel_broker = is_sentinel_url(broker_url)
+    is_sentinel_backend = is_sentinel_url(result_backend)
+    is_redis_broker = broker_url.startswith("redis://") or broker_url.startswith("rediss://")
+
+    # Get Sentinel master name from param, env, or default
+    master_name = (
+        sentinel_master_name or os.getenv("PYWORKFLOW_CELERY_SENTINEL_MASTER") or "mymaster"
+    )
+
+    # Build transport options for broker
+    if is_sentinel_broker:
+        sentinel_broker_opts: dict[str, Any] = {"master_name": master_name}
+        # Merge with user options (user takes precedence)
+        final_broker_opts: dict[str, Any] = {
+            "visibility_timeout": 3600,
+            **sentinel_broker_opts,
+            **(broker_transport_options or {}),
+        }
+    else:
+        final_broker_opts = {
+            "visibility_timeout": 3600,
+            **(broker_transport_options or {}),
+        }
+
+    # Build transport options for result backend
+    if is_sentinel_backend:
+        sentinel_backend_opts: dict[str, Any] = {"master_name": master_name}
+        final_backend_opts: dict[str, Any] = {
+            "visibility_timeout": 3600,
+            **sentinel_backend_opts,
+            **(result_backend_transport_options or {}),
+        }
+    else:
+        final_backend_opts = {
+            "visibility_timeout": 3600,
+            **(result_backend_transport_options or {}),
+        }
+
     app = Celery(
         app_name,
         broker=broker_url,
@@ -138,12 +260,8 @@ def create_celery_app(
         enable_utc=True,
         # Broker transport options - prevent task redelivery
         # See: https://github.com/celery/celery/issues/5935
-        broker_transport_options={
-            "visibility_timeout": 3600,  # 12 hours - prevent Redis from re-queueing tasks
-        },
-        result_backend_transport_options={
-            "visibility_timeout": 3600,
-        },
+        broker_transport_options=final_broker_opts,
+        result_backend_transport_options=final_backend_opts,
         # Task routing
         task_default_queue="pyworkflow.default",
         task_default_exchange="pyworkflow",
@@ -194,12 +312,13 @@ def create_celery_app(
         worker_task_log_format="[%(asctime)s: %(levelname)s/%(processName)s] [%(task_name)s(%(task_id)s)] %(message)s",
     )
 
-    # Configure singleton locking for Redis brokers
+    # Configure singleton locking for Redis or Sentinel brokers
     # This enables distributed locking to prevent duplicate task execution
-    is_redis_broker = broker_url.startswith("redis://") or broker_url.startswith("rediss://")
-    if is_redis_broker:
+    if is_redis_broker or is_sentinel_broker:
         app.conf.update(
             singleton_backend_url=broker_url,
+            singleton_backend_is_sentinel=is_sentinel_broker,
+            singleton_sentinel_master=master_name if is_sentinel_broker else None,
             singleton_key_prefix="pyworkflow:lock:",
             singleton_lock_expiry=3600,  # 1 hour TTL (safety net)
         )