wandb 0.16.3__py3-none-any.whl → 0.16.5__py3-none-any.whl

wandb/sdk/internal/sender.py

@@ -1,6 +1,5 @@
 """sender."""
 
-import concurrent.futures
 import json
 import logging
 import os
@@ -18,12 +17,10 @@ from typing import (
     Dict,
     Generator,
     List,
-    NewType,
     Optional,
     Tuple,
     Type,
     Union,
-    cast,
 )
 
 import requests
@@ -43,6 +40,7 @@ from wandb.sdk.internal import (
     file_stream,
     internal_api,
     job_builder,
+    sender_config,
     update,
 )
 from wandb.sdk.internal.file_pusher import FilePusher
@@ -85,9 +83,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-DictWithValues = NewType("DictWithValues", Dict[str, Any])
-DictNoValues = NewType("DictNoValues", Dict[str, Any])
-
 _OUTPUT_MIN_CALLBACK_INTERVAL = 2  # seconds
 
 
@@ -120,6 +115,7 @@ def _manifest_json_from_proto(manifest: "ArtifactManifest") -> Dict:
                 "ref": content.ref if content.ref else None,
                 "size": content.size if content.size is not None else None,
                 "local_path": content.local_path if content.local_path else None,
+                "skip_cache": content.skip_cache,
                 "extra": {
                     extra.key: json.loads(extra.value_json) for extra in content.extra
                 },
@@ -263,8 +259,9 @@ class SendManager:
         self._project = None
 
         # keep track of config from key/val updates
-        self._consolidated_config: DictNoValues = cast(DictNoValues, dict())
-        self._start_time: float = 0
+        self._consolidated_config = sender_config.ConfigState()
+
+        self._start_time: int = 0
         self._telemetry_obj = telemetry.TelemetryRecord()
         self._config_metric_pbdict_list: List[Dict[int, Any]] = []
         self._metadata_summary: Dict[str, Any] = defaultdict()
@@ -540,7 +537,7 @@ class SendManager:
         self._maybe_update_config(always=final)
 
     def _debounce_config(self) -> None:
-        config_value_dict = self._config_format(self._consolidated_config)
+        config_value_dict = self._config_backend_dict()
         # TODO(jhr): check result of upsert_run?
         if self._run:
             self._api.upsert_run(
@@ -737,18 +734,7 @@ class SendManager:
             )
         self._respond_result(result)
 
-    def send_request_job_info(self, record: "Record") -> None:
-        """Respond to a request for a job link."""
-        result = proto_util._result_from_record(record)
-        result.response.job_info_response.sequenceId = (
-            self._job_builder._job_seq_id or ""
-        )
-        result.response.job_info_response.version = (
-            self._job_builder._job_version_alias or ""
-        )
-        self._respond_result(result)
-
-    def _maybe_setup_resume(
+    def _setup_resume(
         self, run: "RunRecord"
     ) -> Optional["wandb_internal_pb2.ErrorInfo"]:
         """Queries the backend for a run; fail if the settings are incompatible."""
@@ -856,51 +842,20 @@ class SendManager:
         )
         return framework
 
