wandb 0.19.4rc1__py3-none-win32.whl → 0.19.6rc4__py3-none-win32.whl

wandb/sdk/backend/backend.py

@@ -25,8 +25,6 @@ if TYPE_CHECKING:
     from wandb.proto.wandb_internal_pb2 import Record, Result
     from wandb.sdk.lib import service_connection
 
-    from ..wandb_run import Run
-
     RecordQueue = Union["queue.Queue[Record]", multiprocessing.Queue[Record]]
     ResultQueue = Union["queue.Queue[Result]", multiprocessing.Queue[Result]]
 
@@ -54,7 +52,7 @@ class Backend:
     interface: Optional[InterfaceBase]
     _internal_pid: Optional[int]
     wandb_process: Optional[multiprocessing.process.BaseProcess]
-    _settings: Optional[Settings]
+    _settings: Settings
     record_q: Optional["RecordQueue"]
     result_q: Optional["ResultQueue"]
     _mailbox: Mailbox
@@ -62,7 +60,7 @@ class Backend:
     def __init__(
         self,
         mailbox: Mailbox,
-        settings: Optional[Settings] = None,
+        settings: Settings,
         log_level: Optional[int] = None,
         service: "Optional[service_connection.ServiceConnection]" = None,
     ) -> None:
@@ -84,12 +82,7 @@ class Backend:
         self._save_mod_path: Optional[str] = None
         self._save_mod_spec = None
 
-    def _hack_set_run(self, run: "Run") -> None:
-        assert self.interface
-        self.interface._hack_set_run(run)
-
     def _multiprocessing_setup(self) -> None:
-        assert self._settings
         if self._settings.start_method == "thread":
             return
 
@@ -141,10 +134,13 @@ class Backend:
     def ensure_launched(self) -> None:
         """Launch backend worker if not running."""
         if self._service:
-            self.interface = self._service.make_interface(self._mailbox)
+            assert self._settings.run_id
+            self.interface = self._service.make_interface(
+                self._mailbox,
+                stream_id=self._settings.run_id,
+            )
             return
 
-        assert self._settings
         settings = self._settings.model_copy()
         settings.x_log_level = self._log_level or logging.DEBUG
 

wandb/sdk/data_types/base_types/wb_value.py

@@ -24,16 +24,16 @@ def _server_accepts_client_ids() -> bool:
     # The latest SDK version that is < "0.11.0" was released on 2021/06/29.
     # AS OF NOW, 2024/11/06, we assume that all customer's server deployments accept
     # client IDs.
-    #
-    # If there are any users with issues on an older backend, customers can disable the
-    # setting `allow_offline_artifacts` to revert the SDK's behavior back to not
-    # using client IDs in offline mode.
-    if (
-        util._is_offline()
-        and wandb.run
-        and not wandb.run.settings.allow_offline_artifacts
-    ):
-        return False
+
+    if util._is_offline():
+        # If there are any users with issues on an older backend, customers can disable the
+        # setting `allow_offline_artifacts` to revert the SDK's behavior back to not
+        # using client IDs in offline mode.
+        if wandb.run and not wandb.run.settings.allow_offline_artifacts:
+            return False
+        # Assume client IDs are accepted
+        else:
+            return True
 
     # If the script is online, request the max_cli_version and ensure the server
     # is of a high enough version.

wandb/sdk/data_types/helper_types/bounding_boxes_2d.py

@@ -48,7 +48,7 @@ class BoundingBoxes2D(JSONMetadata):
 
     Examples:
         ### Log bounding boxes for a single image
-        <!--yeadoc-test:boundingbox-2d-->
+
         ```python
         import numpy as np
         import wandb
@@ -94,7 +94,7 @@ class BoundingBoxes2D(JSONMetadata):
         ```
 
         ### Log a bounding box overlay to a Table
-        <!--yeadoc-test:bb2d-image-with-labels-->
+
         ```python
         import numpy as np
         import wandb

wandb/sdk/data_types/helper_types/image_mask.py

@@ -33,7 +33,7 @@ class ImageMask(Media):
 
     Examples:
         ### Logging a single masked image
-        <!--yeadoc-test:log-image-mask-->
+
         ```python
         import numpy as np
         import wandb
