wandb 0.19.8__py3-none-win32.whl → 0.19.10__py3-none-win32.whl

wandb/sdk/artifacts/artifact_saver.py

@@ -59,6 +59,8 @@ class ArtifactSaver:
 
     def save(
         self,
+        entity: str,
+        project: str,
         type: str,
         name: str,
         client_id: str,
@@ -76,6 +78,8 @@ class ArtifactSaver:
         base_id: str | None = None,
     ) -> dict | None:
         return self._save_internal(
+            entity,
+            project,
             type,
             name,
             client_id,
@@ -95,6 +99,8 @@ class ArtifactSaver:
 
     def _save_internal(
         self,
+        entity: str,
+        project: str,
         type: str,
         name: str,
         client_id: str,
@@ -140,7 +146,11 @@ class ArtifactSaver:
             base_id = latest["id"]
         if self._server_artifact["state"] == "COMMITTED":
             if use_after_commit:
-                self._api.use_artifact(artifact_id)
+                self._api.use_artifact(
+                    artifact_id,
+                    artifact_entity_name=entity,
+                    artifact_project_name=project,
+                )
             return self._server_artifact
         if (
             self._server_artifact["state"] != "PENDING"
@@ -244,7 +254,11 @@ class ArtifactSaver:
             step_prepare.shutdown()
 
         if finalize and use_after_commit:
-            self._api.use_artifact(artifact_id)
+            self._api.use_artifact(
+                artifact_id,
+                artifact_entity_name=entity,
+                artifact_project_name=project,
+            )
 
         return self._server_artifact
 

wandb/sdk/artifacts/storage_handlers/azure_handler.py

@@ -171,6 +171,7 @@ class AzureHandler(StorageHandler):
     def _get_credential(
         self, account_url: str
     ) -> azure.identity.DefaultAzureCredential | str:
+        # NOTE: Always returns default credential for reinit="create_new" runs.
         if (
             wandb.run
             and wandb.run.settings.azure_account_url_to_access_key is not None

wandb/sdk/artifacts/storage_policies/wandb_storage_policy.py

@@ -13,6 +13,7 @@ import requests
 import urllib3
 
 from wandb.errors.term import termwarn
+from wandb.proto.wandb_internal_pb2 import ServerFeature
 from wandb.sdk.artifacts.artifact_file_cache import (
     ArtifactFileCache,
     get_artifact_file_cache,
@@ -144,9 +145,14 @@ class WandbStoragePolicy(StoragePolicy):
                 http_headers["Authorization"] = f"Bearer {self._api.access_token}"
             elif _thread_local_api_settings.cookies is None:
                 auth = ("api", self._api.api_key or "")
-
             response = self._session.get(
-                self._file_url(self._api, artifact.entity, manifest_entry),
+                self._file_url(
+                    self._api,
+                    artifact.entity,
+                    artifact.project,
+                    artifact.name.split(":")[0],
+                    manifest_entry,
+                ),
                 auth=auth,
                 cookies=_thread_local_api_settings.cookies,
                 headers=http_headers,
@@ -187,6 +193,8 @@ class WandbStoragePolicy(StoragePolicy):
         self,
         api: InternalApi,
         entity_name: str,
+        project_name: str,
+        artifact_name: str,
         manifest_entry: ArtifactManifestEntry,
     ) -> str:
         storage_layout = self._config.get("storageLayout", StorageLayout.V1)
@@ -198,6 +206,19 @@ class WandbStoragePolicy(StoragePolicy):
                 api.settings("base_url"), entity_name, md5_hex
             )
         elif storage_layout == StorageLayout.V2:
+            if api._check_server_feature_with_fallback(
+                ServerFeature.ARTIFACT_COLLECTION_MEMBERSHIP_FILE_DOWNLOAD_HANDLER  # type: ignore
+            ):
+                return "{}/artifactsV2/{}/{}/{}/{}/{}/{}/{}".format(
+                    api.settings("base_url"),
+                    storage_region,
+                    quote(entity_name),
+                    quote(project_name),
+                    quote(artifact_name),
+                    quote(manifest_entry.birth_artifact_id or ""),
+                    md5_hex,
+                    manifest_entry.path.name,
+                )
             return "{}/artifactsV2/{}/{}/{}/{}".format(
                 api.settings("base_url"),
                 storage_region,

wandb/sdk/data_types/audio.py

@@ -25,10 +25,9 @@ class Audio(BatchableMedia):
 
     def __init__(self, data_or_path, sample_rate=None, caption=None):
         """Accept a path to an audio file or a numpy array of audio data."""
-        super().__init__()
+        super().__init__(caption=caption)
         self._duration = None
         self._sample_rate = sample_rate
-        self._caption = caption
 
         if isinstance(data_or_path, str):
             if self.path_is_reference(data_or_path):
@@ -80,7 +79,6 @@ class Audio(BatchableMedia):
         json_dict.update(
             {
                 "_type": self._log_type,
-                "caption": self._caption,
             }
         )
         return json_dict

wandb/sdk/data_types/base_types/media.py

@@ -3,11 +3,10 @@ import os
 import platform
 import re
 import shutil
-from typing import TYPE_CHECKING, Optional, Sequence, Type, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, Optional, Sequence, Type, Union, cast
 
 import wandb
 from wandb import util
-from wandb._globals import _datatypes_callback
 from wandb.sdk.lib import filesystem
 from wandb.sdk.lib.paths import LogicalPath
 
@@ -192,7 +191,7 @@ class Media(WBValue):
             shutil.move(self._path, new_path)
             self._path = new_path
             self._is_tmp = False
-            _datatypes_callback(media_path)
+            run._publish_file(media_path)
         else:
             try:
                 shutil.copy(self._path, new_path)
@@ -200,7 +199,7 @@ class Media(WBValue):
                 if not ignore_copy_err:
                     raise e
             self._path = new_path
-            _datatypes_callback(media_path)
+            run._publish_file(media_path)
 
     def to_json(self, run: Union["LocalRun", "Artifact"]) -> dict:
         """Serialize the object into a JSON blob.
@@ -222,7 +221,10 @@ class Media(WBValue):
         from wandb.data_types import Audio
         from wandb.sdk.wandb_run import Run
 
-        json_obj = {}
+        json_obj: Dict[str, Any] = {}
+
+        if self._caption is not None:
+            json_obj["caption"] = self._caption
 
         if isinstance(run, Run):
             json_obj.update(
@@ -232,6 +234,7 @@ class Media(WBValue):
                     "size": self._size,
                 }
             )
+
             artifact_entry_url = self._get_artifact_entry_ref_url()
             if artifact_entry_url is not None:
                 json_obj["artifact_path"] = artifact_entry_url
@@ -337,8 +340,11 @@ class BatchableMedia(Media):
     organize files by name in the media directory.
     """
 
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(
+        self,
+        caption: Optional[str] = None,
+    ) -> None:
+        super().__init__(caption=caption)
 
     @classmethod
     def seq_to_json(

wandb/sdk/data_types/base_types/wb_value.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Type, Union
 
-import wandb
 from wandb import util
+from wandb.sdk import wandb_setup
 
 if TYPE_CHECKING:  # pragma: no cover
     from wandb.sdk.artifacts.artifact import Artifact
@@ -11,6 +11,31 @@ if TYPE_CHECKING:  # pragma: no cover
     TypeMappingType = Dict[str, Type["WBValue"]]
 
 
+def _is_maybe_offline() -> bool:
+    """Guess whether wandb is configured to be offline.
+
+    This is an anti-pattern because there is no library-level "offline" mode:
+    only runs can be offline. Online and offline runs can exist in the same
+    process. This function is a heuristic that works only if there is at most
+    one run in the process, and could otherwise produce unexpected results.
+
+    Returns:
+        Whether the user likely configured wandb to be offline.
+    """
+    singleton = wandb_setup._setup(start_service=False)
+
+    # First check: if there's a run, check if it is offline.
+    #
+    # This covers uses like `wandb.init(mode="offline")` which don't modify
+    # the singleton's settings.
+    if run := singleton.most_recent_active_run:
+        return run.offline
+
+    # Second check: default to global defaults derived from environment
+    # variables or passed explicitly to `wandb.setup()`.
+    return singleton.settings._offline
+
+
 def _server_accepts_client_ids() -> bool:
     from wandb.util import parse_version
 
@@ -25,15 +50,13 @@ def _server_accepts_client_ids() -> bool:
     # AS OF NOW, 2024/11/06, we assume that all customer's server deployments accept
     # client IDs.
 
-    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
+    if _is_maybe_offline():
+        singleton = wandb_setup._setup(start_service=False)
+
+        if run := singleton.most_recent_active_run:
+            return run._settings.allow_offline_artifacts
         else:
-            return True
+            return singleton.settings.allow_offline_artifacts
 
     # If the script is online, request the max_cli_version and ensure the server
     # is of a high enough version.
@@ -240,7 +263,7 @@ class WBValue:
             self._artifact_target
             and self._artifact_target.name
             and self._artifact_target.artifact._is_draft_save_started()
-            and not util._is_offline()
+            and not _is_maybe_offline()
             and not _server_accepts_client_ids()
         ):
             self._artifact_target.artifact.wait()
@@ -271,7 +294,7 @@ class WBValue:
             self._artifact_target
             and self._artifact_target.name
             and self._artifact_target.artifact._is_draft_save_started()
-            and not util._is_offline()
+            and not _is_maybe_offline()
             and not _server_accepts_client_ids()
         ):
             self._artifact_target.artifact.wait()

wandb/sdk/data_types/html.py

@@ -16,19 +16,46 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Html(BatchableMedia):
-    """Wandb class for arbitrary html.
-
-    Args:
-        data: (string or io object) HTML to display in wandb
-        inject: (boolean) Add a stylesheet to the HTML object.  If set
-            to False the HTML will pass through unchanged.
-    """
+    """A class for logging HTML content to W&B."""
 
     _log_type = "html-file"
 
-    def __init__(self, data: Union[str, "TextIO"], inject: bool = True) -> None:
+    def __init__(
+        self,
+        data: Union[str, "TextIO"],
+        inject: bool = True,
+        data_is_not_path: bool = False,
+    ) -> None:
+        """Creates a W&B HTML object.
+
+        It can be initialized by providing a path to a file:
+        ```
+        with wandb.init() as run:
+            run.log({"html": wandb.Html("./index.html")})
+        ```
+
+        Alternatively, it can be initialized by providing literal HTML,
+        in either a string or IO object:
+        ```
+        with wandb.init() as run:
+            run.log({"html": wandb.Html("<h1>Hello, world!</h1>")})
+        ```
+
+        Args:
+            data:
+                A string that is a path to a file with the extension ".html",
+                or a string or IO object containing literal HTML.
+            inject: Add a stylesheet to the HTML object. If set
+                to False the HTML will pass through unchanged.
+            data_is_not_path: If set to False, the data will be
+                treated as a path to a file.
+        """
         super().__init__()
-        data_is_path = isinstance(data, str) and os.path.exists(data)
+        data_is_path = (
+            isinstance(data, str)
+            and os.path.isfile(data)
+            and os.path.splitext(data)[1] == ".html"
+        ) and not data_is_not_path
         data_path = ""
         if data_is_path:
             assert isinstance(data, str)

wandb/sdk/data_types/image.py

@@ -34,8 +34,8 @@ if TYPE_CHECKING:  # pragma: no cover
     TorchTensorType = Union["torch.Tensor", "torch.Variable"]
 
 
-def _server_accepts_image_filenames() -> bool:
-    if util._is_offline():
+def _server_accepts_image_filenames(run: "LocalRun") -> bool:
+    if run.offline:
         return True
 
     # Newer versions of wandb accept large image filenames arrays
@@ -51,15 +51,15 @@ def _server_accepts_image_filenames() -> bool:
     return accepts_image_filenames
 
 
-def _server_accepts_artifact_path() -> bool:
-    from wandb.util import parse_version
+def _server_accepts_artifact_path(run: "LocalRun") -> bool:
+    if run.offline:
+        return False
+
+    max_cli_version = util._get_max_cli_version()
+    if max_cli_version is None:
+        return False
 
-    target_version = "0.12.14"
-    max_cli_version = util._get_max_cli_version() if not util._is_offline() else None
-    accepts_artifact_path: bool = max_cli_version is not None and parse_version(
-        target_version
-    ) <= parse_version(max_cli_version)
-    return accepts_artifact_path
+    return util.parse_version("0.12.14") <= util.parse_version(max_cli_version)
 
 
 class Image(BatchableMedia):
@@ -152,12 +152,11 @@ class Image(BatchableMedia):
         masks: Optional[Union[Dict[str, "ImageMask"], Dict[str, dict]]] = None,
         file_type: Optional[str] = None,
     ) -> None:
-        super().__init__()
+        super().__init__(caption=caption)
         # TODO: We should remove grouping, it's a terrible name and I don't
         # think anyone uses it.
 
         self._grouping = None
-        self._caption = None
         self._width = None
         self._height = None
         self._image = None
@@ -193,9 +192,6 @@ class Image(BatchableMedia):
         if grouping is not None:
             self._grouping = grouping
 
-        if caption is not None:
-            self._caption = caption
-
         total_classes = {}
 
         if boxes:
@@ -297,10 +293,19 @@ class Image(BatchableMedia):
             "PIL.Image",
             required='wandb.Image needs the PIL package. To get it, run "pip install pillow".',
         )
+
+        accepted_formats = ["png", "jpg", "jpeg", "bmp"]
+        self.format = file_type or "png"
+
+        if self.format not in accepted_formats:
+            raise ValueError(f"file_type must be one of {accepted_formats}")
+
+        tmp_path = os.path.join(MEDIA_TMP.name, runid.generate_id() + "." + self.format)
+
         if util.is_matplotlib_typename(util.get_full_typename(data)):
             buf = BytesIO()
-            util.ensure_matplotlib_figure(data).savefig(buf, format="png")
-            self._image = pil_image.open(buf, formats=["PNG"])
+            util.ensure_matplotlib_figure(data).savefig(buf, format=self.format)
+            self._image = pil_image.open(buf)
         elif isinstance(data, pil_image.Image):
             self._image = data
         elif util.is_pytorch_tensor_typename(util.get_full_typename(data)):
@@ -312,26 +317,23 @@ class Image(BatchableMedia):
             if hasattr(data, "dtype") and str(data.dtype) == "torch.uint8":
                 data = data.to(float)
             data = vis_util.make_grid(data, normalize=True)
+            mode = mode or self.guess_mode(data, file_type)
             self._image = pil_image.fromarray(
-                data.mul(255).clamp(0, 255).byte().permute(1, 2, 0).cpu().numpy()
+                data.mul(255).clamp(0, 255).byte().permute(1, 2, 0).cpu().numpy(),
+                mode=mode,
             )
         else:
             if hasattr(data, "numpy"):  # TF data eager tensors
                 data = data.numpy()
             if data.ndim > 2:
                 data = data.squeeze()  # get rid of trivial dimensions as a convenience
+
+            mode = mode or self.guess_mode(data, file_type)
             self._image = pil_image.fromarray(
-                self.to_uint8(data), mode=mode or self.guess_mode(data)
+                self.to_uint8(data),
+                mode=mode,
             )
-        accepted_formats = ["png", "jpg", "jpeg", "bmp"]
-        if file_type is None:
-            self.format = "png"
-        else:
-            self.format = file_type
-        assert (
-            self.format in accepted_formats
-        ), f"file_type must be one of {accepted_formats}"
-        tmp_path = os.path.join(MEDIA_TMP.name, runid.generate_id() + "." + self.format)
+
         assert self._image is not None
         self._image.save(tmp_path, transparency=None)
         self._set_file(tmp_path, is_tmp=True)
@@ -399,7 +401,7 @@ class Image(BatchableMedia):
             )
 
         if (
-            not _server_accepts_artifact_path()
+            not _server_accepts_artifact_path(run)
             or self._get_artifact_entry_ref_url() is None
         ):
             super().bind_to_run(run, key, step, id_, ignore_copy_err=ignore_copy_err)
@@ -430,8 +432,6 @@ class Image(BatchableMedia):
             json_dict["height"] = self._height
         if self._grouping:
             json_dict["grouping"] = self._grouping
-        if self._caption:
-            json_dict["caption"] = self._caption
 
         if isinstance(run_or_artifact, wandb.Artifact):
             artifact = run_or_artifact
@@ -471,15 +471,34 @@ class Image(BatchableMedia):
             }
         return json_dict
 