-    def _config_telemetry_update(self, config_dict: Dict[str, Any]) -> None:
-        """Add legacy telemetry to config object."""
-        wandb_key = "_wandb"
-        config_dict.setdefault(wandb_key, dict())
-        s: str
-        b: bool
-        s = self._telemetry_obj.python_version
-        if s:
-            config_dict[wandb_key]["python_version"] = s
-        s = self._telemetry_obj.cli_version
-        if s:
-            config_dict[wandb_key]["cli_version"] = s
-        s = self._telemetry_get_framework()
-        if s:
-            config_dict[wandb_key]["framework"] = s
-        s = self._telemetry_obj.huggingface_version
-        if s:
-            config_dict[wandb_key]["huggingface_version"] = s
-        b = self._telemetry_obj.env.jupyter
-        config_dict[wandb_key]["is_jupyter_run"] = b
-        b = self._telemetry_obj.env.kaggle
-        config_dict[wandb_key]["is_kaggle_kernel"] = b
-
-        config_dict[wandb_key]["start_time"] = self._start_time
-
-        t: Dict[int, Any] = proto_util.proto_encode_to_dict(self._telemetry_obj)
-        config_dict[wandb_key]["t"] = t
-
-    def _config_metric_update(self, config_dict: Dict[str, Any]) -> None:
-        """Add default xaxis to config."""
-        if not self._config_metric_pbdict_list:
-            return
-        wandb_key = "_wandb"
-        config_dict.setdefault(wandb_key, dict())
-        config_dict[wandb_key]["m"] = self._config_metric_pbdict_list
-
-    def _config_format(self, config_data: Optional[DictNoValues]) -> DictWithValues:
-        """Format dict into value dict with telemetry info."""
-        config_dict: Dict[str, Any] = config_data.copy() if config_data else dict()
-        self._config_telemetry_update(config_dict)
-        self._config_metric_update(config_dict)
-        config_value_dict: DictWithValues = config_util.dict_add_value_dict(config_dict)
-        return config_value_dict
-
-    def _config_save(self, config_value_dict: DictWithValues) -> None:
+    def _config_backend_dict(self) -> sender_config.BackendConfigDict:
+        config = self._consolidated_config or sender_config.ConfigState()
+
+        return config.to_backend_dict(
+            telemetry_record=self._telemetry_obj,
+            framework=self._telemetry_get_framework(),
+            start_time_millis=self._start_time,
+            metric_pbdicts=self._config_metric_pbdict_list,
+        )
+
+    def _config_save(
+        self,
+        config_value_dict: sender_config.BackendConfigDict,
+    ) -> None:
         config_path = os.path.join(self._settings.files_dir, "config.yaml")
         config_util.save_config_file_from_dict(config_path, config_value_dict)
 
@@ -925,13 +880,37 @@ class SendManager:
             pass
         # TODO: do something if sync spell is not successful?
 
+    def _setup_fork(self, server_run: dict):
+        assert self._settings.fork_from
+        assert self._settings.fork_from.metric == "_step"
+        assert self._run
+        first_step = int(self._settings.fork_from.value) + 1
+        self._resume_state.step = first_step
+        self._resume_state.history = server_run.get("historyLineCount", 0)
+        self._run.forked = True
+        self._run.starting_step = first_step
+
+    def _handle_error(
+        self,
+        record: "Record",
+        error: "wandb_internal_pb2.ErrorInfo",
+        run: "RunRecord",
+    ) -> None:
+        if record.control.req_resp or record.control.mailbox_slot:
+            result = proto_util._result_from_record(record)
+            result.run_result.run.CopyFrom(run)
+            result.run_result.error.CopyFrom(error)
+            self._respond_result(result)
+        else:
+            logger.error("Got error in async mode: %s", error.message)
+
     def send_run(self, record: "Record", file_dir: Optional[str] = None) -> None:
         run = record.run
         error = None
         is_wandb_init = self._run is None
 
         # save start time of a run
-        self._start_time = run.start_time.ToMicroseconds() / 1e6
+        self._start_time = run.start_time.ToMicroseconds() // 1e6
 
         # update telemetry
         if run.telemetry:
@@ -940,61 +919,69 @@ class SendManager:
             self._telemetry_obj.feature.sync = True
 
         # build config dict
-        config_value_dict: Optional[DictWithValues] = None
+        config_value_dict: Optional[sender_config.BackendConfigDict] = None
         if run.config:
-            config_util.update_from_proto(self._consolidated_config, run.config)
-            config_value_dict = self._config_format(self._consolidated_config)
+            self._consolidated_config.update_from_proto(run.config)
+            config_value_dict = self._config_backend_dict()
             self._config_save(config_value_dict)
 
+        do_fork = self._settings.fork_from is not None and is_wandb_init
+        do_resume = bool(self._settings.resume)
+
+        if do_fork and do_resume:
+            error = wandb_internal_pb2.ErrorInfo()
+            error.code = wandb_internal_pb2.ErrorInfo.ErrorCode.USAGE
+            error.message = (
+                "You cannot use `resume` and `fork_from` together. Please choose one."
+            )
+            self._handle_error(record, error, run)
+
         if is_wandb_init:
             # Ensure we have a project to query for status
             if run.project == "":
                 run.project = util.auto_project_name(self._settings.program)
             # Only check resume status on `wandb.init`
-            error = self._maybe_setup_resume(run)
+
+            if do_resume:
+                error = self._setup_resume(run)
 
         if error is not None:
