wandb 0.15.3__py3-none-any.whl → 0.15.5__py3-none-any.whl

wandb/sdk/wandb_run.py

@@ -47,12 +47,13 @@ from wandb.proto.wandb_internal_pb2 import (
     RunRecord,
     ServerInfoResponse,
 )
+from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.internal import job_builder
 from wandb.sdk.lib.import_hooks import (
     register_post_import_hook,
     unregister_post_import_hook,
 )
-from wandb.sdk.lib.paths import FilePathStr, StrPath
+from wandb.sdk.lib.paths import FilePathStr, LogicalPath, StrPath
 from wandb.util import (
     _is_artifact_object,
     _is_artifact_string,
@@ -61,14 +62,11 @@ from wandb.util import (
     _resolve_aliases,
     add_import_hook,
     parse_artifact_string,
-    to_forward_slash_path,
 )
 from wandb.viz import CustomChart, Visualize, custom_chart
 
-from . import wandb_artifacts, wandb_config, wandb_metric, wandb_summary
+from . import wandb_config, wandb_metric, wandb_summary
 from .data_types._dtypes import TypeRegistry
-from .interface.artifacts import Artifact as ArtifactInterface
-from .interface.artifacts import ArtifactNotLoggedError
 from .interface.interface import GlobStr, InterfaceBase
 from .interface.summary_record import SummaryRecord
 from .lib import (
@@ -83,13 +81,12 @@ from .lib import (
     telemetry,
 )
 from .lib.exit_hooks import ExitHooks
-from .lib.git import GitRepo
+from .lib.gitlib import GitRepo
 from .lib.mailbox import MailboxError, MailboxHandle, MailboxProbe, MailboxProgress
 from .lib.printer import get_printer
 from .lib.proto_util import message_to_dict
 from .lib.reporting import Reporter
 from .lib.wburls import wburls
-from .wandb_artifacts import Artifact
 from .wandb_settings import Settings, SettingsConsole
 from .wandb_setup import _WandbSetup
 
@@ -109,8 +106,6 @@ if TYPE_CHECKING:
         SampledHistoryResponse,
     )
 
-    from .data_types.base_types.wb_value import WBValue
-    from .interface.artifacts import ArtifactManifest, ArtifactManifestEntry
     from .interface.interface import FilesDict, PolicyName
     from .lib.printer import PrinterJupyter, PrinterTerm
     from .wandb_alerts import AlertLevel
@@ -481,7 +476,6 @@ class Run:
     _notes: Optional[str]
 
     _run_obj: Optional[RunRecord]
-    _run_obj_offline: Optional[RunRecord]
     # Use string literal annotation because of type reference loop
     _backend: Optional["wandb.sdk.backend.backend.Backend"]
     _internal_run_interface: Optional[
@@ -604,7 +598,6 @@ class Run:
 
         # Returned from backend request_run(), set from wandb_init?
         self._run_obj = None
-        self._run_obj_offline = None
 
         # Created when the run "starts".
         self._run_status_checker = None
@@ -641,7 +634,7 @@ class Run:
         self._launch_artifact_mapping: Dict[str, Any] = {}
         self._unique_launch_artifact_sequence_names: Dict[str, Any] = {}
         if self._settings.save_code and self._settings.program_relpath:
-            config[wandb_key]["code_path"] = to_forward_slash_path(
+            config[wandb_key]["code_path"] = LogicalPath(
                 os.path.join("code", self._settings.program_relpath)
             )
         if sweep_config:
@@ -883,8 +876,7 @@ class Run:
             tel.feature.set_run_name = True
         self._name = name
         if self._backend and self._backend.interface:
-            run = self._backend.interface._make_run(self)
-            self._backend.interface.publish_run(run)
+            self._backend.interface.publish_run(self)
 
     @property
     @_run_decorator._attach
@@ -905,8 +897,7 @@ class Run:
     def notes(self, notes: str) -> None:
         self._notes = notes
         if self._backend and self._backend.interface:
-            run = self._backend.interface._make_run(self)
-            self._backend.interface.publish_run(run)
+            self._backend.interface.publish_run(self)
 
     @property
     @_run_decorator._attach
@@ -914,9 +905,8 @@ class Run:
         """Tags associated with the run, if there are any."""
         if self._tags:
             return self._tags
-        run_obj = self._run_obj or self._run_obj_offline
-        if run_obj:
-            return tuple(run_obj.tags)
+        if self._run_obj:
+            return tuple(self._run_obj.tags)
         return None
 
     @tags.setter
@@ -926,8 +916,7 @@ class Run:
             tel.feature.set_run_tags = True
         self._tags = tuple(tags)
         if self._backend and self._backend.interface:
-            run = self._backend.interface._make_run(self)
-            self._backend.interface.publish_run(run)
+            self._backend.interface.publish_run(self)
 
     @property
     @_run_decorator._attach
@@ -999,8 +988,7 @@ class Run:
         return self._step
 
     def project_name(self) -> str:
-        run_obj = self._run_obj or self._run_obj_offline
-        return run_obj.project if run_obj else ""
+        return self._run_obj.project if self._run_obj else ""
 
     @property
     @_run_decorator._attach
@@ -1026,8 +1014,7 @@ class Run:
         return self._settings._noop
 
     def _get_group(self) -> str:
-        run_obj = self._run_obj or self._run_obj_offline
-        return run_obj.run_group if run_obj else ""
+        return self._run_obj.run_group if self._run_obj else ""
 
     @property
     @_run_decorator._attach
@@ -1038,7 +1025,7 @@ class Run:
 
         If you are doing a distributed training you should give all of the
             runs in the training the same group.
-        If you are doing crossvalidation you should give all the crossvalidation
+        If you are doing cross-validation you should give all the cross-validation
             folds the same group.
         """
         return self._get_group()
@@ -1046,8 +1033,7 @@ class Run:
     @property
     @_run_decorator._attach
     def job_type(self) -> str:
-        run_obj = self._run_obj or self._run_obj_offline
-        return run_obj.job_type if run_obj else ""
+        return self._run_obj.job_type if self._run_obj else ""
 
     @property
     @_run_decorator._attach
@@ -1096,10 +1082,19 @@ class Run:
             An `Artifact` object if code was logged
         """
         if name is None:
-            name_string = wandb.util.make_artifact_name_safe(
-                f"{self._project}-{self._settings.program_relpath}"
-            )
-            name = f"source-{name_string}"
+            if self.settings._jupyter:
+                notebook_name = None
+                if self.settings.notebook_name:
+                    notebook_name = self.settings.notebook_name
+                elif self.settings._jupyter_path:
+                    if self.settings._jupyter_path.startswith("fileId="):
+                        notebook_name = self.settings._jupyter_name
+                    else:
+                        notebook_name = self.settings._jupyter_path
+                name_string = f"{self._project}-{notebook_name}"
+            else:
+                name_string = f"{self._project}-{self._settings.program_relpath}"
+            name = wandb.util.make_artifact_name_safe(f"source-{name_string}")
         art = wandb.Artifact(name, "code")
         files_added = False
         if root is not None:
@@ -1289,14 +1284,14 @@ class Run:
 
     def _config_artifact_callback(
         self, key: str, val: Union[str, Artifact, dict]
-    ) -> Union[Artifact, public.Artifact]:
+    ) -> Artifact:
         # artifacts can look like dicts as they are passed into the run config
         # since the run config stores them on the backend as a dict with fields shown
         # in wandb.util.artifact_to_json
         if _is_artifact_version_weave_dict(val):
             assert isinstance(val, dict)
             public_api = self._public_api()
-            artifact = public.Artifact.from_id(val["id"], public_api.client)
+            artifact = Artifact._from_id(val["id"], public_api.client)
             return self.use_artifact(artifact, use_as=key)
         elif _is_artifact_string(val):
             # this will never fail, but is required to make mypy happy
@@ -1309,12 +1304,11 @@ class Run:
             else:
                 public_api = self._public_api()
             if is_id:
-                artifact = public.Artifact.from_id(artifact_string, public_api._client)
+                artifact = Artifact._from_id(artifact_string, public_api._client)
             else:
                 artifact = public_api.artifact(name=artifact_string)
             # in the future we'll need to support using artifacts from
-            # different instances of wandb. simplest way to do that is
-            # likely to convert the retrieved public.Artifact to a wandb.Artifact
+            # different instances of wandb.
 
             return self.use_artifact(artifact, use_as=key)
         elif _is_artifact_object(val):
@@ -1457,6 +1451,9 @@ class Run:
 
     def _set_run_obj(self, run_obj: RunRecord) -> None:
         self._run_obj = run_obj
+        if self.settings._offline:
+            return
+
         self._entity = run_obj.entity
         self._project = run_obj.project
 
@@ -1485,9 +1482,6 @@ class Run:
             settings=self._settings,
         )
 
-    def _set_run_obj_offline(self, run_obj: RunRecord) -> None:
-        self._run_obj_offline = run_obj
-
     def _add_singleton(
         self, data_type: str, key: str, value: Dict[Union[int, str], str]
     ) -> None:
@@ -2173,6 +2167,8 @@ class Run:
             self._output_writer = None
 
     def _on_init(self) -> None:
+        if self._settings._offline:
+            return
         if self._backend and self._backend.interface:
             logger.info("communicating current version")
             version_handle = self._backend.interface.deliver_check_version(
@@ -2591,7 +2587,7 @@ class Run:
     @_run_decorator._attach
     def link_artifact(
         self,
-        artifact: Union[public.Artifact, Artifact],
+        artifact: Artifact,
         target_path: str,
         aliases: Optional[List[str]] = None,
     ) -> None:
@@ -2616,7 +2612,7 @@ class Run:
             aliases = []
 
         if self._backend and self._backend.interface:
-            if isinstance(artifact, Artifact) and not artifact._logged_artifact:
+            if artifact.is_draft() and not artifact._is_draft_save_started():
                 artifact = self._log_artifact(artifact)
             if not self._settings._offline:
                 self._backend.interface.publish_link_artifact(
@@ -2635,11 +2631,11 @@ class Run:
     @_run_decorator._attach
     def use_artifact(
         self,
-        artifact_or_name: Union[str, public.Artifact, Artifact],
+        artifact_or_name: Union[str, Artifact],
         type: Optional[str] = None,
         aliases: Optional[List[str]] = None,
         use_as: Optional[str] = None,
-    ) -> Union[public.Artifact, Artifact]:
+    ) -> Artifact:
         """Declare an artifact as an input to a run.
 
         Call `download` or `file` on the returned object to get the contents locally.
@@ -2704,10 +2700,10 @@ class Run:
                 aliases = []
             elif isinstance(aliases, str):
                 aliases = [aliases]
-            if isinstance(artifact_or_name, wandb.Artifact):
+            if isinstance(artifact_or_name, Artifact) and artifact.is_draft():
                 if use_as is not None:
                     wandb.termwarn(
-                        "Indicating use_as is not supported when using an artifact with an instance of `wandb.Artifact`"
+                        "Indicating use_as is not supported when using a draft artifact"
                     )
                 self._log_artifact(
                     artifact,
@@ -2717,13 +2713,13 @@ class Run:
                 )
                 artifact.wait()
                 artifact._use_as = use_as or artifact.name
-            elif isinstance(artifact, public.Artifact):
+            elif isinstance(artifact, Artifact) and not artifact.is_draft():
                 if (
                     self._launch_artifact_mapping
                     and artifact.name in self._launch_artifact_mapping.keys()
                 ):
                     wandb.termwarn(
-                        "Swapping artifacts is not supported when using an instance of `public.Artifact`. "
+                        "Swapping artifacts is not supported when using a non-draft artifact. "
                         f"Using {artifact.name}."
                     )
                 artifact._use_as = use_as or artifact.name
@@ -2743,11 +2739,11 @@ class Run:
     @_run_decorator._attach
     def log_artifact(
         self,
-        artifact_or_path: Union[wandb_artifacts.Artifact, StrPath],
+        artifact_or_path: Union[Artifact, StrPath],
         name: Optional[str] = None,
         type: Optional[str] = None,
         aliases: Optional[List[str]] = None,
-    ) -> wandb_artifacts.Artifact:
+    ) -> Artifact:
         """Declare an artifact as an output of a run.
 
         Arguments:
@@ -2780,12 +2776,12 @@ class Run:
     @_run_decorator._attach
     def upsert_artifact(
         self,
-        artifact_or_path: Union[wandb_artifacts.Artifact, str],
+        artifact_or_path: Union[Artifact, str],
         name: Optional[str] = None,
         type: Optional[str] = None,
         aliases: Optional[List[str]] = None,
         distributed_id: Optional[str] = None,
-    ) -> wandb_artifacts.Artifact:
+    ) -> Artifact:
         """Declare (or append to) a non-finalized artifact as output of a run.
 
         Note that you must call run.finish_artifact() to finalize the artifact.
@@ -2834,12 +2830,12 @@ class Run:
     @_run_decorator._attach
     def finish_artifact(
         self,
-        artifact_or_path: Union[wandb_artifacts.Artifact, str],
+        artifact_or_path: Union[Artifact, str],
         name: Optional[str] = None,
         type: Optional[str] = None,
         aliases: Optional[List[str]] = None,
         distributed_id: Optional[str] = None,
-    ) -> wandb_artifacts.Artifact:
+    ) -> Artifact:
         """Finishes a non-finalized artifact as output of a run.
 
         Subsequent "upserts" with the same distributed ID will result in a new version.
@@ -2886,7 +2882,7 @@ class Run:
 
     def _log_artifact(
         self,
-        artifact_or_path: Union[wandb_artifacts.Artifact, StrPath],
+        artifact_or_path: Union[Artifact, StrPath],
         name: Optional[str] = None,
         type: Optional[str] = None,
         aliases: Optional[List[str]] = None,
@@ -2894,7 +2890,7 @@ class Run:
         finalize: bool = True,
         is_user_created: bool = False,
         use_after_commit: bool = False,
-    ) -> wandb_artifacts.Artifact:
+    ) -> Artifact:
         api = internal.Api()
         if api.settings().get("anonymous") == "true":
             wandb.termwarn(
@@ -2923,7 +2919,7 @@ class Run:
                     is_user_created=is_user_created,
                     use_after_commit=use_after_commit,
                 )
