ob-metaflow-extensions 1.1.123rc2__py2.py3-none-any.whl → 1.1.124__py2.py3-none-any.whl

metaflow_extensions/outerbounds/plugins/__init__.py

@@ -319,7 +319,6 @@ STEP_DECORATORS_DESC = [
     ("snowpark", ".snowpark.snowpark_decorator.SnowparkDecorator"),
     ("tensorboard", ".tensorboard.TensorboardDecorator"),
     ("gpu_profile", ".profilers.gpu_profile_decorator.GPUProfileDecorator"),
-    ("app_deploy", ".apps.deploy_decorator.WorkstationAppDeployDecorator"),
 ]
 FLOW_DECORATORS_DESC = [("nim", ".nim.NimDecorator")]
 TOGGLE_STEP_DECORATOR = [

{ob_metaflow_extensions-1.1.123rc2.dist-info → ob_metaflow_extensions-1.1.124.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: ob-metaflow-extensions
-Version: 1.1.123rc2
+Version: 1.1.124
 Summary: Outerbounds Platform Extensions for Metaflow
 Author: Outerbounds, Inc.
 License: Commercial
 Description-Content-Type: text/markdown
 Requires-Dist: boto3
 Requires-Dist: kubernetes
-Requires-Dist: ob-metaflow (==2.13.8.1)
+Requires-Dist: ob-metaflow (==2.13.9.1)
 
 # Outerbounds platform package
 

{ob_metaflow_extensions-1.1.123rc2.dist-info → ob_metaflow_extensions-1.1.124.dist-info}/RECORD

@@ -1,13 +1,9 @@
 metaflow_extensions/outerbounds/__init__.py,sha256=TRGvIUMjkfneWtYUFSWoubu_Kf2ekAL4WLbV3IxOj9k,499
 metaflow_extensions/outerbounds/remote_config.py,sha256=Zpfpjgz68_ZgxlXezjzlsDLo4840rkWuZgwDB_5H57U,4059
 metaflow_extensions/outerbounds/config/__init__.py,sha256=JsQGRuGFz28fQWjUvxUgR8EKBLGRdLUIk_buPLJplJY,1225
-metaflow_extensions/outerbounds/plugins/__init__.py,sha256=0M_MbFmDcHRYs9mJ7SFDT1hmXkVEhzEEWRgUU7mEt2w,12844
+metaflow_extensions/outerbounds/plugins/__init__.py,sha256=QDcoAAiLEWG1-_mZhpswwtgtCZJvyGEsZOhNau7S9L4,12768
 metaflow_extensions/outerbounds/plugins/auth_server.py,sha256=_Q9_2EL0Xy77bCRphkwT1aSu8gQXRDOH-Z-RxTUO8N4,2202
 metaflow_extensions/outerbounds/plugins/perimeters.py,sha256=QXh3SFP7GQbS-RAIxUOPbhPzQ7KDFVxZkTdKqFKgXjI,2697
-metaflow_extensions/outerbounds/plugins/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metaflow_extensions/outerbounds/plugins/apps/app_utils.py,sha256=JrVKlbRx8-nSmI4cRrB7F8BQGDHleABIYZudK4P-XFE,7905
-metaflow_extensions/outerbounds/plugins/apps/deploy_decorator.py,sha256=oHCkcXHYIoCi9LujhBsJsktZM44Zkf4d_g4RHLsiW18,5858
-metaflow_extensions/outerbounds/plugins/apps/supervisord_utils.py,sha256=QDM7s-iVKnnmE7fM8K-nFoLojQvL_cT8hUj1LF1JOBs,8372
 metaflow_extensions/outerbounds/plugins/fast_bakery/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metaflow_extensions/outerbounds/plugins/fast_bakery/docker_environment.py,sha256=i6F3FXwvEhkmUCTHDJ4VmSoL6vKyQhC_YRCtY6F4EkA,14209
 metaflow_extensions/outerbounds/plugins/fast_bakery/fast_bakery.py,sha256=cj63FrdioggipQFP8GwgxU3FYe6IyzjGSUGYxLQZ4nQ,5189
@@ -48,7 +44,7 @@ metaflow_extensions/outerbounds/toplevel/plugins/azure/__init__.py,sha256=WUuhz2
 metaflow_extensions/outerbounds/toplevel/plugins/gcp/__init__.py,sha256=BbZiaH3uILlEZ6ntBLKeNyqn3If8nIXZFq_Apd7Dhco,70
 metaflow_extensions/outerbounds/toplevel/plugins/kubernetes/__init__.py,sha256=5zG8gShSj8m7rgF4xgWBZFuY3GDP5n1T0ktjRpGJLHA,69
 metaflow_extensions/outerbounds/toplevel/plugins/snowflake/__init__.py,sha256=LptpH-ziXHrednMYUjIaosS1SXD3sOtF_9_eRqd8SJw,50
-ob_metaflow_extensions-1.1.123rc2.dist-info/METADATA,sha256=JYsmhOhSHRHULTOGp9b7wA3UE-KKMg6b4x-9BMcfHGc,523
-ob_metaflow_extensions-1.1.123rc2.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
-ob_metaflow_extensions-1.1.123rc2.dist-info/top_level.txt,sha256=NwG0ukwjygtanDETyp_BUdtYtqIA_lOjzFFh1TsnxvI,20
-ob_metaflow_extensions-1.1.123rc2.dist-info/RECORD,,
+ob_metaflow_extensions-1.1.124.dist-info/METADATA,sha256=_3jU-slK-7GJKkydQ1poaPiU9iomr6p0VU-HMK70gX4,520
+ob_metaflow_extensions-1.1.124.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
+ob_metaflow_extensions-1.1.124.dist-info/top_level.txt,sha256=NwG0ukwjygtanDETyp_BUdtYtqIA_lOjzFFh1TsnxvI,20
+ob_metaflow_extensions-1.1.124.dist-info/RECORD,,

metaflow_extensions/outerbounds/plugins/apps/app_utils.py

@@ -1,170 +0,0 @@
-from metaflow.exception import MetaflowException
-import os
-from metaflow.metaflow_config_funcs import init_config
-import requests
-import time
-import random
-
-# IMPORTANT: Currently contents of this file are mostly duplicated from the outerbounds package.
-# This is purely due to the time rush of having to deliver this feature. As a fast forward, we
-# will reorganize things in a way that the amount of duplication in minimum.
-
-
-APP_READY_POLL_TIMEOUT_SECONDS = 300
-# Even after our backend validates that the app routes are ready, it takes a few seconds for
-# the app to be accessible via the browser. Till we hunt down this delay, add an extra buffer.
-APP_READY_EXTRA_BUFFER_SECONDS = 30
-
-
-def start_app(port=-1, name=""):
-    if len(name) == 0 or len(name) >= 20:
-        raise MetaflowException("App name should not be more than 20 characters long.")
-    elif not name.isalnum() or not name.islower():
-        raise MetaflowException(
-            "App name can only contain lowercase alphanumeric characters."
-        )
-
-    if "WORKSTATION_ID" not in os.environ:
-        raise MetaflowException(
-            "All outerbounds app commands can only be run from a workstation."
-        )
-
-    workstation_id = os.environ["WORKSTATION_ID"]
-
-    try:
-        try:
-            conf = init_config()
-            metaflow_token = conf["METAFLOW_SERVICE_AUTH_KEY"]
-            api_url = conf["OBP_API_SERVER"]
-
-            workstations_response = requests.get(
-                f"https://{api_url}/v1/workstations",
-                headers={"x-api-key": metaflow_token},
-            )
-            workstations_response.raise_for_status()
-        except:
-            raise MetaflowException("Failed to list workstations!")
-
-        workstations_json = workstations_response.json()["workstations"]
-        for workstation in workstations_json:
-            if workstation["instance_id"] == os.environ["WORKSTATION_ID"]:
-                if "named_ports" in workstation["spec"]:
-                    try:
-                        ensure_app_start_request_is_valid(
-                            workstation["spec"]["named_ports"], port, name
-                        )
-                    except ValueError as e:
-                        raise MetaflowException(str(e))
-
-                    for named_port in workstation["spec"]["named_ports"]:
-                        if int(named_port["port"]) == port:
-                            if named_port["enabled"] and named_port["name"] == name:
-                                print(f"App {name} started on port {port}!")
-                                print(
-                                    f"Browser URL: https://{api_url.replace('api', 'ui')}/apps/{os.environ['WORKSTATION_ID']}/{name}/"
-                                )
-                                print(
-                                    f"API URL: https://{api_url}/apps/{os.environ['WORKSTATION_ID']}/{name}/"
-                                )
-                                return
-                            else:
-                                try:
-                                    response = requests.put(
-                                        f"https://{api_url}/v1/workstations/update/{workstation_id}/namedports",
-                                        headers={"x-api-key": metaflow_token},
-                                        json={
-                                            "port": port,
-                                            "name": name,
-                                            "enabled": True,
-                                        },
-                                    )
-
-                                    response.raise_for_status()
-                                    poll_success = wait_for_app_port_to_be_accessible(
-                                        api_url,
-                                        metaflow_token,
-                                        workstation_id,
-                                        name,
-                                        APP_READY_POLL_TIMEOUT_SECONDS,
-                                    )
-                                    if poll_success:
-                                        print(f"App {name} started on port {port}!")
-                                        print(
-                                            f"Browser URL: https://{api_url.replace('api', 'ui')}/apps/{os.environ['WORKSTATION_ID']}/{name}/"
-                                        )
-                                        print(
-                                            f"API URL: https://{api_url}/apps/{os.environ['WORKSTATION_ID']}/{name}/"
-                                        )
-                                    else:
-                                        raise MetaflowException(
-                                            f"The app could not be deployed in {APP_READY_POLL_TIMEOUT_SECONDS / 60} minutes. Please try again later."
-                                        )
-                                except Exception:
-                                    raise MetaflowException(
-                                        f"Failed to start app {name} on port {port}!"
-                                    )
-    except Exception as e:
-        raise MetaflowException(f"Failed to start app {name} on port {port}!")
-
-
-def ensure_app_start_request_is_valid(existing_named_ports, port: int, name: str):
-    existing_apps_by_port = {np["port"]: np for np in existing_named_ports}
-
-    if port not in existing_apps_by_port:
-        raise MetaflowException(f"Port {port} not found on workstation")
-
-    for existing_named_port in existing_named_ports:
-        if (
-            name == existing_named_port["name"]
-            and existing_named_port["port"] != port
-            and existing_named_port["enabled"]
-        ):
-            raise MetaflowException(
-                f"App with name '{name}' is already deployed on port {existing_named_port['port']}"
-            )
-
-
-def wait_for_app_port_to_be_accessible(
-    api_url, metaflow_token, workstation_id, app_name, poll_timeout_seconds
-) -> bool:
-    num_retries_per_request = 3
-    start_time = time.time()
-    retry_delay = 1.0
-    poll_interval = 10
-    wait_message = f"App {app_name} is currently being deployed..."
-    while time.time() - start_time < poll_timeout_seconds:
-        for _ in range(num_retries_per_request):
-            try:
-                workstations_response = requests.get(
-                    f"https://{api_url}/v1/workstations",
-                    headers={"x-api-key": metaflow_token},
-                )
-                workstations_response.raise_for_status()
-                if is_app_ready(workstations_response.json(), workstation_id, app_name):
-                    print(wait_message)
-                    time.sleep(APP_READY_EXTRA_BUFFER_SECONDS)
-                    return True
-                else:
-                    print(wait_message)
-                    time.sleep(poll_interval)
-            except (
-                requests.exceptions.ConnectionError,
-                requests.exceptions.ReadTimeout,
-            ):
-                time.sleep(retry_delay)
-                retry_delay *= 2  # Double the delay for the next attempt
-                retry_delay += random.uniform(0, 1)  # Add jitter
-                retry_delay = min(retry_delay, 10)
-    return False
-
-
-def is_app_ready(response_json: dict, workstation_id: str, app_name: str) -> bool:
-    """Checks if the app is ready in the given workstation's response."""
-    workstations = response_json.get("workstations", [])
-    for workstation in workstations:
-        if workstation.get("instance_id") == workstation_id:
-            hosted_apps = workstation.get("status", {}).get("hosted_apps", [])
-            for hosted_app in hosted_apps:
-                if hosted_app.get("name") == app_name:
-                    return bool(hosted_app.get("ready"))
-    return False

metaflow_extensions/outerbounds/plugins/apps/deploy_decorator.py

@@ -1,155 +0,0 @@
-from metaflow.exception import MetaflowException
-from metaflow.decorators import StepDecorator
-from metaflow import current
-from .app_utils import start_app
-from .supervisord_utils import SupervisorClient, SupervisorClientException
-import os
-import random
-import string
-import tempfile
-import sys
-
-DEFAULT_WAIT_TIME_SECONDS_FOR_PROCESS_TO_START = 10
-BASE_DIR_FOR_APP_ASSETS = "/home/ob-workspace/.appdaemon/apps/"
-
-
-class WorkstationAppDeployDecorator(StepDecorator):
-    """
-    Specifies that this step is used to deploy an instance of the app.
-    Requires that self.app_name, self.app_port, self.entrypoint and self.deployDir is set.
-
-    Parameters
-    ----------
-    app_port : int
-        Number of GPUs to use.
-    app_name : str
-        Name of the app to deploy.
-    """
-
-    name = "app_deploy"
-    defaults = {"app_port": 8080, "app_name": "app"}
-
-    def step_init(self, flow, graph, step, decos, environment, flow_datastore, logger):
-        if any([deco.name == "kubernetes" for deco in decos]):
-            raise MetaflowException(
-                "Step *{step}* is marked for execution both on Kubernetes and "
-                "Nvidia. Please use one or the other.".format(step=step)
-            )
-
-        # We always need to have some environment defined through the flow to deploy and app.
-        # Which means either step decorators like @pypi / @conda must be defined.
-        # or flow level decorators like @conda_base / @pypi_base.
-        if not any([deco.name == "pypi" or deco.name == "conda" for deco in decos]):
-            flow_decorators = flow._flow_decorators.keys()
-            if (
-                "conda_base" not in flow_decorators
-                and "pypi_base" not in flow_decorators
-            ):
-                raise MetaflowException(
-                    "@app_deploy requires either step decorators like @pypi / @conda or flow level decorators like @conda_base / @pypi_base to be defined."
-                )
-
-        app_port = self.attributes["app_port"]
-        app_name = self.attributes["app_name"]
-
-        # Currently this decorator is expected to only execute on workstation.
-        if app_port is None or app_port < 6000 or app_port > 6002:
-            raise MetaflowException(
-                "AppDeployDecorator requires app_port to be between 6000 and 6002."
-            )
-
-        if app_name is None:
-            raise MetaflowException("AppDeployDecorator requires app_name to be set.")
-
-    def task_pre_step(
-        self,
-        step_name,
-        task_datastore,
-        metadata,
-        run_id,
-        task_id,
-        flow,
-        graph,
-        retry_count,
-        max_user_code_retries,
-        ubf_context,
-        inputs,
-    ):
-        os.makedirs(BASE_DIR_FOR_APP_ASSETS, exist_ok=True)
-        # First we want to create a directory where the user's app directory and artifacts can be stored.
-        with tempfile.TemporaryDirectory(
-            prefix=BASE_DIR_FOR_APP_ASSETS, delete=False
-        ) as temp_dir:
-            launch_temp_dir = temp_dir
-
-        # Expose this to the user, so that they can use it write their artifacts.
-        setattr(flow, "deploy_dir", launch_temp_dir)
-
-        # Make sure to record deploy_dir so that the user cannot accidentally override it.
-        self._deploy_dir = launch_temp_dir
-
-    def task_post_step(
-        self, step_name, flow, graph, retry_count, max_user_code_retries
-    ):
-        deploy_dir = self._deploy_dir
-
-        # By default we assume that the user has a __main__.py file in their app directory.
-        # They can always override this behavior.
-        user_provided_entrypoint = getattr(flow, "entrypoint", None)
-
-        if user_provided_entrypoint is not None and not isinstance(
-            user_provided_entrypoint, str
-        ):
-            raise MetaflowException(
-                f"@app_deploy requires entrypoint to be set to a string. The current value of entrypoint {user_provided_entrypoint} is not valid."
-            )
-
-        flow_directory = os.path.dirname(os.path.abspath(sys.argv[0]))
-
-        # By default, we assume that the layout of the flow directory is:
-        # flow_dir/
-        # - deployer_flow.py
-        # - my_custom_app/
-        #   - __main__.py
-        #   - other_files
-        #   - other_dirs/
-        # This can be overridden by the user by setting the app_dir attribute.
-        # None of this matters if the user provides a custom entrypoint, since in that case we don't copy
-        # anything anywhere.
-        app_location = getattr(
-            flow, "app_dir", os.path.join(flow_directory, self.attributes["app_name"])
-        )
-
-        if user_provided_entrypoint is None and not os.path.exists(app_location):
-            raise MetaflowException(f"App directory {app_location} does not exist.")
-
-        wait_time_for_app_start = getattr(
-            flow,
-            "wait_time_for_app_start",
-            DEFAULT_WAIT_TIME_SECONDS_FOR_PROCESS_TO_START,
-        )
-
-        try:
-            supervisor_client = SupervisorClient(
-                wait_time_seconds_for_app_start=wait_time_for_app_start
-            )
-
-            # First, let's deploy the app.
-            start_app(
-                port=self.attributes["app_port"], name=self.attributes["app_name"]
-            )
-
-            # Now, let's add the app to supervisor.
-            supervisor_client.start_process_with_supervisord(
-                self.attributes["app_name"],
-                self.attributes["app_port"],
-                user_provided_entrypoint,
-                deploy_dir,
-                app_location,
-            )
-        except SupervisorClientException as e:
-            raise MetaflowException(str(e))
-        except Exception as e:
-            raise MetaflowException(
-                f"Failed to start {self.attributes['app_name']}! Cause: {str(e)}"
-            ) from e

metaflow_extensions/outerbounds/plugins/apps/supervisord_utils.py

@@ -1,239 +0,0 @@
-import argparse
-import os
-import configparser
-import tempfile
-import sys
-import subprocess
-from pathlib import Path
-import shutil
-from enum import Enum
-import time
-
-
-class SupervisorClientException(Exception):
-    pass
-
-
-class SupervisorClient:
-    class SupervisodProcessCodes(Enum):
-        STOPPED = 0
-        STARTING = 10
-        RUNNING = 20
-        BACKOFF = 30
-        STOPPING = 40
-        EXITED = 100
-        FATAL = 200
-        UNKNOWN = 1000
-
-    def __init__(self, wait_time_seconds_for_app_start: int):
-        self.supervisor_conf_loc = os.environ.get("SUPERVISOR_CONF_PATH")
-
-        self.wait_time_seconds_for_app_start = wait_time_seconds_for_app_start
-        if self.supervisor_conf_loc is None or not os.path.exists(
-            self.supervisor_conf_loc
-        ):
-            raise SupervisorClientException(
-                "This workstation does not support deploying apps! Please reach out to Outerbounds for support."
-            )
-
-        self.metaflow_envs_persistent_path = os.environ.get(
-            "SUPERVISOR_PYTHON_ENVS_PATH"
-        )
-        if self.metaflow_envs_persistent_path is None:
-            raise SupervisorClientException(
-                "This workstation does not support deploying apps! Please reach out to Outerbounds for support."
-            )
-
-        # Check if supervisorctl is installed
-        if not shutil.which("supervisorctl"):
-            raise SupervisorClientException(
-                "This workstation does not support deploying apps! Please reach out to Outerbounds for support."
-            )
-
-    def _stop_existing_app_at_port(self, app_port):
-        supervisor_config = configparser.ConfigParser()
-        supervisor_config.read(self.supervisor_conf_loc)
-
-        for program in supervisor_config.sections():
-            if "obp_app_port" in supervisor_config[program]:
-                if supervisor_config[program]["obp_app_port"].strip() == str(app_port):
-                    res = subprocess.run(
-                        ["supervisorctl", "stop", program],
-                        stdout=subprocess.DEVNULL,
-                        stderr=subprocess.DEVNULL,
-                    )
-
-                    del supervisor_config[program]
-
-        with tempfile.NamedTemporaryFile(
-            "w", dir=os.path.dirname(self.supervisor_conf_loc), delete=False
-        ) as f:
-            supervisor_config.write(f)
-            tmp_file = f.name
-
-        os.rename(tmp_file, self.supervisor_conf_loc)
-
-    def start_process_with_supervisord(
-        self,
-        app_name,
-        app_port,
-        user_provided_entrypoint,
-        deploy_dir=None,
-        app_dir=None,
-    ):
-        """
-        Add a new program entry to supervisor configuration.
-
-        Args:
-            app_name: The name of the app to start.
-            entrypoint: The entrypoint to start the app with.
-            directory: The directory to run the app in.
-            deploy_dir: The directory to copy the app to and deploy from.
-            app_dir: The directory to copy the app from.
-        """
-
-        entrypoint = user_provided_entrypoint
-        deploy_dir_for_port = "/home/ob-workspace/.appdaemon/apps/6000"
-        launch_directory = (
-            "/home/ob-workspace/.appdaemon/apps"
-            if entrypoint is None
-            else "/home/ob-workspace/.appdaemon"
-        )
-
-        # Step 1: Stop any existing apps that are running on the same port.
-        self._stop_existing_app_at_port(app_port)
-
-        if user_provided_entrypoint is None:
-            # Step 2: Copy the app_dir to the deploy_dir.
-            recursive_copy(app_dir, deploy_dir)
-
-            # Step 3: Copy the entire deploy_dir to the port specific directory.
-            if os.path.exists(deploy_dir_for_port):
-                shutil.rmtree(deploy_dir_for_port)
-
-            os.makedirs(deploy_dir_for_port)
-            recursive_copy(deploy_dir, deploy_dir_for_port)
-
-            # Apply default value
-            entrypoint = f"-m {str(app_port)}"
-
-        shutil.rmtree(deploy_dir)
-
-        persistent_path_for_executable = (
-            self.persist_metaflow_generated_python_environment()
-        )
-
-        command = f"{persistent_path_for_executable} {entrypoint}"
-
-        entry = {
-            "command": command,
-            "directory": launch_directory,
-            "autostart": "true",
-            "autorestart": "true",
-            "obp_app_port": app_port,  # Record the app port for internal reference. This is not used by supervisor.
-        }
-
-        supervisor_config = configparser.ConfigParser()
-        supervisor_config.read(self.supervisor_conf_loc)
-
-        supervisor_config[f"program:{app_name}"] = entry
-
-        with tempfile.NamedTemporaryFile(
-            "w", dir=os.path.dirname(self.supervisor_conf_loc), delete=False
-        ) as f:
-            supervisor_config.write(f)
-            tmp_file = f.name
-
-        os.rename(tmp_file, self.supervisor_conf_loc)
-
-        # Execute supervisorctl reload
-        # Capture the exit code
-        exit_code = subprocess.run(
-            ["supervisorctl", "reload"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        ).returncode
-        if exit_code != 0:
-            print("Failed to reload supervisor configuration!", file=sys.stderr)
-            return
-
-        print(
-            f"Waiting for {self.wait_time_seconds_for_app_start} seconds for {app_name} to start..."
-        )
-        time.sleep(self.wait_time_seconds_for_app_start)
-        status = self._get_launched_prcoess_status(app_name)
-
-        if status not in [
-            self.SupervisodProcessCodes.RUNNING,
-            self.SupervisodProcessCodes.STARTING,
-        ]:
-            raise SupervisorClientException(
-                f"Failed to start {app_name}! Try running {command} manually to debug."
-            )
-
-    def _get_launched_prcoess_status(self, app_name):
-        status_cmd_output = subprocess.run(
-            ["supervisorctl", "status", app_name],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        ).stdout.decode("utf-8")
-
-        status_cmd_output_parts = [
-            x.strip() for x in status_cmd_output.split(" ") if x.strip()
-        ]
-
-        status_str = status_cmd_output_parts[1]
-
-        if status_str == "RUNNING":
-            return self.SupervisodProcessCodes.RUNNING
-        elif status_str == "STOPPED":
-            return self.SupervisodProcessCodes.STOPPED
-        elif status_str == "STARTING":
-            return self.SupervisodProcessCodes.STARTING
-        elif status_str == "BACKOFF":
-            return self.SupervisodProcessCodes.BACKOFF
-        elif status_str == "STOPPING":
-            return self.SupervisodProcessCodes.STOPPING
-        elif status_str == "EXITED":
-            return self.SupervisodProcessCodes.EXITED
-        elif status_str == "FATAL":
-            return self.SupervisodProcessCodes.FATAL
-        else:
-            return self.SupervisodProcessCodes.UNKNOWN
-
-    # By default, an environment generated by metaflow will end up in a path like: /root/micromamba/envs/metaflow/linux-64/02699a4d2d50cfc/bin/python
-    # However, on a workstation these environments are not persisted, so we need to copy them over to /home/ob-workspace
-    def persist_metaflow_generated_python_environment(self):
-        current_executable = sys.executable
-        environment_path = Path(current_executable).parent.parent
-
-        persistent_path_for_this_environment = os.path.join(
-            self.metaflow_envs_persistent_path,
-            environment_path.parent.name,
-            environment_path.name,
-        )
-
-        final_executable_path = os.path.join(
-            persistent_path_for_this_environment,
-            Path(current_executable).parent.name,
-            Path(current_executable).name,
-        )
-
-        if os.path.exists(final_executable_path):
-            return final_executable_path
-
-        os.makedirs(persistent_path_for_this_environment, exist_ok=True)
-
-        recursive_copy(environment_path, persistent_path_for_this_environment)
-
-        return final_executable_path
-
-
-def recursive_copy(src, dst):
-    for item in os.listdir(src):
-        s = os.path.join(src, item)
-        d = os.path.join(dst, item)
-        if os.path.isdir(s):
-            shutil.copytree(s, d, dirs_exist_ok=True)
-        else:
-            shutil.copy2(s, d)