-            if record.control.req_resp or record.control.mailbox_slot:
-                result = proto_util._result_from_record(record)
-                result.run_result.run.CopyFrom(run)
-                result.run_result.error.CopyFrom(error)
-                self._respond_result(result)
-            else:
-                logger.error("Got error in async mode: %s", error.message)
+            self._handle_error(record, error, run)
             return
 
         # Save the resumed config
         if self._resume_state.config is not None:
-            # TODO: should we merge this with resumed config?
-            config_override = self._consolidated_config
-            config_dict = self._resume_state.config
-            config_dict = config_util.dict_strip_value_dict(config_dict)
-            config_dict.update(config_override)
-            self._consolidated_config.update(config_dict)
-            config_value_dict = self._config_format(self._consolidated_config)
+            self._consolidated_config.merge_resumed_config(
+                config_util.dict_strip_value_dict(self._resume_state.config)
+            )
+
+            config_value_dict = self._config_backend_dict()
             self._config_save(config_value_dict)
 
         # handle empty config
         # TODO(jhr): consolidate the 4 ways config is built:
         #            (passed config, empty config, resume config, send_config)
         if not config_value_dict:
-            config_value_dict = self._config_format(None)
+            config_value_dict = self._config_backend_dict()
             self._config_save(config_value_dict)
 
         try:
-            self._init_run(run, config_value_dict)
+            server_run = self._init_run(run, config_value_dict)
         except (CommError, UsageError) as e:
             logger.error(e, exc_info=True)
-            if record.control.req_resp or record.control.mailbox_slot:
-                result = proto_util._result_from_record(record)
-                result.run_result.run.CopyFrom(run)
-                error = ProtobufErrorHandler.from_exception(e)
-                result.run_result.error.CopyFrom(error)
-                self._respond_result(result)
+            error = ProtobufErrorHandler.from_exception(e)
+            self._handle_error(record, error, run)
             return
 
         assert self._run  # self._run is configured in _init_run()
 
+        if do_fork:
+            error = self._setup_fork(server_run)
+
+        if error is not None:
+            self._handle_error(record, error, run)
+            return
+
         if record.control.req_resp or record.control.mailbox_slot:
             result = proto_util._result_from_record(record)
             # TODO: we could do self._interface.publish_defer(resp) to notify
@@ -1012,8 +999,8 @@ class SendManager:
     def _init_run(
         self,
         run: "RunRecord",
-        config_dict: Optional[DictWithValues],
-    ) -> None:
+        config_dict: Optional[sender_config.BackendConfigDict],
+    ) -> dict:
         # We subtract the previous runs runtime when resuming
         start_time = (
             run.start_time.ToMicroseconds() / 1e6
@@ -1098,6 +1085,7 @@ class SendManager:
             self._run.sweep_id = sweep_id
         if os.getenv("SPELL_RUN_URL"):
             self._sync_spell()
+        return server_run
 
     def _start_run_threads(self, file_dir: Optional[str] = None) -> None:
         assert self._run  # self._run is configured by caller
@@ -1344,8 +1332,7 @@ class SendManager:
         self._config_needs_debounce = True
 
     def send_config(self, record: "Record") -> None:
-        cfg = record.config
-        config_util.update_from_proto(self._consolidated_config, cfg)
+        self._consolidated_config.update_from_proto(record.config)
         self._update_config()
 
     def send_metric(self, record: "Record") -> None:
@@ -1457,40 +1444,27 @@ class SendManager:
             )
 
     def send_request_log_artifact(self, record: "Record") -> None:
-        assert record.control.mailbox_slot
+        assert record.control.req_resp
         result = proto_util._result_from_record(record)
         artifact = record.request.log_artifact.artifact
         history_step = record.request.log_artifact.history_step
 
-        future = None
         try:
-            res, future = self._send_artifact(artifact, history_step)
+            res = self._send_artifact(artifact, history_step)
             assert res, "Unable to send artifact"
-            result.response.log_artifact_response.artifact_id = res.get("id", None)
+            result.response.log_artifact_response.artifact_id = res["id"]
             logger.info(f"logged artifact {artifact.name} - {res}")
         except Exception as e:
             result.response.log_artifact_response.error_message = (
                 f'error logging artifact "{artifact.type}/{artifact.name}": {e}'
             )
 
