outerbounds 0.3.182rc1__py3-none-any.whl → 0.3.183rc0__py3-none-any.whl

outerbounds/apps/_state_machine.py

@@ -137,6 +137,19 @@ class _capsuleDeployerStateMachine:
 from typing import TypedDict
 
 
+class AccessInfo(TypedDict):
+    outOfClusterURL: str
+    inClusterURL: str
+
+
+class CapsuleStatus(TypedDict):
+    availableReplicas: int
+    readyToServeTraffic: bool
+    accessInfo: AccessInfo
+    updateInProgress: bool
+    currentlyServedVersion: str
+
+
 class WorkerStatus(TypedDict):
     workerId: str
     phase: str
@@ -196,6 +209,82 @@ class DEPLOYMENT_READY_CONDITIONS:
     # `ASYNC` implies that the deployment will be assumed ready after the URL is minted and the worker statuses are not checked.
     ASYNC = "async"
 
+    @classmethod
+    def check_failure_condition(
+        cls,
+        capsule_status: CapsuleStatus,
+        worker_semantic_status: "CapsuleWorkerSemanticStatus",
+    ) -> bool:
+        """
+        Check if the deployment has failed based on the current capsule and worker status.
+        """
+        return worker_semantic_status["status"]["at_least_one_crashlooping"]
+
+    @classmethod
+    def check_readiness_condition(
+        cls,
+        capsule_status: CapsuleStatus,
+        worker_semantic_status: "CapsuleWorkerSemanticStatus",
+        readiness_condition: str,
+    ) -> Tuple[bool, bool]:
+        """
+        Check if the deployment readiness condition is satisfied based on current capsule and worker status.
+
+        This method evaluates whether a deployment has reached its desired ready state according to
+        the specified readiness condition. Different conditions have different criteria for what
+        constitutes a "ready" deployment.
+
+        Parameters
+        ----------
+        capsule_status : CapsuleStatus
+            The current status of the capsule deployment, including update progress information.
+        worker_semantic_status : CapsuleWorkerSemanticStatus
+            Semantic status information about the workers, including counts and states.
+        readiness_condition : str
+            The readiness condition to evaluate. Must be one of the class constants:
+            - ATLEAST_ONE_RUNNING: At least one worker is running and update is not in progress
+            - ALL_RUNNING: All required workers are running and update is not in progress
+            - FULLY_FINISHED: All workers running with no pending/crashlooping workers and update is not in progress
+            - ASYNC: Deployment ready when update is no longer in progress
+
+        Returns
+        -------
+        Tuple[bool, bool]
+            A tuple containing:
+            - First element: Boolean indicating if the readiness condition is satisfied
+            - Second element: Boolean indicating if additional worker readiness checks
+              should be performed (False for ASYNC mode, True for all others)
+
+        Raises
+        ------
+        ValueError
+            If an invalid readiness condition is provided.
+        """
+        _worker_readiness_check = True
+        _readiness_condition_satisfied = False
+        if readiness_condition == cls.ATLEAST_ONE_RUNNING:
+            _readiness_condition_satisfied = (
+                worker_semantic_status["status"]["at_least_one_running"]
+                and not capsule_status["updateInProgress"]
+            )
+        elif readiness_condition == cls.ALL_RUNNING:
+            _readiness_condition_satisfied = (
+                worker_semantic_status["status"]["all_running"]
+                and not capsule_status["updateInProgress"]
+            )
+        elif readiness_condition == cls.FULLY_FINISHED:
+            _readiness_condition_satisfied = (
+                worker_semantic_status["status"]["fully_finished"]
+                and not capsule_status["updateInProgress"]
+            )
+        elif readiness_condition == cls.ASYNC:
+            _readiness_condition_satisfied = not capsule_status["updateInProgress"]
+            _worker_readiness_check = False
+        else:
+            raise ValueError(f"Invalid readiness condition: {readiness_condition}")
+
+        return _readiness_condition_satisfied, _worker_readiness_check
+
     @classmethod
     def docstring(cls):
         return cls.__doc__

outerbounds/apps/app_cli.py

@@ -223,6 +223,7 @@ class ColorTheme:
     LOADING_COLOR = "cyan"
     BAD_COLOR = "red"
     INFO_COLOR = "green"
+    DEBUG_COLOR = "yellow"
 
     TL_HEADER_COLOR = "magenta"
     ROW_COLOR = "bright_white"
