pyworkflow-engine 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

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/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)
         )

pyworkflow/celery/singleton.py

@@ -12,13 +12,16 @@ Based on:
 import inspect
 import json
 from hashlib import md5
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 from celery import Task
 from celery.exceptions import WorkerLostError
 from loguru import logger
 
+if TYPE_CHECKING:
+    from redis.sentinel import Sentinel
+
 
 def generate_lock_key(
     task_name: str,
@@ -59,14 +62,83 @@ class SingletonConfig:
     def raise_on_duplicate(self) -> bool:
         return self.app.conf.get("singleton_raise_on_duplicate", False)
 
+    @property
+    def is_sentinel(self) -> bool:
+        """Check if the backend uses Redis Sentinel."""
+        return self.app.conf.get("singleton_backend_is_sentinel", False)
+
+    @property
+    def sentinel_master(self) -> str | None:
+        """Get the Sentinel master name."""
+        return self.app.conf.get("singleton_sentinel_master")
+
 
 class RedisLockBackend:
-    """Redis backend for distributed locking."""
+    """Redis backend for distributed locking with Sentinel support."""
 
-    def __init__(self, url: str):
+    _sentinel: "Sentinel | None"
+    _master_name: str | None
+
+    def __init__(
+        self,
+        url: str,
+        is_sentinel: bool = False,
+        sentinel_master: str | None = None,
+    ):
         import redis
 
-        self.redis = redis.from_url(url, decode_responses=True)
+        if is_sentinel:
+            from redis.sentinel import Sentinel
+
+            sentinels = self._parse_sentinel_url(url)
+            self._sentinel = Sentinel(
+                sentinels,
+                socket_timeout=0.5,
+                decode_responses=True,
+            )
+            self._master_name = sentinel_master or "mymaster"
+            self.redis = self._sentinel.master_for(
+                self._master_name,
+                decode_responses=True,
+            )
+        else:
+            self._sentinel = None
+            self._master_name = None
+            self.redis = redis.from_url(url, decode_responses=True)
+
+    @staticmethod
+    def _parse_sentinel_url(url: str) -> list[tuple[str, int]]:
+        """
+        Parse sentinel:// URL to list of (host, port) tuples.
+
+        Args:
+            url: Sentinel URL (sentinel:// or sentinel+ssl://)
+
+        Returns:
+            List of (host, port) tuples for Sentinel servers
+        """
+        # Remove protocol
+        url = url.replace("sentinel://", "").replace("sentinel+ssl://", "")
+        # Remove database suffix and query params
+        if "/" in url:
+            url = url.split("/")[0]
+        if "?" in url:
+            url = url.split("?")[0]
+        # Handle password prefix (password@hosts)
+        if "@" in url:
+            url = url.split("@", 1)[1]
+
+        sentinels: list[tuple[str, int]] = []
+        for host_port in url.split(","):
+            host_port = host_port.strip()
+            if not host_port:
+                continue
+            if ":" in host_port:
+                host, port = host_port.rsplit(":", 1)
+                sentinels.append((host, int(port)))
+            else:
+                sentinels.append((host_port, 26379))  # Default Sentinel port
+        return sentinels
 
     def lock(self, lock_key: str, task_id: str, expiry: int | None = None) -> bool:
         """Acquire lock atomically. Returns True if acquired."""
@@ -144,13 +216,26 @@ class SingletonWorkflowTask(Task):
     def singleton_backend(self) -> RedisLockBackend | None:
         if self._singleton_backend is None:
             url = self.singleton_config.backend_url
+            is_sentinel = self.singleton_config.is_sentinel
+            sentinel_master = self.singleton_config.sentinel_master
+
             if not url:
-                # Try broker URL if it's Redis
+                # Try broker URL if it's Redis or Sentinel
                 broker = self.app.conf.broker_url or ""
                 if broker.startswith("redis://") or broker.startswith("rediss://"):
                     url = broker
+                    is_sentinel = False
+                elif broker.startswith("sentinel://") or broker.startswith("sentinel+ssl://"):
+                    url = broker
+                    is_sentinel = True
+                    sentinel_master = self.app.conf.get("singleton_sentinel_master", "mymaster")
+
             if url:
-                self._singleton_backend = RedisLockBackend(url)
+                self._singleton_backend = RedisLockBackend(
+                    url,
+                    is_sentinel=is_sentinel,
+                    sentinel_master=sentinel_master,
+                )
         return self._singleton_backend
 
     @property

pyworkflow/cli/commands/worker.py

@@ -20,7 +20,13 @@ def worker() -> None:
     pass
 
 
-@worker.command(name="run")
+@worker.command(
+    name="run",
+    context_settings={
+        "allow_extra_args": True,
+        "allow_interspersed_args": False,
+    },
+)
 @click.option(
     "--workflow",
     "queue_workflow",
@@ -70,6 +76,40 @@ def worker() -> None:
     default="prefork",
     help="Worker pool type (default: prefork). Use 'solo' for debugging with breakpoints",
 )
+@click.option(
+    "--sentinel-master",
+    default=None,
+    help="Redis Sentinel master name (required for sentinel:// URLs)",
+)
+@click.option(
+    "--autoscale",
+    default=None,
+    help="Enable autoscaling: MIN,MAX (e.g., '2,10')",
+)
+@click.option(
+    "--max-tasks-per-child",
+    type=int,
+    default=None,
+    help="Maximum tasks per worker child before replacement",
+)
+@click.option(
+    "--prefetch-multiplier",
+    type=int,
+    default=None,
+    help="Task prefetch count per worker process",
+)
+@click.option(
+    "--time-limit",
+    type=float,
+    default=None,
+    help="Hard time limit for tasks in seconds",
+)
+@click.option(
+    "--soft-time-limit",
+    type=float,
+    default=None,
+    help="Soft time limit for tasks in seconds",
+)
 @click.pass_context
 def run_worker(
     ctx: click.Context,
@@ -81,6 +121,12 @@ def run_worker(
     hostname: str | None,
     beat: bool,
     pool: str | None,
+    sentinel_master: str | None,
+    autoscale: str | None,
+    max_tasks_per_child: int | None,
+    prefetch_multiplier: int | None,
+    time_limit: float | None,
+    soft_time_limit: float | None,
 ) -> None:
     """
     Start a Celery worker for processing workflows.
@@ -88,6 +134,8 @@ def run_worker(
     By default, processes all queues. Use --workflow, --step, or --schedule
     flags to limit to specific queue types.
 
+    Use -- to pass arbitrary Celery arguments directly to the worker.
+
     Examples:
 
         # Start a worker processing all queues
@@ -107,6 +155,15 @@ def run_worker(
 
         # Start with custom log level
         pyworkflow worker run --loglevel debug
+
+        # 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
     """
     # Get config from CLI context (TOML config)
     config = ctx.obj.get("config", {})
@@ -124,6 +181,9 @@ def run_worker(
             merged_config["celery"] = yaml_config["celery"]
         config = merged_config
 
+    # Get extra args passed after --
+    extra_args = ctx.args
+
     # Determine queues to process
     queues = []
     if queue_workflow:
@@ -158,11 +218,21 @@ def run_worker(
 
     loguru_logger.enable("pyworkflow")
 
+    # Get Sentinel master from CLI option, config file, or environment
+    sentinel_master_name = sentinel_master or celery_config.get(
+        "sentinel_master",
+        os.getenv("PYWORKFLOW_CELERY_SENTINEL_MASTER"),
+    )
+
     print_info("Starting Celery worker...")
     print_info(f"Broker: {broker_url}")
+    if broker_url.startswith("sentinel://") or broker_url.startswith("sentinel+ssl://"):
+        print_info(f"Sentinel master: {sentinel_master_name or 'mymaster'}")
     print_info(f"Queues: {', '.join(queues)}")
     print_info(f"Concurrency: {concurrency}")
     print_info(f"Pool: {pool}")
+    if extra_args:
+        print_info(f"Extra args: {' '.join(extra_args)}")
 
     try:
         # Discover workflows using CLI discovery (reads from --module, env var, or YAML config)
@@ -177,6 +247,7 @@ def run_worker(
         app = create_celery_app(
             broker_url=broker_url,
             result_backend=result_backend,
+            sentinel_master_name=sentinel_master_name,
         )
 
         # Log discovered workflows and steps
@@ -212,11 +283,12 @@ def run_worker(
         worker_args = [
             "worker",
             f"--loglevel={loglevel.upper()}",
-            f"--queues={','.join(queues)}",
             f"--concurrency={concurrency}",  # Always set (default: 1)
             f"--pool={pool}",  # Always set (default: prefork)
         ]
 
+        worker_args.append(f"--queues={','.join(queues)}")
+
         if hostname:
             worker_args.append(f"--hostname={hostname}")
 
@@ -224,6 +296,26 @@ def run_worker(
             worker_args.append("--beat")
             worker_args.append("--scheduler=pyworkflow.celery.scheduler:PyWorkflowScheduler")
 
+        # Add new explicit options
+        if autoscale:
+            worker_args.append(f"--autoscale={autoscale}")
+
+        if max_tasks_per_child is not None:
+            worker_args.append(f"--max-tasks-per-child={max_tasks_per_child}")
+
+        if prefetch_multiplier is not None:
+            worker_args.append(f"--prefetch-multiplier={prefetch_multiplier}")
+
+        if time_limit is not None:
+            worker_args.append(f"--time-limit={time_limit}")
+
+        if soft_time_limit is not None:
+            worker_args.append(f"--soft-time-limit={soft_time_limit}")
+
+        # Append extra args last (highest priority - they can override anything)
+        if extra_args:
+            worker_args.extend(extra_args)
+
         print_success("Worker starting...")
         print_info("Press Ctrl+C to stop")
         print_info("")

{pyworkflow_engine-0.1.15.dist-info → pyworkflow_engine-0.1.16.dist-info}/METADATA

@@ -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.15.dist-info → pyworkflow_engine-0.1.16.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyworkflow/__init__.py,sha256=y7ZDE1MHyoDPMBh_mnmHhmtYxFeZV0aSWeKpUn6JXuA,6281
+pyworkflow/__init__.py,sha256=s41mjcGKUwCL-2vfD77bvwvoWhPXncFNzylphNfQnG0,6281
 pyworkflow/config.py,sha256=pKwPrpCwBJiDpB-MIjM0U7GW1TFmQFO341pihL5-vTM,14455
 pyworkflow/discovery.py,sha256=snW3l4nvY3Nc067TGlwtn_qdzTU9ybN7YPr8FbvY8iM,8066
 pyworkflow/aws/__init__.py,sha256=Ak_xHcR9LTRX-CwcS0XecYmzrXZw4EM3V9aKBBDEmIk,1741
@@ -6,10 +6,10 @@ pyworkflow/aws/context.py,sha256=Vjyjip6U1Emg-WA5TlBaxFhcg15rf9mVJiPfT4VywHc,821
 pyworkflow/aws/handler.py,sha256=0SnQuIfQVD99QKMCRFPtrsrV_l1LYKFkzPIRx_2UkSI,5849
 pyworkflow/aws/testing.py,sha256=WrRk9wjbycM-UyHFQWNnA83UE9IrYnhfT38WrbxQT2U,8844
 pyworkflow/celery/__init__.py,sha256=FywVyqnT8AYz9cXkr-wel7_-N7dHFsPNASEPMFESf4Q,1179
-pyworkflow/celery/app.py,sha256=UwZauZjVzOxMPX3WmPilRi8Emg5_VbMjHjNn7uz7R14,9670
+pyworkflow/celery/app.py,sha256=QXpPXVVuwJv3ToylT0pyz9SgmwjC9hW-9WaIO4wH5OQ,14349
 pyworkflow/celery/loop.py,sha256=mu8cIfMJYgHAoGCN_DdDoNoXK3QHzHpLmrPCyFDQYIY,3016
 pyworkflow/celery/scheduler.py,sha256=Ms4rqRpdpMiLM8l4y3DK-Divunj9afYuUaGGoNQe7P4,11288
-pyworkflow/celery/singleton.py,sha256=J4a5LY5GsSFbO2evkql4Pw7h38tA2rQbR3J2cXkJRZg,13155
+pyworkflow/celery/singleton.py,sha256=9gdVHzqFjShZ9OJOJlJNABUg9oqnl6ITGROtomcOtsg,16070
 pyworkflow/celery/tasks.py,sha256=BNHZwWTSRc3q8EgAy4tEmXAm6O0vtVLgrG7MrO0ZZXA,86049
 pyworkflow/cli/__init__.py,sha256=tcbe-fcZmyeEKUy_aEo8bsEF40HsNKOwvyMBZIJZPwc,3844
 pyworkflow/cli/__main__.py,sha256=LxLLS4FEEPXa5rWpLTtKuivn6Xp9pGia-QKGoxt9SS0,148
@@ -20,7 +20,7 @@ pyworkflow/cli/commands/runs.py,sha256=dkAx0WSBLyooD-vUUDPqgrmM3ElFwqO4nycEZGkNq
 pyworkflow/cli/commands/scheduler.py,sha256=w2iUoJ1CtEtOg_4TWslTHbzEPVsV-YybqWU9jkf38gs,3706
 pyworkflow/cli/commands/schedules.py,sha256=UCKZLTWsiLwCewCEXmqOVQnptvvuIKsWSTXai61RYbM,23466
 pyworkflow/cli/commands/setup.py,sha256=J-9lvz3m2sZiiLzQtQIfjmX0l8IpJ4L-xp5U4P7UmRY,32256
-pyworkflow/cli/commands/worker.py,sha256=PamHnEbgr2GQhFikyEEjT_Oai_iIvSs-a8GGXF4lHv0,12196
+pyworkflow/cli/commands/worker.py,sha256=3TfKAQ3MxYyAEGt4TuPTLfuLN-igtrYeu4cTiLsJoq8,14982
 pyworkflow/cli/commands/workflows.py,sha256=zRBFeqCa4Uo_wwEjgk0SBmkqgcaMznS6ghe1N0ub8Zs,42673
 pyworkflow/cli/output/__init__.py,sha256=5VxKL3mXah5rCKmctxcAKVwp42T47qT1oBK5LFVHHEg,48
 pyworkflow/cli/output/formatters.py,sha256=QzsgPR3cjIbH0723wuG_HzUx9xC7XMA6-NkT2y2lwtM,8785
@@ -86,9 +86,9 @@ pyworkflow/storage/sqlite.py,sha256=qDhFjyFAenwYq6MF_66FFhDaBG7CEr7ni9Uy72X7MvQ,
 pyworkflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/utils/duration.py,sha256=C-itmiSQQlplw7j6XB679hLF9xYGnyCwm7twO88OF8U,3978
 pyworkflow/utils/schedule.py,sha256=dO_MkGFyfwZpb0LDlW6BGyZzlPuQIA6dc6j9nk9lc4Y,10691
-pyworkflow_engine-0.1.15.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.15.dist-info/METADATA,sha256=U7Dxscf56DPD5TOPCvuyeR75XF5CnftWN78i2yboZBU,19628
-pyworkflow_engine-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyworkflow_engine-0.1.15.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.15.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.15.dist-info/RECORD,,
+pyworkflow_engine-0.1.16.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
+pyworkflow_engine-0.1.16.dist-info/METADATA,sha256=a0_gpG8bYfcmgaJ_G28Ko5mRdWWls_Gyh3bs4bcnJ_k,19628
+pyworkflow_engine-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyworkflow_engine-0.1.16.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
+pyworkflow_engine-0.1.16.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
+pyworkflow_engine-0.1.16.dist-info/RECORD,,