-    def guess_mode(self, data: "np.ndarray") -> str:
+    def guess_mode(
+        self,
+        data: Union["np.ndarray", "torch.Tensor"],
+        file_type: Optional[str] = None,
+    ) -> str:
         """Guess what type of image the np.array is representing."""
         # TODO: do we want to support dimensions being at the beginning of the array?
-        if data.ndim == 2:
+        ndims = data.ndim
+        if util.is_pytorch_tensor_typename(util.get_full_typename(data)):
+            # Torch tenors typically have the channels dimension first
+            num_channels = data.shape[0]
+        else:
+            num_channels = data.shape[-1]
+
+        if ndims == 2:
             return "L"
-        elif data.shape[-1] == 3:
+        elif num_channels == 3:
             return "RGB"
-        elif data.shape[-1] == 4:
-            return "RGBA"
+        elif num_channels == 4:
+            if file_type in ["jpg", "jpeg"]:
+                wandb.termwarn(
+                    "JPEG format does not support transparency. "
+                    "Ignoring alpha channel.",
+                    repeat=False,
+                )
+                return "RGB"
+            else:
+                return "RGBA"
         else:
             raise ValueError(
                 "Un-supported shape for image conversion {}".format(list(data.shape))
@@ -556,7 +575,7 @@ class Image(BatchableMedia):
             "format": format,
             "count": num_images_to_log,
         }