-        def _respond_result(fut: concurrent.futures.Future):
-            if fut.exception() is not None:
-                result.response.log_artifact_response.error_message = f'error logging artifact "{artifact.type}/{artifact.name}": {fut.exception()}'
-            self._respond_result(result)
-
-        if future is not None:
-            # respond to the request only after the artifact is fully committed
-            future.add_done_callback(_respond_result)
-        else:
-            self._respond_result(result)
+        self._respond_result(result)
 
     def send_artifact(self, record: "Record") -> None:
         artifact = record.artifact
         try:
-            res, future = self._send_artifact(artifact)
-            # wait for future to complete in send artifact
-            if future is not None:
-                future.result()
+            res = self._send_artifact(artifact)
             logger.info(f"sent artifact {artifact.name} - {res}")
         except Exception as e:
             logger.error(
@@ -1501,8 +1475,8 @@ class SendManager:
 
     def _send_artifact(
         self, artifact: "ArtifactRecord", history_step: Optional[int] = None
-    ) -> Tuple[Dict, Optional[concurrent.futures.Future]]:
-        from pkg_resources import parse_version
+    ) -> Optional[Dict]:
+        from wandb.util import parse_version
 
         assert self._pusher
         saver = ArtifactSaver(
@@ -1522,10 +1496,10 @@ class SendManager:
                     "This W&B Server doesn't support distributed artifacts, "
                     "have your administrator install wandb/local >= 0.9.37"
                 )
-                return {}, None
+                return None
 
         metadata = json.loads(artifact.metadata) if artifact.metadata else None