-                artifact._logged_artifact = _LazyArtifact(self._public_api(), future)
+                artifact._set_save_future(future, self._public_api().client)
             else:
                 self._backend.interface.publish_artifact(
                     self,
@@ -2946,10 +2942,9 @@ class Run:
 
     def _public_api(self, overrides: Optional[Dict[str, str]] = None) -> PublicApi:
         overrides = {"run": self._run_id}
-        run_obj = self._run_obj
-        if run_obj is not None:
-            overrides["entity"] = run_obj.entity
-            overrides["project"] = run_obj.project
+        if not (self._settings._offline or self._run_obj is None):
+            overrides["entity"] = self._run_obj.entity
+            overrides["project"] = self._run_obj.project
         return public.Api(overrides)
 
     # TODO(jhr): annotate this
@@ -2957,11 +2952,11 @@ class Run:
         if not self._settings._offline:
             try:
                 public_api = self._public_api()
-                expected_type = public.Artifact.expected_type(
-                    public_api.client,
-                    artifact.name,
+                expected_type = Artifact._expected_type(
                     public_api.settings["entity"],
                     public_api.settings["project"],
+                    artifact.name,
+                    public_api.client,
                 )
             except requests.exceptions.RequestException:
                 # Just return early if there is a network error. This is
@@ -2976,11 +2971,11 @@ class Run:
 
     def _prepare_artifact(
         self,
-        artifact_or_path: Union[wandb_artifacts.Artifact, StrPath],
+        artifact_or_path: Union[Artifact, StrPath],
         name: Optional[str] = None,
         type: Optional[str] = None,
         aliases: Optional[List[str]] = None,
-    ) -> Tuple[wandb_artifacts.Artifact, List[str]]:
+    ) -> Tuple[Artifact, List[str]]:
         if isinstance(artifact_or_path, (str, os.PathLike)):
             name = name or f"run-{self._run_id}-{os.path.basename(artifact_or_path)}"
             artifact = wandb.Artifact(name, type or "unspecified")
@@ -3703,160 +3698,3 @@ def finish(exit_code: Optional[int] = None, quiet: Optional[bool] = None) -> Non
     """
     if wandb.run:
         wandb.run.finish(exit_code=exit_code, quiet=quiet)
-
-
-class InvalidArtifact:
-    """An "artifact" that raises an error when any properties are accessed."""
-
-    def __init__(self, base_artifact: "ArtifactInterface"):
-        super().__setattr__("base_artifact", base_artifact)
-
-    def __getattr__(self, __name: str) -> Any:
-        raise ArtifactNotLoggedError(artifact=self.base_artifact, attr=__name)
-
-    def __setattr__(self, __name: str, __value: Any) -> None:
-        raise ArtifactNotLoggedError(artifact=self.base_artifact, attr=__name)
-
-    def __bool__(self) -> bool:
-        return False
-
-
-class WaitTimeoutError(errors.Error):
-    """Raised when wait() timeout occurs before process is finished."""
-
-
-class _LazyArtifact(ArtifactInterface):
-    _api: PublicApi
-    _instance: Union[ArtifactInterface, InvalidArtifact]
-    _future: Any
-
-    def __init__(self, api: PublicApi, future: Any):
-        self._api = api
-        self._instance = InvalidArtifact(self)
-        self._future = future
-
-    def __getattr__(self, item: str) -> Any:
-        return getattr(self._instance, item)
-
-    def wait(self, timeout: Optional[int] = None) -> ArtifactInterface:
-        if not self._instance:
-            future_get = self._future.get(timeout)
-            if not future_get:
-                raise WaitTimeoutError(
-                    "Artifact upload wait timed out, failed to fetch Artifact response"
-                )
-            resp = future_get.response.log_artifact_response
-            if resp.error_message:
-                raise ValueError(resp.error_message)
-            self._instance = public.Artifact.from_id(resp.artifact_id, self._api.client)
-        assert isinstance(
-            self._instance, ArtifactInterface
-        ), "Insufficient permissions to fetch Artifact with id {} from {}".format(
-            resp.artifact_id, self._api.client.app_url
-        )
-        return self._instance
-
-    @property
-    def id(self) -> Optional[str]:
-        return self._instance.id
-
-    @property
-    def source_version(self) -> Optional[str]:
-        return self._instance.source_version
-
-    @property
-    def version(self) -> str:
-        return self._instance.version
-
-    @property
-    def name(self) -> str:
-        return self._instance.name
-
-    @property
-    def full_name(self) -> str:
-        return self._instance.full_name
-
-    @property
-    def type(self) -> str:
-        return self._instance.type
-
-    @property
-    def entity(self) -> str:
-        return self._instance.entity
-
-    @property
-    def project(self) -> str:
-        return self._instance.project
-
-    @property
-    def manifest(self) -> "ArtifactManifest":
-        return self._instance.manifest
-
-    @property
-    def digest(self) -> str:
-        return self._instance.digest
-
-    @property
-    def state(self) -> str:
-        return self._instance.state
-
-    @property
-    def size(self) -> int:
-        return self._instance.size
-
-    @property
-    def commit_hash(self) -> str:
-        return self._instance.commit_hash
-
-    @property
-    def description(self) -> Optional[str]:
-        return self._instance.description
-
-    @description.setter
-    def description(self, desc: Optional[str]) -> None:
-        self._instance.description = desc
-
-    @property
-    def metadata(self) -> dict:
-        return self._instance.metadata
-
-    @metadata.setter
-    def metadata(self, metadata: dict) -> None:
-        self._instance.metadata = metadata
-
-    @property
-    def aliases(self) -> List[str]:
-        return self._instance.aliases
-
-    @aliases.setter
-    def aliases(self, aliases: List[str]) -> None:
-        self._instance.aliases = aliases
-
-    def used_by(self) -> List["wandb.apis.public.Run"]:
-        return self._instance.used_by()
-
-    def logged_by(self) -> "wandb.apis.public.Run":
-        return self._instance.logged_by()
-
-    def get_path(self, name: str) -> "ArtifactManifestEntry":
-        return self._instance.get_path(name)
-
-    def get(self, name: str) -> "WBValue":
-        return self._instance.get(name)
-
-    def download(
-        self, root: Optional[str] = None, recursive: bool = False
-    ) -> FilePathStr:
-        return self._instance.download(root, recursive)
-
-    def checkout(self, root: Optional[str] = None) -> str:
-        return self._instance.checkout(root)
-
-    def verify(self, root: Optional[str] = None) -> Any:
-        return self._instance.verify(root)
-
-    def save(self) -> None:
-        self._instance.save()
-
-    def delete(self) -> None:
-        self._instance.delete()

wandb/sdk/wandb_settings.py

@@ -37,13 +37,14 @@ import wandb.env
 from wandb import util
 from wandb.apis.internal import Api
 from wandb.errors import UsageError
+from wandb.sdk.internal.system.env_probe_helpers import is_aws_lambda
 from wandb.sdk.lib import filesystem
 from wandb.sdk.lib._settings_toposort_generated import SETTINGS_TOPOLOGICALLY_SORTED
 from wandb.sdk.wandb_config import Config
 from wandb.sdk.wandb_setup import _EarlyLogger
 
 from .lib import apikey
-from .lib.git import GitRepo
+from .lib.gitlib import GitRepo
 from .lib.ipython import _get_python_type
 from .lib.runid import generate_id
 
@@ -449,16 +450,18 @@ class Settings:
     # settings are declared as class attributes for static type checking purposes
     # and to help with IDE autocomplete.
     _args: Sequence[str]
+    _aws_lambda: bool
     _async_upload_concurrency_limit: int
     _cli_only_mode: bool  # Avoid running any code specific for runs
     _colab: bool
     _config_dict: Config
     _console: SettingsConsole
     _cuda: str
-    _disable_meta: bool
-    _disable_service: bool
-    _disable_stats: bool
+    _disable_meta: bool  # Do not collect system metadata
+    _disable_service: bool  # Disable wandb-service, spin up internal process the old way
+    _disable_stats: bool  # Do not collect system metrics
     _disable_viewer: bool  # Prevent early viewer query
+    _disable_setproctitle: bool  # Do not use setproctitle on internal process
     _except_exit: bool
     _executable: str
     _extra_http_headers: Mapping[str, str]
@@ -484,6 +487,7 @@ class Settings:
     _platform: str
     _python: str
     _runqueue_item_id: str
+    _require_nexus: bool
     _save_requirements: bool
     _service_transport: str
     _service_wait: float
@@ -506,6 +510,7 @@ class Settings:
     allow_val_change: bool
     anonymous: str
     api_key: str
+    azure_account_url_to_access_key: Dict[str, str]
     base_url: str  # The base url for the wandb api
     code_dir: str
     config_paths: Sequence[str]
@@ -530,6 +535,7 @@ class Settings:
     ignore_globs: Tuple[str]
     init_timeout: float
     is_local: bool
+    job_source: str
     label_disable: bool
     launch: bool
     launch_config_path: str
@@ -599,6 +605,10 @@ class Settings:
         Note that key names must be the same as the class attribute names.
         """
         props: Dict[str, Dict[str, Any]] = dict(
+            _aws_lambda={
+                "hook": lambda _: is_aws_lambda(),
+                "auto_hook": True,
+            },
             _async_upload_concurrency_limit={
                 "preprocessor": int,
                 "validator": self._validate__async_upload_concurrency_limit,
@@ -609,6 +619,7 @@ class Settings:
                 "preprocessor": _str_as_bool,
                 "is_policy": True,
             },
+            _disable_setproctitle={"value": False, "preprocessor": _str_as_bool},
             _disable_stats={"preprocessor": _str_as_bool},
             _disable_viewer={"preprocessor": _str_as_bool},
             _extra_http_headers={"preprocessor": _str_as_json},
@@ -655,6 +666,7 @@ class Settings:
             },
             _sync={"value": False},
             _platform={"value": util.get_platform_name()},
+            _require_nexus={"value": False, "preprocessor": _str_as_bool},
             _save_requirements={"value": True, "preprocessor": _str_as_bool},
             _service_wait={
                 "value": 30,
@@ -693,6 +705,7 @@ class Settings:
             },
             anonymous={"validator": self._validate_anonymous},
             api_key={"validator": self._validate_api_key},
+            azure_account_url_to_access_key={"value": {}},
             base_url={
                 "value": "https://api.wandb.ai",
                 "preprocessor": lambda x: str(x).strip().rstrip("/"),
@@ -731,6 +744,7 @@ class Settings:
                 ),
                 "auto_hook": True,
             },
+            job_source={"validator": self._validate_job_source},
             label_disable={"preprocessor": _str_as_bool},
             launch={"preprocessor": _str_as_bool},
             log_dir={
@@ -1113,6 +1127,15 @@ class Settings:
 
         return True
 
+    @staticmethod
+    def _validate_job_source(value: str) -> bool:
+        valid_sources = ["repo", "artifact", "image"]
+        if value not in valid_sources:
+            raise UsageError(
+                f"Settings field `job_source`: {value!r} not in {valid_sources}"
+            )
+        return True
+
     # other helper methods
     @staticmethod
     def _path_convert(*args: str) -> str:
@@ -1542,6 +1565,7 @@ class Settings:
             "WANDB_TRACELOG": "_tracelog",
             "WANDB_DISABLE_SERVICE": "_disable_service",
             "WANDB_SERVICE_TRANSPORT": "_service_transport",
+            "WANDB_REQUIRE_NEXUS": "_require_nexus",
             "WANDB_DIR": "root_dir",
             "WANDB_NAME": "run_name",
             "WANDB_NOTES": "run_notes",