@@ -69,7 +69,7 @@ class ImageMask(Media):
         ```
 
         ### Log a masked image inside a Table
-        <!--yeadoc-test:log-image-mask-table-->
+
         ```python
         import numpy as np
         import wandb

wandb/sdk/data_types/image.py

@@ -77,7 +77,6 @@ class Image(BatchableMedia):
 
     Examples:
         ### Create a wandb.Image from a numpy array
-        <!--yeadoc-test:log-image-numpy-->
         ```python
         import numpy as np
         import wandb
@@ -92,7 +91,6 @@ class Image(BatchableMedia):
         ```
 
         ### Create a wandb.Image from a PILImage
-        <!--yeadoc-test:log-image-pillow-->
         ```python
         import numpy as np
         from PIL import Image as PILImage
@@ -111,7 +109,6 @@ class Image(BatchableMedia):
         ```
 
         ### log .jpg rather than .png (default)
-        <!--yeadoc-test:log-image-format-->
         ```python
         import numpy as np
         import wandb

wandb/sdk/data_types/saved_model.py

@@ -362,7 +362,7 @@ class _PytorchSavedModel(_PicklingSavedModel["torch.nn.Module"]):
 
     @staticmethod
     def _deserialize(dir_or_file_path: str) -> "torch.nn.Module":
-        return _get_torch().load(dir_or_file_path)
+        return _get_torch().load(dir_or_file_path, weights_only=False)
 
     @staticmethod
     def _validate_obj(obj: Any) -> bool:

wandb/sdk/data_types/utils.py

@@ -148,12 +148,8 @@ def val_to_json(
                 "partitioned-table",
                 "joined-table",
             ]:
-                # Special conditional to log tables as artifact entries as well.
-                # I suspect we will generalize this as we transition to storing all
-                # files in an artifact
-                # we sanitize the key to meet the constraints
-                # in this case, leaving only alphanumerics or underscores.
-                sanitized_key = re.sub(r"[^a-zA-Z0-9_]+", "", key)
+                # Sanitize the key to meet the constraints of artifact names.
+                sanitized_key = re.sub(r"[^a-zA-Z0-9_\-.]+", "", key)
                 art = wandb.Artifact(f"run-{run.id}-{sanitized_key}", "run_table")
                 art.add(val, key)
                 run.log_artifact(art)

wandb/sdk/interface/interface.py

@@ -90,16 +90,11 @@ def file_enum_to_policy(enum: "pb.FilesItem.PolicyType.V") -> "PolicyName":
 
 
 class InterfaceBase:
-    _run: Optional["Run"]
     _drop: bool
 
     def __init__(self) -> None:
-        self._run = None
         self._drop = False
 
-    def _hack_set_run(self, run: "Run") -> None:
-        self._run = run
-
     def publish_header(self) -> None:
         header = pb.HeaderRecord()
         self._publish_header(header)
@@ -232,7 +227,12 @@ class InterfaceBase:
             update.value_json = json.dumps(v)
         return summary
 
-    def _summary_encode(self, value: Any, path_from_root: str) -> dict:
+    def _summary_encode(
+        self,
+        value: Any,
+        path_from_root: str,
+        run: "Run",
+    ) -> dict:
         """Normalize, compress, and encode sub-objects for backend storage.
 
         value: Object to encode.
@@ -250,12 +250,14 @@ class InterfaceBase:
             json_value = {}
             for key, value in value.items():  # noqa: B020
                 json_value[key] = self._summary_encode(
-                    value, path_from_root + "." + key
+                    value,
+                    path_from_root + "." + key,
+                    run=run,
                 )
             return json_value
         else:
             friendly_value, converted = json_friendly(
-                val_to_json(self._run, path_from_root, value, namespace="summary")
+                val_to_json(run, path_from_root, value, namespace="summary")
             )
             json_value, compressed = maybe_compress_summary(
                 friendly_value, get_h5_typename(value)
@@ -267,7 +269,11 @@ class InterfaceBase:
 
             return json_value
 
-    def _make_summary(self, summary_record: sr.SummaryRecord) -> pb.SummaryRecord:
+    def _make_summary(
+        self,
+        summary_record: sr.SummaryRecord,
+        run: "Run",
+    ) -> pb.SummaryRecord:
         pb_summary_record = pb.SummaryRecord()
 
         for item in summary_record.update:
@@ -282,7 +288,11 @@ class InterfaceBase:
                 pb_summary_item.key = item.key[0]
 
             path_from_root = ".".join(item.key)
-            json_value = self._summary_encode(item.value, path_from_root)
+            json_value = self._summary_encode(
+                item.value,
+                path_from_root,
+                run=run,
+            )
             json_value, _ = json_friendly(json_value)  # type: ignore
 
             pb_summary_item.value_json = json.dumps(
@@ -303,8 +313,12 @@ class InterfaceBase:
 
         return pb_summary_record
 
-    def publish_summary(self, summary_record: sr.SummaryRecord) -> None:
-        pb_summary_record = self._make_summary(summary_record)
+    def publish_summary(
+        self,
+        run: "Run",
+        summary_record: sr.SummaryRecord,
+    ) -> None:
+        pb_summary_record = self._make_summary(summary_record, run=run)
         self._publish_summary(pb_summary_record)
 
     @abstractmethod

wandb/sdk/interface/interface_sock.py

@@ -16,32 +16,28 @@ from .router_sock import MessageSockRouter
 if TYPE_CHECKING:
     from wandb.proto import wandb_internal_pb2 as pb
 
-    from ..wandb_run import Run
-
 
 logger = logging.getLogger("wandb")
 
 
 class InterfaceSock(InterfaceShared):
-    _stream_id: Optional[str]
-    _sock_client: SockClient
     _mailbox: Mailbox
 
-    def __init__(self, sock_client: SockClient, mailbox: Mailbox) -> None:
+    def __init__(
+        self,
+        sock_client: SockClient,
+        mailbox: Mailbox,
+        stream_id: str,
+    ) -> None:
         # _sock_client is used when abstract method _init_router() is called by constructor
         self._sock_client = sock_client
         super().__init__(mailbox=mailbox)
         self._process_check = False
-        self._stream_id = None
+        self._stream_id = stream_id
 
     def _init_router(self) -> None:
         self._router = MessageSockRouter(self._sock_client, mailbox=self._mailbox)
 
-    def _hack_set_run(self, run: "Run") -> None:
-        super()._hack_set_run(run)
-        assert run._settings.run_id
-        self._stream_id = run._settings.run_id
-
     def _assign(self, record: Any) -> None:
         assert self._stream_id
         record._info.stream_id = self._stream_id

wandb/sdk/internal/internal_api.py

@@ -243,6 +243,7 @@ class Api:
         ),
         environ: MutableMapping = os.environ,
         retry_callback: Optional[Callable[[int, str], Any]] = None,
+        api_key: Optional[str] = None,
     ) -> None:
         self._environ = environ
         self._global_context = context.Context()
@@ -284,7 +285,9 @@ class Api:
         self._extra_http_headers.update(_thread_local_api_settings.headers or {})
 
         auth = None
-        if self.access_token is not None:
+        if api_key:
+            auth = ("api", api_key)
+        elif self.access_token is not None:
             self._extra_http_headers["Authorization"] = f"Bearer {self.access_token}"
         elif _thread_local_api_settings.cookies is None:
             auth = ("api", self.api_key or "")
@@ -400,6 +403,11 @@ class Api:
                 wandb.termerror(f"Error while calling W&B API: {error} ({response})")
             raise
 
+    def validate_api_key(self) -> bool:
+        """Returns whether the API key stored on initialization is valid."""
+        res = self.execute(gql("query { viewer { id } }"))
+        return res is not None and res["viewer"] is not None
+
     def set_current_run_id(self, run_id: str) -> None:
         self._current_run_id = run_id
 

wandb/sdk/internal/sender.py

@@ -52,9 +52,9 @@ from wandb.sdk.lib import (
     filesystem,
     proto_util,
     redirect,
+    retry,
     telemetry,
 )
-from wandb.sdk.lib.mailbox import ContextCancelledError
 from wandb.sdk.lib.proto_util import message_to_dict
 
 if TYPE_CHECKING:
@@ -388,7 +388,7 @@ class SendManager:
         try:
             self._api.set_local_context(api_context)
             send_handler(record)
-        except ContextCancelledError:
+        except retry.RetryCancelledError:
             logger.debug(f"Record cancelled: {record_type}")
             self._context_keeper.release(context_id)
         finally:

wandb/sdk/internal/system/assets/cpu.py

@@ -118,7 +118,7 @@ class CPU:
         self.name: str = self.__class__.__name__.lower()
         self.metrics: List[Metric] = [
             ProcessCpuPercent(settings.x_stats_pid),
-            CpuPercent(),
+            # CpuPercent(),
             ProcessCpuThreads(settings.x_stats_pid),
         ]
         self.metrics_monitor: MetricsMonitor = MetricsMonitor(

wandb/sdk/lib/apikey.py

@@ -104,7 +104,6 @@ def prompt_api_key(  # noqa: C901
         log_string = term.LOG_STRING_NOCOLOR
         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
 
     if anon_mode == "must":
@@ -123,24 +122,20 @@ def prompt_api_key(  # noqa: C901
             choices, input_timeout=settings.login_timeout, jupyter=jupyter
         )
 
+    key = None
     api_ask = (
-        f"{log_string}: Paste an API key from your profile and hit enter, "
-        "or press ctrl+c to quit"
+        f"{log_string}: Paste an API key from your profile and hit enter"
+        if jupyter
+        else f"{log_string}: Paste an API key from your profile and hit enter, or press ctrl+c to quit"
     )
     if result == LOGIN_CHOICE_ANON:
         key = api.create_anonymous_api_key()
-
-        write_key(settings, key, api=api, anonymous=True)
-        return key  # type: ignore
     elif result == LOGIN_CHOICE_NEW:
         key = browser_callback(signup=True) if browser_callback else None
 
         if not key:
             wandb.termlog(f"Create an account here: {app_url}/authorize?signup=true")
             key = input_callback(api_ask).strip()
-
-        write_key(settings, key, api=api)
-        return key  # type: ignore
     elif result == LOGIN_CHOICE_EXISTS:
         key = browser_callback() if browser_callback else None
 
@@ -158,8 +153,6 @@ def prompt_api_key(  # noqa: C901
                 f"You can find your API key in your browser here: {app_url}/authorize"
             )
             key = input_callback(api_ask).strip()
-        write_key(settings, key, api=api)
-        return key  # type: ignore
     elif result == LOGIN_CHOICE_NOTTY:
         # TODO: Needs refactor as this needs to be handled by caller
         return False
@@ -172,8 +165,9 @@ def prompt_api_key(  # noqa: C901
             browser_callback() if jupyter and browser_callback else (None, False)
         )
 
-        write_key(settings, key, api=api)
-        return key  # type: ignore
+    if not key:
+        raise ValueError("No API key specified.")
+    return key
 
 
 def write_netrc(host: str, entity: str, key: str) -> Optional[bool]:
@@ -232,7 +226,6 @@ def write_key(
     settings: "Settings",
     key: Optional[str],
     api: Optional["InternalApi"] = None,
-    anonymous: bool = False,
 ) -> None:
     if not key:
         raise ValueError("No API key specified.")
@@ -249,11 +242,6 @@ def write_key(
             "API key must be 40 characters long, yours was {}".format(len(key))
         )
 
-    if anonymous:
-        api.set_setting("anonymous", "must", globally=True, persist=True)
-    else:
-        api.clear_setting("anonymous", globally=True, persist=True)
-
     write_netrc(settings.base_url, "user", key)
 
 

wandb/sdk/lib/mailbox.py

@@ -24,10 +24,6 @@ class MailboxError(Error):
     """Generic Mailbox Exception."""
 
 
-class ContextCancelledError(MailboxError):
-    """Context cancelled Exception."""
-
-
 class _MailboxWaitAll:
     _event: threading.Event
     _lock: threading.Lock
@@ -341,16 +337,6 @@ class Mailbox:
     def enable_keepalive(self) -> None:
         self._keepalive = True
 
-    def wait(
-        self,
-        handle: MailboxHandle,
-        *,
-        timeout: float,
-        on_progress: Optional[Callable[[MailboxProgress], None]] = None,
-        cancel: bool = False,
-    ) -> Optional[pb.Result]:
-        return handle.wait(timeout=timeout, on_progress=on_progress, cancel=cancel)
-
     def _time(self) -> float:
         return time.monotonic()
 

wandb/sdk/lib/retry.py

@@ -12,10 +12,9 @@ from typing import Any, Awaitable, Callable, Generic, Optional, Tuple, Type, Typ
 from requests import HTTPError
 
 import wandb
+import wandb.errors
 from wandb.util import CheckRetryFnType
 
-from .mailbox import ContextCancelledError
-
 logger = logging.getLogger(__name__)
 
 
@@ -26,6 +25,10 @@ SLEEP_FN = time.sleep
 SLEEP_ASYNC_FN = asyncio.sleep
 
 
+class RetryCancelledError(wandb.errors.Error):
+    """A retry did not occur because it was cancelled."""
+
+
 class TransientError(Exception):
     """Exception type designated for errors that may only be temporary.
 
@@ -191,7 +194,7 @@ class Retry(Generic[_R]):
                 sleep + random.random() * 0.25 * sleep, cancel_event=retry_cancel_event
             )
             if cancelled:
-                raise ContextCancelledError("retry timeout")
+                raise RetryCancelledError("retry timeout")
             sleep *= 2
             if sleep > self.MAX_SLEEP_SECONDS:
                 sleep = self.MAX_SLEEP_SECONDS

wandb/sdk/lib/run_moment.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Literal, Union, cast
+from typing import Literal, cast
 from urllib import parse
 
 _STEP = Literal["_step"]
@@ -7,15 +9,25 @@ _STEP = Literal["_step"]
 
 @dataclass
 class RunMoment:
-    """A moment in a run."""
+    """A moment in a run.
+
+    Defines a branching point in a finished run to fork or resume from.
+    A run moment is identified by a run ID and a metric value.
+    Currently, only the metric '_step' is supported.
+    """
 
-    run: str  # run name
+    run: str
+    """run ID"""
 
-    # currently, the _step value to fork from. in future, this will be optional
-    value: Union[int, float]
+    value: int | float
+    """Value of the metric."""
 
-    # only step for now, in future this will be relaxed to be any metric
     metric: _STEP = "_step"
+    """Metric to use to determine the moment in the run.
+
+    Currently, only the metric '_step' is supported.
+    In future, this will be relaxed to be any metric.
+    """
 
     def __post_init__(self):
         if self.metric != "_step":
@@ -30,7 +42,7 @@ class RunMoment:
             raise ValueError(f"Only string run names are supported, got '{self.run}'.")
 
     @classmethod
-    def from_uri(cls, uri: str) -> "RunMoment":
+    def from_uri(cls, uri: str) -> RunMoment:
         parsable = "runmoment://" + uri
         parse_err = ValueError(
             f"Could not parse passed run moment string '{uri}', "

wandb/sdk/lib/server.py

@@ -25,6 +25,7 @@ class Server:
     def query_with_timeout(self, timeout: int | float = 5) -> None:
         if self._settings.x_disable_viewer:
             return
+
         async_viewer = util.async_call(self._api.viewer_server_info, timeout=timeout)
         try:
             viewer_tuple, viewer_thread = async_viewer()
@@ -36,3 +37,22 @@ class Server:
         # TODO(jhr): should we kill the thread?
         self._viewer, self._serverinfo = viewer_tuple
         self._flags = json.loads(self._viewer.get("flags", "{}"))
+
+    @property
+    def viewer(self) -> dict[str, Any]:
+        """Returns information about the currently authenticated user.
+
+        If the API key is valid, the following is returned:
+        - id
+        - entity
+        - username
+        - flags
+        - teams
+
+        If the API key is not valid or the server is not reachable,
+        an empty dict is returned.
+        """
+        if not self._viewer and not self._settings._offline:
+            self.query_with_timeout()
+
+        return self._viewer

wandb/sdk/lib/service_connection.py

@@ -124,9 +124,9 @@ class ServiceConnection:
         self._torn_down = False
         self._cleanup = cleanup
 
-    def make_interface(self, mailbox: Mailbox) -> InterfaceBase:
+    def make_interface(self, mailbox: Mailbox, stream_id: str) -> InterfaceBase:
         """Returns an interface for communicating with the service."""
-        return InterfaceSock(self._client, mailbox)
+        return InterfaceSock(self._client, mailbox, stream_id=stream_id)
 
     def send_record(self, record: pb.Record) -> None:
         """Sends data to the service."""