wandb 0.17.6__py3-none-any.whl → 0.17.8__py3-none-any.whl

wandb/sdk/data_types/_dtypes.py

@@ -56,7 +56,7 @@ class TypeRegistry:
         # but will be ultimately treated as a None. Ignoring type since
         # mypy does not trust that py_obj is a float by the time it is
         # passed to isnan.
-        if py_obj.__class__ == float and math.isnan(py_obj):  # type: ignore
+        if py_obj.__class__ is float and math.isnan(py_obj):  # type: ignore
             return NoneType()
 
         # TODO: generalize this to handle other config input types
@@ -134,7 +134,7 @@ def _params_obj_to_json_obj(
     artifact: t.Optional["Artifact"] = None,
 ) -> t.Any:
     """Helper method."""
-    if params_obj.__class__ == dict:
+    if params_obj.__class__ is dict:
         return {
             key: _params_obj_to_json_obj(params_obj[key], artifact)
             for key in params_obj
@@ -151,7 +151,7 @@ def _json_obj_to_params_obj(
     json_obj: t.Any, artifact: t.Optional["Artifact"] = None
 ) -> t.Any:
     """Helper method."""
-    if json_obj.__class__ == dict:
+    if json_obj.__class__ is dict:
         if "wb_type" in json_obj:
             return TypeRegistry.type_from_dict(json_obj, artifact)
         else:
@@ -159,7 +159,7 @@ def _json_obj_to_params_obj(
                 key: _json_obj_to_params_obj(json_obj[key], artifact)
                 for key in json_obj
             }
-    elif json_obj.__class__ == list:
+    elif json_obj.__class__ is list:
         return [_json_obj_to_params_obj(item, artifact) for item in json_obj]
     else:
         return json_obj
@@ -533,7 +533,7 @@ class UnionType(Type):
         self,
         allowed_types: t.Optional[t.Sequence[ConvertibleToType]] = None,
     ):
-        assert allowed_types is None or (allowed_types.__class__ == list)
+        assert allowed_types is None or (allowed_types.__class__ is list)
         if allowed_types is None:
             wb_types = []
         else:

wandb/sdk/data_types/base_types/media.py

@@ -159,9 +159,11 @@ class Media(WBValue):
         # into Media itself we should get rid of them
         from wandb import Image
         from wandb.data_types import Audio
+        from wandb.sdk.wandb_run import Run
 
         json_obj = {}
-        if isinstance(run, wandb.wandb_sdk.wandb_run.Run):
+
+        if isinstance(run, Run):
             json_obj.update(
                 {
                     "_type": "file",  # TODO(adrian): This isn't (yet) a real media type we support on the frontend.

wandb/sdk/data_types/helper_types/bounding_boxes_2d.py

@@ -276,7 +276,9 @@ class BoundingBoxes2D(JSONMetadata):
         return True
 
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
-        if isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run):
+        from wandb.sdk.wandb_run import Run
+
+        if isinstance(run_or_artifact, Run):
             return super().to_json(run_or_artifact)
         elif isinstance(run_or_artifact, wandb.Artifact):
             # TODO (tim): I would like to log out a proper dictionary representing this object, but don't

wandb/sdk/data_types/helper_types/image_mask.py

@@ -191,9 +191,11 @@ class ImageMask(Media):
         )
 
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        from wandb.sdk.wandb_run import Run
+
         json_dict = super().to_json(run_or_artifact)
 
-        if isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run):
+        if isinstance(run_or_artifact, Run):
             json_dict["_type"] = self.type_name()
             return json_dict
         elif isinstance(run_or_artifact, wandb.Artifact):

wandb/sdk/data_types/image.py

@@ -418,6 +418,8 @@ class Image(BatchableMedia):
                 )
 
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        from wandb.sdk.wandb_run import Run
+
         json_dict = super().to_json(run_or_artifact)
         json_dict["_type"] = Image._log_type
         json_dict["format"] = self.format
@@ -456,7 +458,7 @@ class Image(BatchableMedia):
                     "digest": classes_entry.digest,
                 }
 
-        elif not isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run):
+        elif not isinstance(run_or_artifact, Run):
             raise ValueError("to_json accepts wandb_run.Run or wandb_artifact.Artifact")
 
         if self._boxes:

wandb/sdk/data_types/saved_model.py