@@ -439,6 +440,12 @@ def deployment_instance_options(func):
         help=DEPLOYMENT_READY_CONDITIONS.__doc__,
         default=DEPLOYMENT_READY_CONDITIONS.ATLEAST_ONE_RUNNING,
     )
+    @click.option(
+        "--status-file",
+        type=str,
+        help="The path to the file where the final status of the deployment will be written.",
+        default=None,
+    )
     @click.option(
         "--readiness-wait-time",
         type=int,
@@ -446,9 +453,10 @@ def deployment_instance_options(func):
         default=4,
     )
     @click.option(
-        "--max-wait-time",
+        "--deployment-timeout",
+        "max_wait_time",
         type=int,
-        help="The maximum time (in seconds) to wait for the deployment to be ready.",
+        help="The maximum time (in seconds) to wait for the deployment to reach readiness before timing out.",
         default=600,
     )
     @click.option(
@@ -702,6 +710,7 @@ def deploy(
     readiness_condition=None,
     max_wait_time=None,
     readiness_wait_time=None,
+    status_file=None,
     no_loader=False,
     **options,
 ):
@@ -801,9 +810,9 @@ def deploy(
             ctx.obj.app_state_dir, app_config.get("name", "default")
         )
 
-        def _non_spinner_logger(*msg):
+        def _non_spinner_logger(*msg, **kwargs):
             for m in msg:
-                logger(m)
+                logger(m, **kwargs)
 
         deploy_validations(
             app_config,
@@ -839,14 +848,34 @@ def deploy(
 
         app_config.set_state("perimeter", ctx.obj.perimeter)
 
+        capsule_spinner = None
+        capsule_logger = _non_spinner_logger
+        if not no_loader:
+            capsule_spinner = MultiStepSpinner(
+                text=lambda: _logger_styled(
+                    "💊 Waiting for %s %s to be ready to serve traffic"
+                    % (capsule.capsule_type.lower(), capsule.identifier),
+                    timestamp=True,
+                ),
+                color=ColorTheme.LOADING_COLOR,
+            )
+            capsule_logger = partial(_spinner_logger, capsule_spinner)
+            capsule_spinner.start()
+
+        _current_instance_debug_dir = os.path.join(
+            cache_dir, f"debug_deployment_instance_{time.time()}"
+        )
+        if CAPSULE_DEBUG:
+            os.makedirs(_current_instance_debug_dir, exist_ok=True)
         # 2. Convert to the IR that the backend accepts
         capsule = CapsuleDeployer(
             app_config,
             ctx.obj.api_url,
-            debug_dir=cache_dir,
+            debug_dir=_current_instance_debug_dir,
             success_terminal_state_condition=readiness_condition,
             create_timeout=max_wait_time,
             readiness_wait_time=readiness_wait_time,
+            logger_fn=capsule_logger,
         )
         currently_present_capsules = list_and_filter_capsules(
             capsule.capsule_api,
@@ -879,13 +908,13 @@ def deploy(
                         "If you wish to force upgrade, you can do so by providing the `--force-upgrade` flag."
                     )
                 raise AppConfigError(message)
-            logger(
+            capsule_logger(
                 f"🚀 {'' if not force_upgrade else 'Force'} Upgrading {capsule.capsule_type.lower()} `{capsule.name}`....",
                 color=ColorTheme.INFO_COLOR,
                 system_msg=True,
             )
         else:
-            logger(
+            capsule_logger(
                 f"🚀 Deploying {capsule.capsule_type.lower()} to the platform....",
                 color=ColorTheme.INFO_COLOR,
                 system_msg=True,
@@ -894,21 +923,9 @@ def deploy(
         capsule.create()
         _post_create_debug(capsule, cache_dir)
 
-        capsule_spinner = None
-        capsule_logger = _non_spinner_logger
-        if not no_loader:
-            capsule_spinner = MultiStepSpinner(
-                text=lambda: _logger_styled(
-                    "💊 Waiting for %s %s to be ready to serve traffic"
-                    % (capsule.capsule_type.lower(), capsule.identifier),
-                    timestamp=True,
-                ),
-                color=ColorTheme.LOADING_COLOR,
-            )
-            capsule_logger = partial(_spinner_logger, capsule_spinner)
-            capsule_spinner.start()
-
-        capsule.wait_for_terminal_state(logger=capsule_logger)
+        # We only get the `capsule_response` if the deployment is has reached
+        # a successful terminal state.
+        final_status = capsule.wait_for_terminal_state()
         if capsule_spinner:
             capsule_spinner.stop()
 
@@ -918,12 +935,35 @@ def deploy(
                 system_msg=True,
             )
 
+        if CAPSULE_DEBUG:
+            logger(
+                f"[debug] 💊 {capsule.capsule_type} {app_config.config['name']} ({capsule.identifier}) deployment status [on completion]: {final_status}",
+                color=ColorTheme.DEBUG_COLOR,
+            )
+            logger(
+                f"[debug] 💊 {capsule.capsule_type} {app_config.config['name']} ({capsule.identifier}) debug info saved to `{_current_instance_debug_dir}`",
+                color=ColorTheme.DEBUG_COLOR,
+            )
+            final_status["debug_dir"] = _current_instance_debug_dir
+
+        if status_file:
+            # Create the file if it doesn't exist
+            with open(status_file, "w") as f:
+                f.write(json.dumps(final_status, indent=4))
+            logger(
+                f"📝 {capsule.capsule_type} {app_config.config['name']} ({capsule.identifier}) deployment status written to {status_file}",
+                color=ColorTheme.INFO_COLOR,
+                system_msg=True,
+            )
+
     except Exception as e:
         logger(
             f"Deployment failed: [{e.__class__.__name__}]: {e}",
             bad=True,
             system_msg=True,
         )
+        if CAPSULE_DEBUG:
+            raise e
         exit(1)
 
 

outerbounds/apps/capsule.py

@@ -1,8 +1,11 @@
+from datetime import datetime
 import json
 import os
 import pathlib
 import requests
+import sys
 import time
+from functools import partial
 import shlex
 from typing import Optional, List, Dict, Any, Tuple, Union
 from .utils import TODOException, safe_requests_wrapper, MaximumRetriesExceeded
@@ -13,6 +16,7 @@ from ._state_machine import (
     _capsule_worker_status_diff,
     CapsuleWorkerSemanticStatus,
     WorkerStatus,
+    CapsuleStatus,
     DEPLOYMENT_READY_CONDITIONS,
 )
 
@@ -59,7 +63,7 @@ class CapsuleStateMachine:
     def get_status_trail(self):
         return self._status_trail
 
-    def add_status(self, status: dict):
+    def add_status(self, status: CapsuleStatus):
         assert type(status) == dict, "TODO: Make this check somewhere else"
         self._status_trail.append({"timestamp": time.time(), "status": status})
 
@@ -106,13 +110,10 @@ class CapsuleStateMachine:
     def report_current_status(self, logger):
         pass
 
-    def check_for_debug(self, state_dir: str):
-        if CAPSULE_DEBUG:
-            debug_path = os.path.join(
-                state_dir, f"debug_capsule_{self._capsule_id}.json"
-            )
-            with open(debug_path, "w") as f:
-                json.dump(self._status_trail, f, indent=4)
+    def save_debug_info(self, state_dir: str):
+        debug_path = os.path.join(state_dir, f"debug_capsule_{self._capsule_id}.json")
+        with open(debug_path, "w") as f:
+            json.dump(self._status_trail, f, indent=4)
 
 
 class CapsuleWorkersStateMachine:
@@ -156,19 +157,18 @@ class CapsuleWorkersStateMachine:
             {"timestamp": time.time(), "status": worker_list_response}
         )
 
-    def check_for_debug(self, state_dir: str):
-        if CAPSULE_DEBUG:
-            debug_path = os.path.join(
-                state_dir, f"debug_capsule_workers_{self._capsule_id}_trail.json"
-            )
-            with open(debug_path, "w") as f:
-                json.dump(self._status_trail, f, indent=4)
+    def save_debug_info(self, state_dir: str):
+        debug_path = os.path.join(
+            state_dir, f"debug_capsule_workers_{self._capsule_id}_trail.json"
+        )
+        with open(debug_path, "w") as f:
+            json.dump(self._status_trail, f, indent=4)
 
-            status_path = os.path.join(
-                state_dir, f"debug_capsule_workers_{self._capsule_id}_status.json"
-            )
-            with open(status_path, "w") as f:
-                json.dump(self.current_version_deployment_status(), f, indent=4)
+        status_path = os.path.join(
+            state_dir, f"debug_capsule_workers_{self._capsule_id}_status.json"
+        )
+        with open(status_path, "w") as f:
+            json.dump(self.current_version_deployment_status(), f, indent=4)
 
     def report_current_status(self, logger):
         if len(self._status_trail) == 0:
@@ -195,29 +195,7 @@ class CapsuleWorkersStateMachine:
         )
 
     @property
-    def is_terminal_state(self):
-        return any(
-            s is not None for s in [self.is_success_state, self.is_failure_state]
-        )
-
-    @property
-    def is_success_state(self):
-        status = self.current_version_deployment_status()
-        if self._deployment_mode == DEPLOYMENT_READY_CONDITIONS.ATLEAST_ONE_RUNNING:
-            return status["status"]["at_least_one_running"]
-        elif self._deployment_mode == DEPLOYMENT_READY_CONDITIONS.ALL_RUNNING:
-            return status["status"]["all_running"]
-        elif self._deployment_mode == DEPLOYMENT_READY_CONDITIONS.FULLY_FINISHED:
-            return (
-                status["status"]["current_info"]["running"] == self._minimum_replicas
-                and status["status"]["current_info"]["pending"] == 0
-                and status["status"]["current_info"]["crashlooping"] == 0
-            )
-        else:
-            raise ValueError(f"Unknown deployment mode: {self._deployment_mode}")
-
-    @property
-    def is_failure_state(self):
+    def is_crashlooping(self) -> bool:
         status = self.current_version_deployment_status()
         return status["status"]["at_least_one_crashlooping"]
 
@@ -351,19 +329,24 @@ class CapsuleApiException(Exception):
 
 
 class CapsuleDeploymentException(Exception):
-    def __init__(self, capsule_id: str, message: str):
+    def __init__(
+        self,
+        capsule_id: str,
+        message: str,
+    ):
         self.capsule_id = capsule_id
         self.message = message
 
     def __str__(self):
-        return f"CapsuleDeploymentException: {self.capsule_id} \n\n {self.message}"
+        return f"CapsuleDeploymentException: [{self.capsule_id}] :: {self.message}"
 
 
 class CapsuleApi:
-    def __init__(self, base_url: str, perimeter: str):
+    def __init__(self, base_url: str, perimeter: str, logger_fn=None):
         self._base_url = self._create_base_url(base_url, perimeter)
         from metaflow.metaflow_config import SERVICE_HEADERS
 
+        self._logger_fn = logger_fn
         self._request_headers = {
             **{"Content-Type": "application/json", "Connection": "keep-alive"},
             **(SERVICE_HEADERS or {}),
@@ -385,6 +368,7 @@ class CapsuleApi:
                 method_func,
                 *args,
                 headers=self._request_headers,
+                logger_fn=self._logger_fn,
                 **kwargs,
             )
         except MaximumRetriesExceeded as e:
@@ -599,10 +583,16 @@ class CapsuleDeployer:
         debug_dir: Optional[str] = None,
         success_terminal_state_condition: str = DEPLOYMENT_READY_CONDITIONS.ATLEAST_ONE_RUNNING,
         readiness_wait_time: int = 20,
+        logger_fn=None,
     ):
         self._app_config = app_config
-        self._capsule_api = CapsuleApi(base_url, app_config.get_state("perimeter"))
+        self._capsule_api = CapsuleApi(
+            base_url,
+            app_config.get_state("perimeter"),
+            logger_fn=logger_fn or partial(print, file=sys.stderr),
+        )
         self._create_timeout = create_timeout
+        self._logger_fn = logger_fn
         self._debug_dir = debug_dir
         self._capsule_deploy_response = None
         self._success_terminal_state_condition = success_terminal_state_condition
@@ -668,14 +658,19 @@ class CapsuleDeployer:
             )
 
     def _monitor_worker_readiness(
-        self, workers_sm: "CapsuleWorkersStateMachine", logger=print
+        self,
+        workers_sm: "CapsuleWorkersStateMachine",
     ):
-        """ """
+        """returns True if the worker is crashlooping, False otherwise"""
+        logger = self._logger_fn or partial(print, file=sys.stderr)
         for i in range(self._readiness_wait_time):
             time.sleep(1)
             workers_response = self.get_workers()
             workers_sm.add_status(workers_response)
             workers_sm.report_current_status(logger)
+            if workers_sm.is_crashlooping:
+                return True
+        return False
 
     def _extract_logs_from_crashlooping_worker(
         self, workers_sm: "CapsuleWorkersStateMachine"
@@ -696,13 +691,14 @@ class CapsuleDeployer:
 
     def wait_for_terminal_state(
         self,
-        logger=print,
     ):
         """ """
+        logger = self._logger_fn or partial(print, file=sys.stderr)
         state_machine = CapsuleStateMachine(
             self.identifier, self.current_deployment_instance_version
         )
-        min_replicas = self._app_config.get_state("replicas", {}).get("min", 1)
+        # min_replicas will always be present
+        min_replicas = self._app_config.get_state("replicas", {}).get("min")
         workers_state_machine = CapsuleWorkersStateMachine(
             self.identifier,
             self.current_deployment_instance_version,
@@ -729,10 +725,22 @@ class CapsuleDeployer:
             # of the workerstate machine. If we detect a terminal state in the workers,
             # then even if the capsule upgrade is still in progress we will end up crashing
             # the deployment.
-            if (
-                not state_machine.update_in_progress
-                and workers_state_machine.is_terminal_state
-            ) or (workers_state_machine.is_failure_state):
+            (
+                capsule_ready,
+                further_check_worker_readiness,
+            ) = DEPLOYMENT_READY_CONDITIONS.check_readiness_condition(
+                state_machine.current_status,
+                workers_state_machine.current_version_deployment_status(),
+                self._success_terminal_state_condition,
+            )
+
+            failure_condition_satisfied = (
+                DEPLOYMENT_READY_CONDITIONS.check_failure_condition(
+                    state_machine.current_status,
+                    workers_state_machine.current_version_deployment_status(),
+                )
+            )
+            if capsule_ready or failure_condition_satisfied:
                 logger(
                     "💊 %s deployment status: %s | worker states: [success :%s | failure :%s ] "
                     % (
@@ -740,19 +748,31 @@ class CapsuleDeployer:
                         "in progress"
                         if state_machine.update_in_progress
                         else "completed",
-                        workers_state_machine.is_success_state,
-                        workers_state_machine.is_failure_state,
+                        capsule_ready,
+                        failure_condition_satisfied,
                     )
                 )
-                if workers_state_machine.is_success_state:
+                _further_readiness_check_failed = False
+                if further_check_worker_readiness:
                     # HACK : monitor the workers for N seconds to make sure they are healthy
                     # this is a hack. Ideally we should implment a healtcheck as a first class citizen
                     # but it will take some time to do that so in the meanwhile a timeout set on the cli
                     # side will be really helpful.
-                    self._monitor_worker_readiness(workers_state_machine, logger)
+                    logger(
+                        "💊 running last minute readiness check for %s..."
+                        % self.identifier
+                    )
+                    _further_readiness_check_failed = self._monitor_worker_readiness(
+                        workers_state_machine
+                    )
+
+                if CAPSULE_DEBUG:
+                    logger(
+                        f"[debug] 💊 {self.capsule_type} {self.identifier}: further_check_worker_readiness {_further_readiness_check_failed} | failure_condition_satisfied {failure_condition_satisfied}"
+                    )
 
                 # We should still check for failure state and crash if we detect something in the readiness check
-                if workers_state_machine.is_failure_state:
+                if failure_condition_satisfied or _further_readiness_check_failed:
                     # hit the logs endpoint for the worker and get the logs
                     # Print those logs out on the terminal
                     # raise an exception that should be caught gracefully by the cli
@@ -787,13 +807,33 @@ class CapsuleDeployer:
 
                 break
 
-            if self._debug_dir:
-                state_machine.check_for_debug(self._debug_dir)
-                workers_state_machine.check_for_debug(self._debug_dir)
+            if CAPSULE_DEBUG and self._debug_dir:
+                state_machine.save_debug_info(self._debug_dir)
+                workers_state_machine.save_debug_info(self._debug_dir)
+                if i % 3 == 0:  # Every 3 seconds report the status
+                    logger(
+                        f"[debug] 💊 {self.capsule_type} {self.identifier} deployment status: {state_machine.current_status} | worker states: {workers_state_machine.current_status}"
+                    )
 
         if not self.status.ready_to_serve_traffic:
             raise CapsuleDeploymentException(
                 self.identifier,
                 f"Capsule {self.identifier} failed to be ready to serve traffic",
             )
-        return capsule_response
+
+        if CAPSULE_DEBUG and self._debug_dir:
+            state_machine.save_debug_info(self._debug_dir)
+            workers_state_machine.save_debug_info(self._debug_dir)
+            logger(
+                f"[debug] 💊 {self.capsule_type} {self.identifier} deployment status [on return]: {state_machine.current_status} | worker states: {workers_state_machine.current_status}"
+            )
+
+        return dict(
+            id=self.identifier,
+            auth_type=self.capsule_type,
+            public_url=self.status.out_of_cluster_url,
+            available_replicas=self.status.available_replicas,
+            name=self.name,
+            deployed_version=self.current_deployment_instance_version,
+            deployed_at=datetime.now().isoformat(),
+        )

outerbounds/apps/utils.py

@@ -176,6 +176,7 @@ def safe_requests_wrapper(
     *args,
     conn_error_retries=2,
     retryable_status_codes=[409],
+    logger_fn=None,
     **kwargs,
 ):
     """
@@ -206,10 +207,15 @@ def safe_requests_wrapper(
             if response.status_code not in retryable_status_codes:
                 return response
             if CAPSULE_DEBUG:
-                print(
-                    f"[outerbounds-debug] safe_requests_wrapper: {response.url}[{requests_module_fn.__name__}] {response.status_code} {response.text}",
-                    file=sys.stderr,
-                )
+                if logger_fn:
+                    logger_fn(
+                        f"[outerbounds-debug] safe_requests_wrapper: {response.url}[{requests_module_fn.__name__}] {response.status_code} {response.text}",
+                    )
+                else:
+                    print(
+                        f"[outerbounds-debug] safe_requests_wrapper: {response.url}[{requests_module_fn.__name__}] {response.status_code} {response.text}",
+                        file=sys.stderr,
+                    )
             _num_retries += 1
             time.sleep((2 ** (_num_retries + 1)) + noise)
         except requests.exceptions.ConnectionError:

{outerbounds-0.3.182rc1.dist-info → outerbounds-0.3.183rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: outerbounds
-Version: 0.3.182rc1
+Version: 0.3.183rc0
 Summary: More Data Science, Less Administration
 License: Proprietary
 Keywords: data science,machine learning,MLOps
@@ -28,9 +28,9 @@ Requires-Dist: google-auth (>=2.27.0,<3.0.0) ; extra == "gcp"
 Requires-Dist: google-cloud-secret-manager (>=2.20.0,<3.0.0) ; extra == "gcp"
 Requires-Dist: google-cloud-storage (>=2.14.0,<3.0.0) ; extra == "gcp"
 Requires-Dist: metaflow-checkpoint (==0.2.1)
-Requires-Dist: ob-metaflow (==2.15.17.1)
-Requires-Dist: ob-metaflow-extensions (==1.1.170rc1)
-Requires-Dist: ob-metaflow-stubs (==6.0.3.182rc1)
+Requires-Dist: ob-metaflow (==2.15.18.1)
+Requires-Dist: ob-metaflow-extensions (==1.1.171rc0)
+Requires-Dist: ob-metaflow-stubs (==6.0.3.183rc0)
 Requires-Dist: opentelemetry-distro (>=0.41b0) ; extra == "otel"
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.20.0) ; extra == "otel"
 Requires-Dist: opentelemetry-instrumentation-requests (>=0.41b0) ; extra == "otel"

{outerbounds-0.3.182rc1.dist-info → outerbounds-0.3.183rc0.dist-info}/RECORD

@@ -43,11 +43,11 @@ outerbounds/_vendor/yaml/scanner.py,sha256=ZcI8IngR56PaQ0m27WU2vxCqmDCuRjz-hr7pi
 outerbounds/_vendor/yaml/serializer.py,sha256=8wFZRy9SsQSktF_f9OOroroqsh4qVUe53ry07P9UgCc,4368
 outerbounds/_vendor/yaml/tokens.py,sha256=JBSu38wihGr4l73JwbfMA7Ks1-X84g8-NskTz7KwPmA,2578
 outerbounds/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-outerbounds/apps/_state_machine.py,sha256=eAJFNt_9kwE70XyXoMU107TrzPRnb2xcAyVtXV1yAGc,14646
-outerbounds/apps/app_cli.py,sha256=vTbIN43A9A_OHTM0I6cb28g3GtY4_jk1wmUi5wG09w0,50174
+outerbounds/apps/_state_machine.py,sha256=PaegyxSxNZxyLTxU9_kekd3MPM9sW76RZPkibeMTMfY,18314
+outerbounds/apps/app_cli.py,sha256=n_NABDjdgY4ApgNvdQMmpJfPGzCwJxr_G0w6-5LZ85I,51940
 outerbounds/apps/app_config.py,sha256=UHVK8JLIuW-OcGg5WxDm4QHeImPGtohD4KpJryZntC4,11307
 outerbounds/apps/artifacts.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-outerbounds/apps/capsule.py,sha256=VTMS0qp0q7PiaMTyRgO5jmX_2BvSzYgNyODn9G377aQ,31151
+outerbounds/apps/capsule.py,sha256=NC9ajD06y6U-COi-8Qw6k_N1ltbQAio2O_Xs2RTrAVA,32857
 outerbounds/apps/cli_to_config.py,sha256=Thc5jXRxoU6Pr8kAVVOX-5Es5ha6y6Vh_GBzL__oI7Q,3299
 outerbounds/apps/click_importer.py,sha256=nnkPOR6TKrtIpc3a5Fna1zVJoQqDZvUXlNA9CdiNKFc,995
 outerbounds/apps/code_package/__init__.py,sha256=8McF7pgx8ghvjRnazp2Qktlxi9yYwNiwESSQrk-2oW8,68
@@ -59,7 +59,7 @@ outerbounds/apps/deployer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 outerbounds/apps/experimental/__init__.py,sha256=RUZBAyqFnX3pRQxTjNmS1-qpgQcc9xQGQD2yJh4MA_M,3349
 outerbounds/apps/perimeters.py,sha256=1J1_-5legFPskv3HTRwQMpzTytE3TO8KRT2IvVOrWcQ,1584
 outerbounds/apps/secrets.py,sha256=aWzcAayQEJghQgFP_qp9w6jyvan_hoL4_ceqZ0ZjLd4,6126
-outerbounds/apps/utils.py,sha256=6REvD9PtJcLYzrxX5lZ5Dzzm-Sy2l-I1oSzQN9viYRs,7611
+outerbounds/apps/utils.py,sha256=C-4GLU5GHwwWHbW962Qac-wecvtdiBXezq0c8i9aJvs,7908
 outerbounds/apps/validations.py,sha256=kR2eXckx0XJ4kUOOLkMRepbTh0INtL1Z8aV4-fZpfc8,678
 outerbounds/cli_main.py,sha256=e9UMnPysmc7gbrimq2I4KfltggyU7pw59Cn9aEguVcU,74
 outerbounds/command_groups/__init__.py,sha256=QPWtj5wDRTINDxVUL7XPqG3HoxHNvYOg08EnuSZB2Hc,21
@@ -78,7 +78,7 @@ outerbounds/utils/metaflowconfig.py,sha256=l2vJbgPkLISU-XPGZFaC8ZKmYFyJemlD6bwB-
 outerbounds/utils/schema.py,sha256=lMUr9kNgn9wy-sO_t_Tlxmbt63yLeN4b0xQXbDUDj4A,2331
 outerbounds/utils/utils.py,sha256=4Z8cszNob_8kDYCLNTrP-wWads_S_MdL3Uj3ju4mEsk,501
 outerbounds/vendor.py,sha256=gRLRJNXtZBeUpPEog0LOeIsl6GosaFFbCxUvR4bW6IQ,5093
-outerbounds-0.3.182rc1.dist-info/METADATA,sha256=qJ6vJ908OYQf8CI05n_Ak06Akkm02ZxyzQPCVJJ9drc,1846
-outerbounds-0.3.182rc1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-outerbounds-0.3.182rc1.dist-info/entry_points.txt,sha256=AP6rZg7y5SK9e9a9iVq0Fi9Q2KPjPZSwtZ6R98rLw-8,56
-outerbounds-0.3.182rc1.dist-info/RECORD,,
+outerbounds-0.3.183rc0.dist-info/METADATA,sha256=wY0FgePmu807U8X1eBnglevz656zQgPuAjooGlbNpMU,1846
+outerbounds-0.3.183rc0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+outerbounds-0.3.183rc0.dist-info/entry_points.txt,sha256=AP6rZg7y5SK9e9a9iVq0Fi9Q2KPjPZSwtZ6R98rLw-8,56
+outerbounds-0.3.183rc0.dist-info/RECORD,,