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

wandb/sdk/wandb_init.py

@@ -663,6 +663,9 @@ class _WandbInit:
             if os.environ.get("PEX"):
                 tel.env.pex = True
 
+            if self.settings._aws_lambda:
+                tel.env.aws_lambda = True
+
             if os.environ.get(wandb.env._DISABLE_SERVICE):
                 tel.feature.service_disabled = True
 
@@ -672,6 +675,8 @@ class _WandbInit:
                 tel.feature.flow_control_disabled = True
             if self.settings._flow_control_custom:
                 tel.feature.flow_control_custom = True
+            if self.settings._require_nexus:
+                tel.feature.nexus = True
 
             tel.env.maybe_mp = _maybe_mp_process(backend)
 
@@ -715,86 +720,82 @@ class _WandbInit:
         if not self.settings.disable_git:
             run._populate_git_info()
 
-        run_proto = backend.interface._make_run(run)
         run_result: Optional["pb.RunUpdateResult"] = None
 
         if self.settings._offline:
             with telemetry.context(run=run) as tel:
                 tel.feature.offline = True
 
-            backend.interface.publish_run(run_proto)
-            run._set_run_obj_offline(run_proto)
             if self.settings.resume:
                 wandb.termwarn(
                     "`resume` will be ignored since W&B syncing is set to `offline`. "
                     f"Starting a new run with run id {run.id}."
                 )
-        else:
-            error: Optional["wandb.errors.Error"] = None
+        error: Optional["wandb.errors.Error"] = None
 
-            timeout = self.settings.init_timeout
+        timeout = self.settings.init_timeout
 
-            logger.info(f"communicating run to backend with {timeout} second timeout")
+        logger.info(f"communicating run to backend with {timeout} second timeout")
 
-            run_init_handle = backend.interface.deliver_run(run_proto)
-            result = run_init_handle.wait(
-                timeout=timeout,
-                on_progress=self._on_progress_init,
-                cancel=True,
+        run_init_handle = backend.interface.deliver_run(run)
+        result = run_init_handle.wait(
+            timeout=timeout,
+            on_progress=self._on_progress_init,
+            cancel=True,
+        )
+        if result:
+            run_result = result.run_result
+
+        if run_result is None:
+            error_message = (
+                f"Run initialization has timed out after {timeout} sec. "
+                f"\nPlease refer to the documentation for additional information: {wburls.get('doc_start_err')}"
+            )
+            # We're not certain whether the error we encountered is due to an issue
+            # with the server (a "CommError") or if it's a problem within the SDK (an "Error").
+            # This means that the error could be a result of the server being unresponsive,
+            # or it could be because we were unable to communicate with the wandb service.
+            error = CommError(error_message)
+            run_init_handle._cancel()
+        elif run_result.HasField("error"):
+            error = ProtobufErrorHandler.to_exception(run_result.error)
+
+        if error is not None:
+            logger.error(f"encountered error: {error}")
+            if not manager:
+                # Shutdown the backend and get rid of the logger
+                # we don't need to do console cleanup at this point
+                backend.cleanup()
+                self.teardown()
+            raise error
+
+        assert run_result is not None  # for mypy
+
+        if not run_result.HasField("run"):
+            raise Error(
+                "It appears that something have gone wrong during the program execution as an unexpected missing field was encountered. "
+                "(run_result is missing the 'run' field)"
             )
-            if result:
-                run_result = result.run_result
 
-            if run_result is None:
-                error_message = (
-                    f"Run initialization has timed out after {timeout} sec. "
-                    f"\nPlease refer to the documentation for additional information: {wburls.get('doc_start_err')}"
-                )
-                # We're not certain whether the error we encountered is due to an issue
-                # with the server (a "CommError") or if it's a problem within the SDK (an "Error").
-                # This means that the error could be a result of the server being unresponsive,
-                # or it could be because we were unable to communicate with the wandb service.
-                error = CommError(error_message)
-                run_init_handle._cancel()
-            elif run_result.HasField("error"):
-                error = ProtobufErrorHandler.to_exception(run_result.error)
-
-            if error is not None:
-                logger.error(f"encountered error: {error}")
-                if not manager:
-                    # Shutdown the backend and get rid of the logger
-                    # we don't need to do console cleanup at this point
-                    backend.cleanup()
-                    self.teardown()
-                raise error
-
-            assert run_result is not None  # for mypy
-
-            if not run_result.HasField("run"):
-                raise Error(
-                    "It appears that something have gone wrong during the program execution as an unexpected missing field was encountered. "
-                    "(run_result is missing the 'run' field)"
-                )
+        if run_result.run.resumed:
+            logger.info("run resumed")
+            with telemetry.context(run=run) as tel:
+                tel.feature.resumed = run_result.run.resumed
 
-            if run_result.run.resumed:
-                logger.info("run resumed")
-                with telemetry.context(run=run) as tel:
-                    tel.feature.resumed = run_result.run.resumed
+        run._set_run_obj(run_result.run)
 
-            run._set_run_obj(run_result.run)
-            run._on_init()
+        run._on_init()
 
         logger.info("starting run threads in backend")
         # initiate run (stats and metadata probing)
-        run_obj = run._run_obj or run._run_obj_offline
 
         if manager:
             manager._inform_start(settings=self.settings, run_id=self.settings.run_id)
 
         assert backend.interface
-        assert run_obj
+        assert run._run_obj
 
-        run_start_handle = backend.interface.deliver_run_start(run_obj)
+        run_start_handle = backend.interface.deliver_run_start(run._run_obj)
         # TODO: add progress to let user know we are doing something
         run_start_result = run_start_handle.wait(timeout=30)
         if run_start_result is None:
@@ -881,6 +882,7 @@ def _attach(
             "run_id": attach_id,
             "_start_time": response["_start_time"],
             "_start_datetime": response["_start_datetime"],
+            "_offline": response["_offline"],
         },
         source=Source.INIT,
     )
@@ -901,6 +903,7 @@ def _attach(
     assert backend.interface
 
     mailbox.enable_keepalive()
+
     attach_handle = backend.interface.deliver_attach(attach_id)
     # TODO: add progress to let user know we are doing something
     attach_result = attach_handle.wait(timeout=30)
@@ -910,6 +913,7 @@ def _attach(
     attach_response = attach_result.response.attach_response
     if attach_response.error and attach_response.error.message:
         raise UsageError(f"Failed to attach to run: {attach_response.error.message}")
+
     run._set_run_obj(attach_response.run)
     run._on_attach()
     return run

wandb/sdk/wandb_require.py

@@ -9,6 +9,7 @@ Example:
     wandb.require("incremental-artifacts@beta")
 """
 
+import os
 from typing import Optional, Sequence, Union
 
 import wandb
@@ -38,6 +39,12 @@ class _Requires:
     def require_service(self) -> None:
         self._require_service()
 
+    def _require_nexus(self) -> None:
+        os.environ["WANDB_REQUIRE_NEXUS"] = "True"
+
+    def require_nexus(self) -> None:
+        self._require_nexus()
+
     def apply(self) -> None:
         """Call require_* method for supported features."""
         last_message: str = ""