outerbounds 0.3.182rc2__py3-none-any.whl → 0.3.183rc1__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,86 @@ 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 is ready when the backend registers the current serving version in the capsule's status.
+
+        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:
+            # The async readiness condition is satisfied when the currently served version is the same as the final version.
+            _readiness_condition_satisfied = (
+                capsule_status["currentlyServedVersion"]
+                == worker_semantic_status["final_version"]
+            )
+            _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__
@@ -206,6 +299,7 @@ class DEPLOYMENT_READY_CONDITIONS:
             cls.ATLEAST_ONE_RUNNING,
             cls.ALL_RUNNING,
             cls.FULLY_FINISHED,
+            cls.ASYNC,
         ]
 
 

outerbounds/apps/app_cli.py

@@ -21,8 +21,6 @@ from typing import Dict, List, Any, Optional, Union
 # way to figure the right import of click dynamically. a neat way to handle that would be
 # to have a function that can import the correct click based on the context in which stuff is being loaded.
 from .click_importer import click
-from outerbounds._vendor import yaml
-from outerbounds.utils import metaflowconfig
 from .app_config import (
     AppConfig,
     AppConfigError,
@@ -223,6 +221,7 @@ class ColorTheme:
     LOADING_COLOR = "cyan"
     BAD_COLOR = "red"
     INFO_COLOR = "green"
+    DEBUG_COLOR = "yellow"
 
     TL_HEADER_COLOR = "magenta"
     ROW_COLOR = "bright_white"
@@ -298,7 +297,7 @@ def _pre_create_debug(
 ):
     if CAPSULE_DEBUG:
         os.makedirs(state_dir, exist_ok=True)
-        debug_path = os.path.join(state_dir, f"debug_{time.time()}.yaml")
+        debug_path = os.path.join(state_dir, f"debug_{time.time()}.json")
         with open(
             debug_path,
             "w",
@@ -321,14 +320,10 @@ def _pre_create_debug(
 def _post_create_debug(capsule: CapsuleDeployer, state_dir: str):
     if CAPSULE_DEBUG:
         debug_path = os.path.join(
-            state_dir, f"debug_deploy_response_{time.time()}.yaml"
+            state_dir, f"debug_deploy_response_{time.time()}.json"
         )
         with open(debug_path, "w") as f:
-            f.write(
-                yaml.dump(
-                    capsule._capsule_deploy_response, default_flow_style=False, indent=2
-                )
-            )
+            f.write(json.dumps(capsule._capsule_deploy_response, indent=2, default=str))
 
 
 def _bake_image(app_config: AppConfig, cache_dir: str, logger):
@@ -718,7 +713,7 @@ def deploy(
 
     if not ctx.obj.perimeter:
         raise AppConfigError("OB_CURRENT_PERIMETER is not set")
-
+    _current_instance_debug_dir = None
     logger = partial(_logger, timestamp=True)
     try:
         _cli_parsed_config = build_config_from_options(options)
@@ -809,9 +804,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,
@@ -847,15 +842,35 @@ def deploy(
 
         app_config.set_state("perimeter", ctx.obj.perimeter)
 
+        capsule_spinner = None
+        capsule_logger = _non_spinner_logger
         # 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,
         )
+        _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)
+        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()
+
         currently_present_capsules = list_and_filter_capsules(
             capsule.capsule_api,
             None,
@@ -887,13 +902,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,
@@ -902,23 +917,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()
-
         # We only get the `capsule_response` if the deployment is has reached
         # a successful terminal state.
-        final_status = capsule.wait_for_terminal_state(logger=capsule_logger)
+        final_status = capsule.wait_for_terminal_state()
         if capsule_spinner:
             capsule_spinner.stop()
 
@@ -928,6 +929,17 @@ 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:
@@ -939,11 +951,19 @@ def deploy(
             )
 
     except Exception as e:
+        message = getattr(e, "message", str(e))
         logger(
-            f"Deployment failed: [{e.__class__.__name__}]: {e}",
+            f"Deployment failed: [{e.__class__.__name__}]: {message}",
             bad=True,
             system_msg=True,
         )
+        if CAPSULE_DEBUG:
+            if _current_instance_debug_dir is not None:
+                logger(
+                    f"[debug] 💊 debug info saved to `{_current_instance_debug_dir}`",
+                    color=ColorTheme.DEBUG_COLOR,
+                )
+            raise e
         exit(1)
 
 

outerbounds/apps/app_config.py

@@ -1,5 +1,7 @@
 import json
 import os
+
+# TODO: remove vendor'd dependency where.
 from outerbounds._vendor import yaml
 from typing import Dict, Any
 from .cli_to_config import build_config_from_options
@@ -58,6 +60,7 @@ class AppConfig:
     @staticmethod
     def _load_schema():
         """Load the configuration schema from the YAML file."""
+        # TODO: Make it easier.
         schema_path = os.path.join(os.path.dirname(__file__), "config_schema.yaml")
         with open(schema_path, "r") as f:
             return yaml.safe_load(f)

outerbounds/apps/capsule.py

@@ -3,7 +3,9 @@ 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
@@ -14,6 +16,7 @@ from ._state_machine import (
     _capsule_worker_status_diff,
     CapsuleWorkerSemanticStatus,
     WorkerStatus,
+    CapsuleStatus,
     DEPLOYMENT_READY_CONDITIONS,
 )
 
@@ -60,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})
 
@@ -107,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:
@@ -157,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:
@@ -196,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"]
 
@@ -352,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 {}),
@@ -386,6 +368,7 @@ class CapsuleApi:
                 method_func,
                 *args,
                 headers=self._request_headers,
+                logger_fn=self._logger_fn,
                 **kwargs,
             )
         except MaximumRetriesExceeded as e:
@@ -600,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
@@ -669,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"
@@ -697,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,
@@ -730,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 ] "
                     % (
@@ -741,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
@@ -788,9 +807,13 @@ 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(
@@ -798,6 +821,13 @@ class CapsuleDeployer:
                 f"Capsule {self.identifier} failed to be ready to serve traffic",
             )
 
+        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,

outerbounds/apps/config_schema.yaml

@@ -5,6 +5,11 @@ description: |
   How to read this schema:
     1. If the a property has `allow_union`:true then it will allow overrides from the cli.
     2. If a property has `experimental` set to true then a lot its validations may-be skipped and parsing handled somewhere else.
+
+  The YAML based schema file is for Humans to change and consume. The JSON based schema file is what gets autogenerated based on pre-commit
+  hooks so that we can use within the outerbounds package. The reasons for two distinct types of files it that YAML provides the ability to
+  add comments and make readability easier. While JSON is so that we can reduce the dependency on YAML when working with apps within both
+  Metaflow and OB package.
 version: 1.0.0
 type: object
 required:

outerbounds/apps/config_schema_autogen.json

@@ -0,0 +1,336 @@
+{
+  "title": "Outerbounds App Configuration Schema",
+  "description": "Schema for defining Outerbounds Apps configuration. This schema is what we will end up using on the CLI/programmatic interface.\nHow to read this schema:\n  1. If the a property has `allow_union`:true then it will allow overrides from the cli.\n  2. If a property has `experimental` set to true then a lot its validations may-be skipped and parsing handled somewhere else.\n\nThe YAML based schema file is for Humans to change and consume. The JSON based schema file is what gets autogenerated based on pre-commit\nhooks so that we can use within the outerbounds package. The reasons for two distinct types of files it that YAML provides the ability to\nadd comments and make readability easier. While JSON is so that we can reduce the dependency on YAML when working with apps within both\nMetaflow and OB package.\n",
+  "version": "1.0.0",
+  "type": "object",
+  "required": [
+    "name",
+    "port"
+  ],
+  "properties": {
+    "name": {
+      "allow_union": true,
+      "type": "string",
+      "description": "The name of the app to deploy.",
+      "maxLength": 20,
+      "example": "myapp"
+    },
+    "port": {
+      "allow_union": false,
+      "type": "integer",
+      "description": "Port where the app is hosted. When deployed this will be port on which we will deploy the app.",
+      "minimum": 1,
+      "maximum": 65535,
+      "example": 8000
+    },
+    "tags": {
+      "allow_union": true,
+      "type": "array",
+      "description": "The tags of the app to deploy.",
+      "items": {
+        "type": "object"
+      },
+      "example": [
+        {
+          "foo": "bar"
+        },
+        {
+          "x": "y"
+        }
+      ]
+    },
+    "description": {
+      "allow_union": true,
+      "type": "string",
+      "description": "The description of the app to deploy.",
+      "example": "This is a description of my app."
+    },
+    "force_upgrade": {
+      "allow_union": true,
+      "type": "boolean",
+      "description": "Whether to force upgrade the app even if it is currently being upgraded.",
+      "example": true
+    },
+    "app_type": {
+      "allow_union": true,
+      "type": "string",
+      "description": "The User defined type of app to deploy. Its only used for bookkeeping purposes.",
+      "example": "MyCustomAgent"
+    },
+    "image": {
+      "allow_union": true,
+      "type": "string",
+      "description": "The Docker image to deploy with the App."
+    },
+    "secrets": {
+      "allow_union": true,
+      "type": "array",
+      "description": "Outerbounds integrations to attach to the app. You can use the value you set in the `@secrets` decorator in your code.",
+      "items": {
+        "type": "string"
+      },
+      "example": [
+        "hf-token"
+      ]
+    },
+    "environment": {
+      "allow_union": true,
+      "type": "object",
+      "description": "Environment variables to deploy with the App.",
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "number"
+          },
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "object"
+          },
+          {
+            "type": "array"
+          }
+        ]
+      },
+      "example": {
+        "DEBUG": true,
+        "DATABASE_CONFIG": {
+          "host": "localhost",
+          "port": 5432
+        },
+        "ALLOWED_ORIGINS": [
+          "http://localhost:3000",
+          "https://myapp.com"
+        ]
+      }
+    },
+    "dependencies": {
+      "allow_union": false,
+      "type": "object",
+      "description": "The dependencies to attach to the app. Only one of the properties can be specified.\n",
+      "properties": {
+        "from_requirements_file": {
+          "type": "string",
+          "description": "The path to the requirements.txt file to attach to the app.",
+          "example": "requirements.txt"
+        },
+        "from_pyproject_toml": {
+          "type": "string",
+          "description": "The path to the pyproject.toml file to attach to the app.",
+          "example": "pyproject.toml"
+        },
+        "python": {
+          "type": "string",
+          "description": "The Python version to use for the app.\n",
+          "example": "3.10"
+        },
+        "pypi": {
+          "type": "object",
+          "description": "A dictionary of pypi dependencies to attach to the app.\nThe key is the package name and the value is the version.\n",
+          "example": {
+            "numpy": "1.23.0",
+            "pandas": ""
+          }
+        },
+        "conda": {
+          "type": "object",
+          "description": "A dictionary of pypi dependencies to attach to the app.\nThe key is the package name and the value is the version.\n",
+          "example": {
+            "numpy": "1.23.0",
+            "pandas": ""
+          }
+        }
+      }
+    },
+    "package": {
+      "allow_union": false,
+      "type": "object",
+      "description": "Configurations associated with packaging the app.\n",
+      "properties": {
+        "src_path": {
+          "type": "string",
+          "description": "The path to the source code to deploy with the App.",
+          "example": "./"
+        },
+        "suffixes": {
+          "type": "array",
+          "description": "A list of suffixes to add to the source code to deploy with the App.\n",
+          "items": {
+            "type": "string"
+          },
+          "example": [
+            ".py",
+            ".ipynb"
+          ]
+        }
+      }
+    },
+    "commands": {
+      "allow_union": false,
+      "type": "array",
+      "description": "A list of commands to run the app with. Cannot be configured from the CLI. Only used in `run` command.",
+      "items": {
+        "type": "string"
+      },
+      "example": [
+        "python app.py",
+        "python app.py --foo bar"
+      ]
+    },
+    "resources": {
+      "allow_union": true,
+      "type": "object",
+      "properties": {
+        "cpu": {
+          "type": "string",
+          "description": "CPU resource request and limit.",
+          "example": "500m",
+          "default": "1"
+        },
+        "memory": {
+          "type": "string",
+          "description": "Memory resource request and limit.",
+          "example": "512Mi",
+          "default": "4Gi"
+        },
+        "gpu": {
+          "type": "string",
+          "description": "GPU resource request and limit.",
+          "example": "1"
+        },
+        "storage": {
+          "type": "string",
+          "description": "Storage resource request and limit.",
+          "example": "1Gi",
+          "default": "10Gi"
+        }
+      }
+    },
+    "replicas": {
+      "allow_union": true,
+      "type": "object",
+      "description": "The number of replicas to deploy the app with.\n",
+      "properties": {
+        "min": {
+          "type": "integer",
+          "description": "The minimum number of replicas to deploy the app with.",
+          "example": 1
+        },
+        "max": {
+          "type": "integer",
+          "description": "The maximum number of replicas to deploy the app with.",
+          "example": 10
+        }
+      }
+    },
+    "health_check": {
+      "type": "object",
+      "allow_union": false,
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Whether to enable health checks.",
+          "example": true,
+          "default": false
+        },
+        "path": {
+          "type": "string",
+          "description": "The path for health checks.",
+          "example": "/health"
+        },
+        "initial_delay_seconds": {
+          "type": "integer",
+          "description": "Number of seconds to wait before performing the first health check.",
+          "example": 10
+        },
+        "period_seconds": {
+          "type": "integer",
+          "description": "How often to perform the health check.",
+          "example": 30
+        }
+      }
+    },
+    "compute_pools": {
+      "allow_union": true,
+      "type": "array",
+      "description": "A list of compute pools to deploy the app to.\n",
+      "items": {
+        "type": "string"
+      },
+      "example": [
+        "default",
+        "large"
+      ]
+    },
+    "auth": {
+      "allow_union": false,
+      "type": "object",
+      "description": "Auth related configurations.\n",
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "The type of authentication to use for the app.\n",
+          "enum": [
+            "API",
+            "Browser"
+          ]
+        },
+        "public": {
+          "type": "boolean",
+          "description": "Whether the app is public or not.\n",
+          "default": true
+        }
+      }
+    },
+    "project": {
+      "type": "string",
+      "description": "The project name to deploy the app to.",
+      "experimental": true,
+      "allow_union": true
+    },
+    "branch": {
+      "type": "string",
+      "description": "The branch name to deploy the app to.",
+      "experimental": true,
+      "allow_union": true
+    },
+    "models": {
+      "type": "array",
+      "description": "model asset ids to include with the deployment. NO CLI Option for this Now.",
+      "experimental": true,
+      "allow_union": true,
+      "items": {
+        "type": "object",
+        "properties": {
+          "asset_id": {
+            "type": "string"
+          },
+          "asset_instance_id": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "data": {
+      "type": "array",
+      "description": "data asset ids to include with the deployment.",
+      "experimental": true,
+      "allow_union": true,
+      "items": {
+        "type": "object",
+        "properties": {
+          "asset_id": {
+            "type": "string"
+          },
+          "asset_instance_id": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

outerbounds/apps/utils.py

@@ -17,6 +17,7 @@ import logging
 import itertools
 from typing import Union, Callable, Any, List
 
+# TODO: remove vendor'd dependency where.
 from outerbounds._vendor.spinner import (
     Spinners,
 )
@@ -176,6 +177,7 @@ def safe_requests_wrapper(
     *args,
     conn_error_retries=2,
     retryable_status_codes=[409],
+    logger_fn=None,
     **kwargs,
 ):
     """
@@ -206,10 +208,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.182rc2.dist-info → outerbounds-0.3.183rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: outerbounds
-Version: 0.3.182rc2
+Version: 0.3.183rc1
 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.170rc2)
-Requires-Dist: ob-metaflow-stubs (==6.0.3.182rc2)
+Requires-Dist: ob-metaflow (==2.15.18.1)
+Requires-Dist: ob-metaflow-extensions (==1.1.171rc1)
+Requires-Dist: ob-metaflow-stubs (==6.0.3.183rc1)
 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.182rc2.dist-info → outerbounds-0.3.183rc1.dist-info}/RECORD

@@ -43,23 +43,24 @@ 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=0TCSxkKz9psJMGULMJcqXvrEJNibBDUTVoY37N5pcIk,51003
-outerbounds/apps/app_config.py,sha256=UHVK8JLIuW-OcGg5WxDm4QHeImPGtohD4KpJryZntC4,11307
+outerbounds/apps/_state_machine.py,sha256=uv3tGOWxqY0NdQdsjg3uvPpBu0JeniE41AE9_H7El5c,18601
+outerbounds/apps/app_cli.py,sha256=bblWHLC9h6VCaXYnVndrrpmcuahapbsR9NzeU4rX84I,52107
+outerbounds/apps/app_config.py,sha256=ixxeOlZD0AB2TFoN-mzeqEqduGriTSCsdFFm23bVpqw,11382
 outerbounds/apps/artifacts.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-outerbounds/apps/capsule.py,sha256=8ZoEjLwcUvbps6H03hkl25cAGj8pyaVNziaAK8AZTxY,31523
+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
 outerbounds/apps/code_package/code_packager.py,sha256=RWvM5BKjgLhu7icsO_n5SSYC57dwyST0dWpoWF88ovU,22881
 outerbounds/apps/code_package/examples.py,sha256=aF8qKIJxCVv_ugcShQjqUsXKKKMsm1oMkQIl8w3QKuw,4016
-outerbounds/apps/config_schema.yaml,sha256=j_mysTAPkIMSocItTg3aduMDfBs2teIhAErvpF0Elus,8826
+outerbounds/apps/config_schema.yaml,sha256=85g2khmkZg5pduilcOXMgn5m2I3DF_2WrRMjo5WsojM,9272
+outerbounds/apps/config_schema_autogen.json,sha256=Mu9y6n-ophJ-48M9kBU4_tL6I9Y5nl06lMyufGMfOF8,9855
 outerbounds/apps/dependencies.py,sha256=03pZY-JRN-dYN-iyZ73zoEIEKmrOvbY4qld7RlRXYuw,3976
 outerbounds/apps/deployer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=Yvoj1NFoIBqqaWQ32530saCb66B_juSiDOanH0CJJDE,7950
 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 +79,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.182rc2.dist-info/METADATA,sha256=QNhNeHMNuCMReA27whbsen3OPIniLUinbQ3ScvLfQLc,1846
-outerbounds-0.3.182rc2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-outerbounds-0.3.182rc2.dist-info/entry_points.txt,sha256=AP6rZg7y5SK9e9a9iVq0Fi9Q2KPjPZSwtZ6R98rLw-8,56
-outerbounds-0.3.182rc2.dist-info/RECORD,,
+outerbounds-0.3.183rc1.dist-info/METADATA,sha256=Szdy_WqZjvdilRX2b-KlnLVKg6T3bGlmGCOQzlHNyRw,1846
+outerbounds-0.3.183rc1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+outerbounds-0.3.183rc1.dist-info/entry_points.txt,sha256=AP6rZg7y5SK9e9a9iVq0Fi9Q2KPjPZSwtZ6R98rLw-8,56
+outerbounds-0.3.183rc1.dist-info/RECORD,,