-        if _server_accepts_image_filenames():
+        if _server_accepts_image_filenames(run):
             meta["filenames"] = [
                 obj.get("path", obj.get("artifact_path")) for obj in jsons
             ]

wandb/sdk/data_types/molecule.py

@@ -53,9 +53,7 @@ class Molecule(BatchableMedia):
         caption: Optional[str] = None,
         **kwargs: str,
     ) -> None:
-        super().__init__()
-
-        self._caption = caption
+        super().__init__(caption=caption)
 
         if hasattr(data_or_path, "name"):
             # if the file has a path, we just detect the type and copy it from there
@@ -208,8 +206,6 @@ class Molecule(BatchableMedia):
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
         json_dict = super().to_json(run_or_artifact)
         json_dict["_type"] = self._log_type
-        if self._caption:
-            json_dict["caption"] = self._caption
         return json_dict
 
     @classmethod

wandb/sdk/data_types/object_3d.py

@@ -215,9 +215,10 @@ class Object3D(BatchableMedia):
     def __init__(
         self,
         data_or_path: Union["np.ndarray", str, "TextIO", dict],
+        caption: Optional[str] = None,
         **kwargs: Optional[Union[str, "FileFormat3D"]],
     ) -> None:
-        super().__init__()
+        super().__init__(caption=caption)
 
         if hasattr(data_or_path, "name"):
             # if the file has a path, we just detect the type and copy it from there