-        res, future = saver.save(
+        res = saver.save(
             type=artifact.type,
             name=artifact.name,
             client_id=artifact.client_id,
@@ -1543,10 +1517,10 @@ class SendManager:
         )
 
         self._job_builder._handle_server_artifact(res, artifact)
-        return res, future
+        return res
 
     def send_alert(self, record: "Record") -> None:
-        from pkg_resources import parse_version
+        from wandb.util import parse_version
 
         alert = record.alert
         max_cli_version = self._max_cli_version()
@@ -1639,9 +1613,7 @@ class SendManager:
     def _flush_job(self) -> None:
         if self._job_builder.disable or self._settings._offline:
             return
-        self._job_builder.set_config(
-            {k: v for k, v in self._consolidated_config.items() if k != "_wandb"}
-        )
+        self._job_builder.set_config(self._consolidated_config.non_internal_config())
         summary_dict = self._cached_summary.copy()
         summary_dict.pop("_wandb", None)
         self._job_builder.set_summary(summary_dict)

wandb/sdk/internal/sender_config.py

@@ -0,0 +1,197 @@
+import json
+from typing import Any, Dict, NewType, Optional, Sequence
+
+from wandb.proto import wandb_internal_pb2
+from wandb.sdk.lib import proto_util, telemetry
+
+BackendConfigDict = NewType("BackendConfigDict", Dict[str, Any])
+"""Run config dictionary in the format used by the backend."""
+
+_WANDB_INTERNAL_KEY = "_wandb"
+
+
+class ConfigState:
+    """The configuration of a run."""
+
+    def __init__(self, tree: Optional[Dict[str, Any]] = None) -> None:
+        self._tree: Dict[str, Any] = tree or {}
+        """A tree with string-valued nodes and JSON leaves.
+
+        Leaves are Python objects that are valid JSON values:
+
+        * Primitives like strings and numbers
+        * Dictionaries from strings to JSON objects
+        * Lists of JSON objects
+        """
+
+    def non_internal_config(self) -> Dict[str, Any]:
+        """Returns the config settings minus "_wandb"."""
+        return {k: v for k, v in self._tree.items() if k != _WANDB_INTERNAL_KEY}
+
+    def update_from_proto(
+        self,
+        config_record: wandb_internal_pb2.ConfigRecord,
+    ) -> None:
+        """Applies update and remove commands."""
+        for config_item in config_record.update:
+            self._update_at_path(
+                _key_path(config_item),
+                json.loads(config_item.value_json),
+            )
+
+        for config_item in config_record.remove:
+            self._delete_at_path(_key_path(config_item))
+
+    def merge_resumed_config(self, old_config_tree: Dict[str, Any]) -> None:
+        """Merges the config from a run that's being resumed."""
+        # Add any top-level keys that aren't already set.
+        self._add_unset_keys_from_subtree(old_config_tree, [])
+
+        # Unfortunately, when a user logs visualizations, we store them in the
+        # run's config. When resuming a run, we want to avoid erasing previously
+        # logged visualizations, hence this special handling:
+        self._add_unset_keys_from_subtree(
+            old_config_tree,
+            [_WANDB_INTERNAL_KEY, "visualize"],
+        )
+        self._add_unset_keys_from_subtree(
+            old_config_tree,
+            [_WANDB_INTERNAL_KEY, "viz"],
+        )
+
+    def _add_unset_keys_from_subtree(
+        self,
+        old_config_tree: Dict[str, Any],
+        path: Sequence[str],
+    ) -> None:
+        """Uses the given subtree for keys that aren't already set."""
+        old_subtree = _subtree(old_config_tree, path, create=False)
+        if not old_subtree:
+            return
+
+        new_subtree = _subtree(self._tree, path, create=True)
+        assert new_subtree is not None
+
+        for key, value in old_subtree.items():
+            if key not in new_subtree:
+                new_subtree[key] = value
+
+    def to_backend_dict(
+        self,
+        telemetry_record: telemetry.TelemetryRecord,
+        framework: Optional[str],
+        start_time_millis: int,
+        metric_pbdicts: Sequence[Dict[int, Any]],
+    ) -> BackendConfigDict:
+        """Returns a dictionary representation expected by the backend.
+
+        The backend expects the configuration in a specific format, and the
+        config is also used to store additional metadata about the run.
+
+        Args:
+            telemetry_record: Telemetry information to insert.
+            framework: The detected framework used in the run (e.g. TensorFlow).
+            start_time_millis: The run's start time in Unix milliseconds.
+            metric_pbdicts: List of dict representations of metric protobuffers.
+        """
+        backend_dict = self._tree.copy()
+        wandb_internal = backend_dict.setdefault(_WANDB_INTERNAL_KEY, {})
+
+        ###################################################
+        # Telemetry information
+        ###################################################
+        py_version = telemetry_record.python_version
+        if py_version:
+            wandb_internal["python_version"] = py_version
+
+        cli_version = telemetry_record.cli_version
+        if cli_version:
+            wandb_internal["cli_version"] = cli_version
+
+        if framework:
+            wandb_internal["framework"] = framework
+
+        huggingface_version = telemetry_record.huggingface_version
+        if huggingface_version:
+            wandb_internal["huggingface_version"] = huggingface_version
+
+        wandb_internal["is_jupyter_run"] = telemetry_record.env.jupyter
+        wandb_internal["is_kaggle_kernel"] = telemetry_record.env.kaggle
+        wandb_internal["start_time"] = start_time_millis
+
+        # The full telemetry record.
+        wandb_internal["t"] = proto_util.proto_encode_to_dict(telemetry_record)
+
+        ###################################################
+        # Metrics
+        ###################################################
+        if metric_pbdicts:
+            wandb_internal["m"] = metric_pbdicts
+
+        return BackendConfigDict(
+            {
+                key: {
+                    # Configurations can be stored in a hand-written YAML file,
+                    # and users can add descriptions to their hyperparameters
+                    # there. However, we don't support a way to set descriptions
+                    # via code, so this is always None.
+                    "desc": None,
+                    "value": value,
+                }
+                for key, value in self._tree.items()
+            }
+        )
+
+    def _update_at_path(
+        self,
+        key_path: Sequence[str],
+        value: Any,
+    ) -> None:
+        """Sets the value at the path in the config tree."""
+        subtree = _subtree(self._tree, key_path[:-1], create=True)
+        assert subtree is not None
+
+        subtree[key_path[-1]] = value
+
+    def _delete_at_path(
+        self,
+        key_path: Sequence[str],
+    ) -> None:
+        """Removes the subtree at the path in the config tree."""
+        subtree = _subtree(self._tree, key_path[:-1], create=False)
+        if subtree:
+            del subtree[key_path[-1]]
+
+
+def _key_path(config_item: wandb_internal_pb2.ConfigItem) -> Sequence[str]:
+    """Returns the key path referenced by the config item."""
+    if config_item.nested_key:
+        return config_item.nested_key
+    elif config_item.key:
+        return [config_item.key]
+    else:
+        raise AssertionError(
+            "Invalid ConfigItem: either key or nested_key must be set",
+        )
+
+
+def _subtree(
+    tree: Dict[str, Any],
+    key_path: Sequence[str],
+    *,
+    create: bool = False,
+) -> Optional[Dict[str, Any]]:
+    """Returns a subtree at the given path."""
+    for key in key_path:
+        subtree = tree.get(key)
+
+        if not subtree:
+            if create:
+                subtree = {}
+                tree[key] = subtree
+            else:
+                return None
+
+        tree = subtree
+
+    return tree

wandb/sdk/internal/settings_static.py

@@ -2,6 +2,7 @@ from dataclasses import fields
 from typing import Any, Iterable, Sequence, Tuple
 
 from wandb.proto import wandb_settings_pb2
+from wandb.sdk.lib import RunMoment
 from wandb.sdk.wandb_settings import SettingsData
 
 
@@ -38,6 +39,14 @@ class SettingsStatic(SettingsData):
                             unpacked_inner[inner_key] = inner_value
                         unpacked_mapping[outer_key] = unpacked_inner
                     value = unpacked_mapping
+            elif key == "fork_from":
+                value = getattr(proto, key)
+                if value.run:
+                    value = RunMoment(
+                        run=value.run, value=value.value, metric=value.metric
+                    )
+                else:
+                    value = None
             else:
                 if proto.HasField(key):  # type: ignore [arg-type]
                     value = getattr(proto, key).value

wandb/sdk/internal/system/system_info.py

@@ -14,7 +14,6 @@ from wandb.sdk.internal.settings_static import SettingsStatic
 from wandb.sdk.lib import filesystem
 from wandb.sdk.lib.filenames import CONDA_ENVIRONMENTS_FNAME, DIFF_FNAME, METADATA_FNAME
 from wandb.sdk.lib.gitlib import GitRepo
-from wandb.sdk.wandb_settings import _get_program_relpath
 
 from .assets.interfaces import Interface
 
@@ -168,7 +167,7 @@ class SystemInfo:
             data["program"] = self.settings.program
             # Used during artifact-job creation, always points to the relpath
             # of code execution, even when in a git repo
-            data["codePathLocal"] = _get_program_relpath(self.settings.program)
+            data["codePathLocal"] = self.settings._code_path_local
         if not self.settings.disable_code:
             if self.settings.program_relpath:
                 data["codePath"] = self.settings.program_relpath
@@ -213,7 +212,10 @@ class SystemInfo:
                 os.path.join(self.settings.files_dir, CONDA_ENVIRONMENTS_FNAME), "w"
             ) as f:
                 subprocess.call(
-                    ["conda", "env", "export"], stdout=f, stderr=subprocess.DEVNULL
+                    ["conda", "env", "export"],
+                    stdout=f,
+                    stderr=subprocess.DEVNULL,
+                    timeout=15,  # add timeout since conda env export could take a really long time
                 )
         except Exception as e:
             logger.exception(f"Error saving conda packages: {e}")

wandb/sdk/internal/update.py

@@ -8,7 +8,7 @@ import wandb
 def _find_available(
     current_version: str,
 ) -> Optional[Tuple[str, bool, bool, bool, Optional[str]]]:
-    from pkg_resources import parse_version
+    from wandb.util import parse_version
 
     pypi_url = f"https://pypi.org/pypi/{wandb._wandb_module}/json"
 

wandb/sdk/launch/_launch.py

@@ -10,7 +10,7 @@ import wandb
 from wandb.apis.internal import Api
 
 from . import loader
-from ._project_spec import create_project_from_spec, fetch_and_validate_project
+from ._project_spec import LaunchProject
 from .agent import LaunchAgent
 from .builder.build import construct_agent_configs
 from .environment.local_environment import LocalEnvironment
@@ -221,8 +221,8 @@ async def _launch(
         author=None,
     )
     validate_launch_spec_source(launch_spec)
-    launch_project = create_project_from_spec(launch_spec, api)
-    launch_project = fetch_and_validate_project(launch_project, api)
+    launch_project = LaunchProject.from_spec(launch_spec, api)
+    launch_project.fetch_and_validate_project()
     entrypoint = launch_project.get_single_entry_point()
     image_uri = launch_project.docker_image  # Either set by user or None.