@@ -148,7 +148,9 @@ class _SavedModel(WBValue, Generic[SavedModelObjType]):
         # bit of tech debt in the other data types which requires the input to `to_json`
         # to accept a Run or Artifact. However, Run additions should be deprecated in the future.
         # This check helps ensure we do not add to the debt.
-        if isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run):
+        from wandb.sdk.wandb_run import Run
+
+        if isinstance(run_or_artifact, Run):
             raise ValueError("SavedModel cannot be added to run - must use artifact")
         artifact = run_or_artifact
         json_obj = {

wandb/sdk/data_types/video.py

@@ -214,9 +214,9 @@ class Video(BatchableMedia):
         n_rows = 2 ** ((b.bit_length() - 1) // 2)
         n_cols = video.shape[0] // n_rows
 
-        video = np.reshape(video, newshape=(n_rows, n_cols, t, c, h, w))
+        video = video.reshape(n_rows, n_cols, t, c, h, w)
         video = np.transpose(video, axes=(2, 0, 4, 1, 5, 3))
-        video = np.reshape(video, newshape=(t, n_rows * h, n_cols * w, c))
+        video = video.reshape(t, n_rows * h, n_cols * w, c)
         return video
 
     @classmethod

wandb/sdk/interface/interface.py

@@ -54,18 +54,20 @@ MANIFEST_FILE_SIZE_THRESHOLD = 100_000
 
 GlobStr = NewType("GlobStr", str)
 
-if TYPE_CHECKING:
-    from ..wandb_run import Run
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+PolicyName = Literal["now", "live", "end"]
 
-    if sys.version_info >= (3, 8):
-        from typing import Literal, TypedDict
-    else:
-        from typing_extensions import Literal, TypedDict
 
-    PolicyName = Literal["now", "live", "end"]
+class FilesDict(TypedDict):
+    files: Iterable[Tuple[GlobStr, PolicyName]]
 
-    class FilesDict(TypedDict):
-        files: Iterable[Tuple[GlobStr, PolicyName]]
+
+if TYPE_CHECKING:
+    from ..wandb_run import Run
 
 
 logger = logging.getLogger("wandb")
@@ -112,15 +114,14 @@ class InterfaceBase:
     def _publish_header(self, header: pb.HeaderRecord) -> None:
         raise NotImplementedError
 
-    def communicate_status(self) -> Optional[pb.StatusResponse]:
-        status = pb.StatusRequest()
-        resp = self._communicate_status(status)
-        return resp
+    def deliver_status(self) -> MailboxHandle:
+        return self._deliver_status(pb.StatusRequest())
 
     @abstractmethod
-    def _communicate_status(
-        self, status: pb.StatusRequest
-    ) -> Optional[pb.StatusResponse]:
+    def _deliver_status(
+        self,
+        status: pb.StatusRequest,
+    ) -> MailboxHandle:
         raise NotImplementedError
 
     def _make_config(

wandb/sdk/interface/interface_shared.py

@@ -299,7 +299,7 @@ class InterfaceShared(InterfaceBase):
         raise NotImplementedError
 
     def _communicate(
-        self, rec: pb.Record, timeout: Optional[int] = 5, local: Optional[bool] = None
+        self, rec: pb.Record, timeout: Optional[int] = 30, local: Optional[bool] = None
     ) -> Optional[pb.Result]:
         return self._communicate_async(rec, local=local).get(timeout=timeout)
 
@@ -421,15 +421,12 @@ class InterfaceShared(InterfaceBase):
         rec = self._make_record(alert=proto_alert)
         self._publish(rec)
 
-    def _communicate_status(
-        self, status: pb.StatusRequest
-    ) -> Optional[pb.StatusResponse]:
+    def _deliver_status(
+        self,
+        status: pb.StatusRequest,
+    ) -> MailboxHandle:
         req = self._make_request(status=status)
-        resp = self._communicate(req, local=True)
-        if resp is None:
-            return None
-        assert resp.response.status_response
-        return resp.response.status_response
+        return self._deliver_record(req)
 
     def _publish_exit(self, exit_data: pb.RunExitRecord) -> None:
         rec = self._make_record(exit=exit_data)

wandb/sdk/internal/datastore.py

@@ -69,7 +69,7 @@ class DataStore:
 
     def __init__(self) -> None:
         self._opened_for_scan = False
-        self._fp: Optional["IO[Any]"] = None
+        self._fp: Optional[IO[Any]] = None
         self._index = 0
         self._flush_offset = 0
         self._size_bytes = 0

wandb/sdk/internal/handler.py

@@ -660,7 +660,11 @@ class HandleManager:
         self._dispatch_record(record)
 
     def handle_request_check_version(self, record: Record) -> None:
-        self._dispatch_record(record)
+        if self._settings._offline:
+            result = proto_util._result_from_record(record)
+            self._respond_result(result)
+        else:
+            self._dispatch_record(record)
 
     def handle_request_attach(self, record: Record) -> None:
         result = proto_util._result_from_record(record)
@@ -745,8 +749,6 @@ class HandleManager:
         self._respond_result(result)
 
     def handle_request_status(self, record: Record) -> None:
-        # TODO(mempressure): do something better?
-        assert record.control.req_resp
         result = proto_util._result_from_record(record)
         self._respond_result(result)
 

wandb/sdk/internal/internal.py

@@ -62,7 +62,7 @@ def wandb_internal(
 
     """
     # mark this process as internal
-    wandb._set_internal_process()
+    wandb._set_internal_process()  # type: ignore
     _setup_tracelog()
     started = time.time()
 

wandb/sdk/internal/job_builder.py

@@ -423,15 +423,18 @@ class JobBuilder:
         api: Api,
         build_context: Optional[str] = None,
         dockerfile: Optional[str] = None,
+        base_image: Optional[str] = None,
     ) -> Optional[Artifact]:
         """Build a job artifact from the current run.
 
         Arguments:
+            api (Api): The API object to use to create the job artifact.
             build_context (Optional[str]): Path within the job source code to
                 the image build context. Saved as part of the job for future
                 builds.
             dockerfile (Optional[str]): Path within the build context the
                 Dockerfile. Saved as part of the job for future builds.
+            base_image (Optional[str]): The base image used to run the job code.
 
         Returns:
             Optional[Artifact]: The job artifact if it was successfully built,
@@ -467,8 +470,6 @@ class JobBuilder:
                 "warn",
             )
             return None
-        metadata["dockerfile"] = dockerfile
-        metadata["build_context"] = build_context
 
         runtime: Optional[str] = metadata.get("python")
         # can't build a job without a python version
@@ -520,6 +521,8 @@ class JobBuilder:
             source["build_context"] = build_context  # type: ignore[typeddict-item]
         if dockerfile:
             source["dockerfile"] = dockerfile  # type: ignore[typeddict-item]
+        if base_image:
+            source["base_image"] = base_image  # type: ignore[typeddict-item]
 
         # Pop any keys that are initialized to None. The current TypedDict
         # system for source dicts requires all keys to be present, but we

wandb/sdk/internal/tb_watcher.py

@@ -123,7 +123,7 @@ class TBWatcher:
         self._force = force
         # TODO(jhr): do we need locking in this queue?
         self._watcher_queue = queue.PriorityQueue()
-        wandb.tensorboard.reset_state()
+        wandb.tensorboard.reset_state()  # type: ignore
 
     def _calculate_namespace(self, logdir: str, rootdir: str) -> Optional[str]:
         namespace: Optional[str]
@@ -430,7 +430,7 @@ class TBEventConsumer:
     def _handle_event(
         self, event: "ProtoEvent", history: Optional["TBHistory"] = None
     ) -> None:
-        wandb.tensorboard._log(
+        wandb.tensorboard._log(  # type: ignore
             event.event,
             step=event.event.step,
             namespace=event.namespace,

wandb/sdk/internal/update.py

@@ -10,7 +10,7 @@ def _find_available(
 ) -> Optional[Tuple[str, bool, bool, bool, Optional[str]]]:
     from wandb.util import parse_version
 
-    pypi_url = f"https://pypi.org/pypi/{wandb._wandb_module}/json"
+    pypi_url = "https://pypi.org/pypi/wandb/json"
 
     yanked_dict = {}
     try:
@@ -78,7 +78,7 @@ def check_available(current_version: str) -> Optional[Dict[str, Optional[str]]]:
     if not package_info:
         return None
 
-    wandb_module_name = wandb._wandb_module
+    wandb_module_name = "wandb"
 
     latest_version, pip_prerelease, deleted, yanked, yanked_reason = package_info
     upgrade_message = (

wandb/sdk/launch/builder/kaniko_builder.py

@@ -63,6 +63,13 @@ else:
     NAMESPACE = "wandb"
 
 
+def get_pod_name_safe(job: client.V1Job):
+    try:
+        return job.spec.template.metadata.name
+    except AttributeError:
+        return None
+
+
 async def _wait_for_completion(
     batch_client: client.BatchV1Api, job_name: str, deadline_secs: Optional[int] = None
 ) -> bool:
@@ -319,17 +326,18 @@ class KanikoBuilder(AbstractBuilder):
                 await self._create_docker_ecr_config_map(
                     build_job_name, core_v1, repo_uri
                 )
-            await batch_v1.create_namespaced_job(NAMESPACE, build_job)
-
+            k8s_job = await batch_v1.create_namespaced_job(NAMESPACE, build_job)
             # wait for double the job deadline since it might take time to schedule
             if not await _wait_for_completion(
                 batch_v1, build_job_name, 3 * _DEFAULT_BUILD_TIMEOUT_SECS
             ):
                 if job_tracker:
                     job_tracker.set_err_stage("build")
-                raise Exception(
-                    f"Failed to build image in kaniko for job {run_id}. View logs with `kubectl logs -n {NAMESPACE} {build_job_name}`."
-                )
+                msg = f"Failed to build image in kaniko for job {run_id}."
+                pod_name = get_pod_name_safe(k8s_job)
+                if pod_name:
+                    msg += f" View logs with `kubectl logs -n {NAMESPACE} {pod_name}`."
+                raise Exception(msg)
             try:
                 pods_from_job = await core_v1.list_namespaced_pod(
                     namespace=NAMESPACE, label_selector=f"job-name={build_job_name}"

wandb/sdk/launch/create_job.py

@@ -114,6 +114,7 @@ def _create_job(
     git_hash: Optional[str] = None,
     build_context: Optional[str] = None,
     dockerfile: Optional[str] = None,
+    base_image: Optional[str] = None,
 ) -> Tuple[Optional[Artifact], str, List[str]]:
     wandb.termlog(f"Creating launch job of type: {job_type}...")
 
@@ -188,6 +189,7 @@ def _create_job(
         api.api,
         dockerfile=dockerfile,
         build_context=build_context,
+        base_image=base_image,
     )
     if not artifact:
         wandb.termerror("JobBuilder failed to build a job")

wandb/sdk/lib/_settings_toposort_generated.py

@@ -63,6 +63,7 @@ _Setting = Literal[
     "_python",
     "_runqueue_item_id",
     "_require_core",
+    "_require_legacy_service",
     "_save_requirements",
     "_service_transport",
     "_service_wait",

wandb/sdk/lib/apikey.py

@@ -107,7 +107,7 @@ def prompt_api_key(  # noqa: C901
 
     if jupyter and "google.colab" in sys.modules:
         log_string = term.LOG_STRING_NOCOLOR
-        key = wandb.jupyter.attempt_colab_login(app_url)
+        key = wandb.jupyter.attempt_colab_login(app_url)  # type: ignore
         if key is not None:
             write_key(settings, key, api=api)
             return key  # type: ignore

wandb/sdk/service/service.py

@@ -15,7 +15,12 @@ import time
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from wandb import _sentry, termlog
-from wandb.env import core_debug, core_error_reporting_enabled, is_require_core
+from wandb.env import (
+    core_debug,
+    core_error_reporting_enabled,
+    is_require_core,
+    is_require_legacy_service,
+)
 from wandb.errors import Error, WandbCoreNotAvailableError
 from wandb.sdk.lib.wburls import wburls
 from wandb.util import get_core_path, get_module
@@ -164,7 +169,7 @@ class _Service:
 
             service_args = []
 
-            if is_require_core():
+            if is_require_core() and not is_require_legacy_service():
                 try:
                     core_path = get_core_path()
                 except WandbCoreNotAvailableError as e:

wandb/sdk/service/streams.py

@@ -81,9 +81,7 @@ class StreamRecord:
         self._wait_thread_active()
 
     def _wait_thread_active(self) -> None:
-        result = self._iface.communicate_status()
-        # TODO: using the default communicate timeout, is that enough? retries?
-        assert result
+        self._iface.deliver_status().wait(timeout=-1)
 
     def join(self) -> None:
         self._iface.join()
@@ -212,7 +210,7 @@ class StreamMux:
         # run_id = action.stream_id  # will want to fix if a streamid != runid
         settings = action._data
         thread = StreamThread(
-            target=wandb.wandb_sdk.internal.internal.wandb_internal,
+            target=wandb.wandb_sdk.internal.internal.wandb_internal,  # type: ignore
             kwargs=dict(
                 settings=settings,
                 record_q=stream._record_q,

wandb/sdk/wandb_config.py

@@ -61,7 +61,7 @@ class Config:
 
         Using absl flags
         ```
-        flags.DEFINE_string(‘model’, None, ‘model to run’) # name, default, help
+        flags.DEFINE_string("model", None, "model to run") # name, default, help
         wandb.config.update(flags.FLAGS) # adds all absl flags to config
         ```
 
@@ -129,6 +129,9 @@ class Config:
     def __getitem__(self, key):
         return self._items[key]
 
+    def __iter__(self):
+        return iter(self._items)
+
     def _check_locked(self, key, ignore_locked=False) -> bool:
         locked = self._locked.get(key)
         if locked is not None:

wandb/sdk/wandb_init.py

@@ -15,6 +15,7 @@ import os
 import platform
 import sys
 import tempfile
+import time
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
 
 import wandb
@@ -174,7 +175,9 @@ class _WandbInit:
         # we add this logic to be backward compatible with the old behavior of disable
         # where it would disable the service if the mode was set to disabled
         mode = kwargs.get("mode")
-        settings_mode = (kwargs.get("settings") or {}).get("mode")
+        settings_mode = (kwargs.get("settings") or {}).get("mode") or os.environ.get(
+            "WANDB_MODE"
+        )
         _disable_service = mode == "disabled" or settings_mode == "disabled"
         setup_settings = {"_disable_service": _disable_service}
 
@@ -262,7 +265,7 @@ class _WandbInit:
 
         monitor_gym = kwargs.pop("monitor_gym", None)
         if monitor_gym and len(wandb.patched["gym"]) == 0:
-            wandb.gym.monitor()
+            wandb.gym.monitor()  # type: ignore
 
         if wandb.patched["tensorboard"]:
             with telemetry.context(obj=self._init_telemetry_obj) as tel:
@@ -271,7 +274,7 @@ class _WandbInit:
         tensorboard = kwargs.pop("tensorboard", None)
         sync_tensorboard = kwargs.pop("sync_tensorboard", None)
         if tensorboard or sync_tensorboard and len(wandb.patched["tensorboard"]) == 0:
-            wandb.tensorboard.patch()
+            wandb.tensorboard.patch()  # type: ignore
             with telemetry.context(obj=self._init_telemetry_obj) as tel:
                 tel.feature.tensorboard_sync = True
 
@@ -459,7 +462,7 @@ class _WandbInit:
 
     def _jupyter_setup(self, settings: Settings) -> None:
         """Add hooks, and session history saving."""
-        self.notebook = wandb.jupyter.Notebook(settings)
+        self.notebook = wandb.jupyter.Notebook(settings)  # type: ignore
         ipython = self.notebook.shell
 
         # Monkey patch ipython publish to capture displayed outputs
@@ -522,17 +525,62 @@ class _WandbInit:
         logger.info(f"Logging internal logs to {settings.log_internal}")
 
     def _make_run_disabled(self) -> Run:
+        """Returns a Run-like object where all methods are no-ops.
+
+        This method is used when wandb.init(mode="disabled") is called or WANDB_MODE=disabled
+        is set. It creates a Run object that mimics the behavior of a normal Run but doesn't
+        communicate with the W&B servers.
+
+        The returned Run object has all expected attributes and methods, but they are
+        no-op versions that don't perform any actual logging or communication.
+        """
         drun = Run(settings=Settings(mode="disabled", files_dir=tempfile.gettempdir()))
-        drun._config = wandb.wandb_sdk.wandb_config.Config()
+        # config and summary objects
+        drun._config = wandb.sdk.wandb_config.Config()
         drun._config.update(self.sweep_config)
         drun._config.update(self.config)
         drun.summary = SummaryDisabled()  # type: ignore
+        # methods
         drun.log = lambda data, *_, **__: drun.summary.update(data)  # type: ignore
         drun.finish = lambda *_, **__: module.unset_globals()  # type: ignore
+        drun.join = drun.finish  # type: ignore
+        drun.define_metric = lambda *_, **__: wandb.sdk.wandb_metric.Metric("dummy")  # type: ignore
+        drun.save = lambda *_, **__: False  # type: ignore
+        for symbol in (
+            "alert",
+            "finish_artifact",
+            "get_project_url",
+            "get_sweep_url",
+            "get_url",
+            "link_artifact",
+            "link_model",
+            "use_artifact",
+            "log_artifact",
+            "log_code",
+            "log_model",
+            "use_model",
+            "mark_preempting",
+            "plot_table",
+            "restore",
+            "status",
+            "watch",
+            "unwatch",
+            "upsert_artifact",
+        ):
+            setattr(drun, symbol, lambda *_, **__: None)  # type: ignore
+        # attributes
         drun._step = 0
+        drun._attach_id = None
         drun._run_obj = None
         drun._run_id = runid.generate_id()
         drun._name = "dummy-" + drun.id
+        drun._project = "dummy"
+        drun._entity = "dummy"
+        drun._tags = tuple()
+        drun._notes = None
+        drun._group = None
+        drun._start_time = time.time()
+        drun._starting_step = 0
         module.set_global(
             run=drun,
             config=drun.config,
@@ -688,7 +736,10 @@ class _WandbInit:
                 tel.feature.flow_control_disabled = True
             if self.settings._flow_control_custom:
                 tel.feature.flow_control_custom = True
-            if self.settings._require_core:
+            if (
+                self.settings._require_core
+                and not self.settings._require_legacy_service
+            ):
                 tel.feature.core = True
             if self.settings._shared:
                 wandb.termwarn(
@@ -868,7 +919,7 @@ def _attach(
         raise UsageError(
             "Either `attach_id` or `run_id` must be specified or `run` must have `_attach_id`"
         )
-    wandb._assert_is_user_process()
+    wandb._assert_is_user_process()  # type: ignore
 
     _wl = wandb_setup._setup()
     assert _wl
@@ -1157,7 +1208,7 @@ def init(
     Returns:
         A `Run` object.
     """
-    wandb._assert_is_user_process()
+    wandb._assert_is_user_process()  # type: ignore
 
     kwargs = dict(locals())
 

wandb/sdk/wandb_manager.py

@@ -13,7 +13,6 @@ import wandb
 from wandb import env, trigger
 from wandb.errors import Error
 from wandb.sdk.lib.exit_hooks import ExitHooks
-from wandb.sdk.lib.import_hooks import unregister_all_post_import_hooks
 
 if TYPE_CHECKING:
     from wandb.proto import wandb_settings_pb2
@@ -163,8 +162,6 @@ class _Manager:
         This sends a teardown record to the process. An exception is raised if
         the process has already been shut down.
         """
-        unregister_all_post_import_hooks()
-
         if self._atexit_lambda:
             atexit.unregister(self._atexit_lambda)
             self._atexit_lambda = None

wandb/sdk/wandb_require.py

@@ -13,7 +13,12 @@ import os
 from typing import Optional, Sequence, Union
 
 import wandb
-from wandb.env import _REQUIRE_CORE
+from wandb.env import (
+    _REQUIRE_CORE,
+    _REQUIRE_LEGACY_SERVICE,
+    is_require_core,
+    is_require_legacy_service,
+)
 from wandb.errors import UnsupportedError
 from wandb.sdk import wandb_run
 from wandb.sdk.lib.wburls import wburls
@@ -41,8 +46,24 @@ class _Requires:
         self._require_service()
 
     def require_core(self) -> None:
+        if is_require_legacy_service():
+            raise UnsupportedError(
+                'Cannot use wandb.require("core") because legacy-service'
+                " is already required--did you use"
+                ' wandb.require("legacy-service") or set the'
+                " WANDB__REQUIRE_LEGACY_SERVICE environment variable?"
+            )
         os.environ[_REQUIRE_CORE] = "true"
 
+    def require_legacy_service(self) -> None:
+        if is_require_core():
+            raise UnsupportedError(
+                'Cannot use wandb.require("legacy-service") because core'
+                ' is already required--did you use wandb.require("core")'
+                " or set the WANDB__REQUIRE_CORE environment variable?"
+            )
+        os.environ[_REQUIRE_LEGACY_SERVICE] = "true"
+
     def apply(self) -> None:
         """Call require_* method for supported features."""
         last_message: str = ""