wandb/sdk/data_types/saved_model.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import shutil
 import sys
+from types import ModuleType
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast
 
 import wandb
@@ -15,9 +16,6 @@ from ._private import MEDIA_TMP
 from .base_types.wb_value import WBValue
 
 if TYPE_CHECKING:
-    from types import ModuleType
-
-    import cloudpickle  # type: ignore
     import sklearn  # type: ignore
     import tensorflow  # type: ignore
     import torch  # type: ignore
@@ -264,9 +262,9 @@ class _SavedModel(WBValue, Generic[SavedModelObjType]):
         self._serialize(self._model_obj, target_path)
 
 
-def _get_cloudpickle() -> "cloudpickle":
+def _get_cloudpickle() -> ModuleType:
     return cast(
-        "cloudpickle",
+        ModuleType,
         util.get_module("cloudpickle", "ModelAdapter requires `cloudpickle`"),
     )
 
@@ -338,9 +336,9 @@ class _PicklingSavedModel(_SavedModel[SavedModelObjType]):
         return json_obj
 
 
-def _get_torch() -> "torch":
+def _get_torch() -> ModuleType:
     return cast(
-        "torch",
+        ModuleType,
         util.get_module("torch", "ModelAdapter requires `torch`"),
     )
 
@@ -366,9 +364,9 @@ class _PytorchSavedModel(_PicklingSavedModel["torch.nn.Module"]):
         )
 
 
-def _get_sklearn() -> "sklearn":
+def _get_sklearn() -> ModuleType:
     return cast(
-        "sklearn",
+        ModuleType,
         util.get_module("sklearn", "ModelAdapter requires `sklearn`"),
     )
 

wandb/sdk/data_types/table.py

@@ -480,6 +480,11 @@ class Table(Media):
             max_rows = Table.MAX_ROWS
         n_rows = len(self.data)
         if n_rows > max_rows and warn:
+            # NOTE: Never raises for reinit="create_new" runs.
+            #   Since this is called by bind_to_run(), this can be fixed by
+            #   propagating the run. It cannot be fixed for to_json() calls
+            #   that are given an artifact, other than by deferring to singleton
+            #   settings.
             if wandb.run and (
                 wandb.run.settings.table_raise_on_max_row_limit_exceeded
                 or wandb.run.settings.strict

wandb/sdk/data_types/trace_tree.py

@@ -431,6 +431,8 @@ class Trace:
             name: The name of the trace to be logged
         """
         trace_tree = WBTraceTree(self._span, self._model_dict)
+        # NOTE: Does not work for reinit="create_new" runs.
+        #   This method should be deprecated and users should call run.log().
         assert (
             wandb.run is not None
         ), "You must call wandb.init() before logging a trace"

wandb/sdk/data_types/utils.py

@@ -101,7 +101,7 @@ def val_to_json(
 
             items = _prune_max_seq(val)
 
-            if _server_accepts_image_filenames():
+            if _server_accepts_image_filenames(run):
                 for item in items:
                     item.bind_to_run(
                         run=run,