wandb 0.21.0__py3-none-win_amd64.whl → 0.21.1__py3-none-win_amd64.whl

wandb/sdk/data_types/image.py

@@ -28,8 +28,6 @@ if TYPE_CHECKING:  # pragma: no cover
 
     from wandb.sdk.artifacts.artifact import Artifact
 
-    from ..wandb_run import Run as LocalRun
-
     ImageDataType = Union[
         "matplotlib.artist.Artist", "PILImage", "TorchTensorType", "np.ndarray"
     ]
@@ -101,7 +99,7 @@ def _convert_to_uint8(data: "np.ndarray") -> "np.ndarray":
     return data.astype(np.uint8)
 
 
-def _server_accepts_image_filenames(run: "LocalRun") -> bool:
+def _server_accepts_image_filenames(run: "wandb.Run") -> bool:
     if run.offline:
         return True
 
@@ -117,7 +115,7 @@ def _server_accepts_image_filenames(run: "LocalRun") -> bool:
     return accepts_image_filenames
 
 
-def _server_accepts_artifact_path(run: "LocalRun") -> bool:
+def _server_accepts_artifact_path(run: "wandb.Run") -> bool:
     if run.offline:
         return False
 
@@ -161,19 +159,18 @@ class Image(BatchableMedia):
         file_type: Optional[str] = None,
         normalize: bool = True,
     ) -> None:
-        """Initialize a wandb.Image object.
+        """Initialize a `wandb.Image` object.
 
         Args:
-            data_or_path: Accepts numpy array/pytorch tensor of image data,
-                a PIL image object, or a path to an image file.
-
-                If a numpy array or pytorch tensor is provided,
+            data_or_path: Accepts NumPy array/pytorch tensor of image data,
+                a PIL image object, or a path to an image file. If a NumPy
+                array or pytorch tensor is provided,
                 the image data will be saved to the given file type.
                 If the values are not in the range [0, 255] or all values are in the range [0, 1],
                 the image pixel values will be normalized to the range [0, 255]
                 unless `normalize` is set to False.
-                - pytorch tensor should be in the format (channel, height, width)
-                - numpy array should be in the format (height, width, channel)
+            - pytorch tensor should be in the format (channel, height, width)
+            - NumPy array should be in the format (height, width, channel)
             mode: The PIL mode for an image. Most common are "L", "RGB",
                 "RGBA". Full explanation at https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes
             caption: Label for display of image.
@@ -190,53 +187,56 @@ class Image(BatchableMedia):
                 Normalize is only applied if data_or_path is a numpy array or pytorch tensor.
 
         Examples:
-            ### Create a wandb.Image from a numpy array
-            ```python
-            import numpy as np
-            import wandb
-
-            with wandb.init() as run:
-                examples = []
-                for i in range(3):
-                    pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
-                    image = wandb.Image(pixels, caption=f"random field {i}")
-                    examples.append(image)
-                run.log({"examples": examples})
-            ```
-
-            ### Create a wandb.Image from a PILImage
-            ```python
-            import numpy as np
-            from PIL import Image as PILImage
-            import wandb
-
-            with wandb.init() as run:
-                examples = []
-                for i in range(3):
-                    pixels = np.random.randint(
-                        low=0, high=256, size=(100, 100, 3), dtype=np.uint8
-                    )
-                    pil_image = PILImage.fromarray(pixels, mode="RGB")
-                    image = wandb.Image(pil_image, caption=f"random field {i}")
-                    examples.append(image)
-                run.log({"examples": examples})
-            ```
-
-            ### log .jpg rather than .png (default)
-            ```python
-            import numpy as np
-            import wandb
-
-            with wandb.init() as run:
-                examples = []
-                for i in range(3):
-                    pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
-                    image = wandb.Image(
-                        pixels, caption=f"random field {i}", file_type="jpg"
-                    )
-                    examples.append(image)
-                run.log({"examples": examples})
-            ```
+        Create a wandb.Image from a numpy array
+
+        ```python
+        import numpy as np
+        import wandb
+
+        with wandb.init() as run:
+            examples = []
+            for i in range(3):
+                pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
+                image = wandb.Image(pixels, caption=f"random field {i}")
+                examples.append(image)
+            run.log({"examples": examples})
+        ```
+
+        Create a wandb.Image from a PILImage
+
+        ```python
+        import numpy as np
+        from PIL import Image as PILImage
+        import wandb
+
+        with wandb.init() as run:
+            examples = []
+            for i in range(3):
+                pixels = np.random.randint(
+                    low=0, high=256, size=(100, 100, 3), dtype=np.uint8
+                )
+                pil_image = PILImage.fromarray(pixels, mode="RGB")
+                image = wandb.Image(pil_image, caption=f"random field {i}")
+                examples.append(image)
+            run.log({"examples": examples})
+        ```
+
+        Log .jpg rather than .png (default)
+
+        ```python
+        import numpy as np
+        import wandb
+
+        with wandb.init() as run:
+            examples = []
+            for i in range(3):
+                pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
+                image = wandb.Image(
+                    pixels, caption=f"random field {i}", file_type="jpg"
+                )
+                examples.append(image)
+            run.log({"examples": examples})
+        ```
         """
         super().__init__(caption=caption)
         # TODO: We should remove grouping, it's a terrible name and I don't
@@ -442,6 +442,10 @@ class Image(BatchableMedia):
     def from_json(
         cls: Type["Image"], json_obj: dict, source_artifact: "Artifact"
     ) -> "Image":
+        """Factory method to create an Audio object from a JSON object.
+
+        "<!-- lazydoc-ignore-classmethod: internal -->
+        """
         classes: Optional[Classes] = None
         if json_obj.get("classes") is not None:
             value = source_artifact.get(json_obj["classes"]["path"])
@@ -476,16 +480,24 @@ class Image(BatchableMedia):
 
     @classmethod
     def get_media_subdir(cls: Type["Image"]) -> str:
+        """Get media subdirectory.
+
+        "<!-- lazydoc-ignore-classmethod: internal -->
+        """
         return os.path.join("media", "images")
 
     def bind_to_run(
         self,
-        run: "LocalRun",
+        run: "wandb.Run",
         key: Union[int, str],
         step: Union[int, str],
         id_: Optional[Union[int, str]] = None,
         ignore_copy_err: Optional[bool] = None,
     ) -> None:
+        """Bind this object to a run.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         # For Images, we are going to avoid copying the image file to the run.
         # We should make this common functionality for all media types, but that
         # requires a broader UI refactor. This model can easily be moved to the
@@ -519,9 +531,11 @@ class Image(BatchableMedia):
                     run, key, step, id_, ignore_copy_err=ignore_copy_err
                 )
 
-    def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
-        from wandb.sdk.wandb_run import Run
+    def to_json(self, run_or_artifact: Union["wandb.Run", "Artifact"]) -> dict:
+        """Returns the JSON representation expected by the backend.
 
+        <!-- lazydoc-ignore: internal -->
+        """
         json_dict = super().to_json(run_or_artifact)
         json_dict["_type"] = Image._log_type
         json_dict["format"] = self.format
@@ -558,8 +572,8 @@ class Image(BatchableMedia):
                     "digest": classes_entry.digest,
                 }
 
-        elif not isinstance(run_or_artifact, Run):
-            raise TypeError("to_json accepts wandb_run.Run or wandb_artifact.Artifact")
+        elif not isinstance(run_or_artifact, wandb.Run):
+            raise TypeError("to_json accepts wandb.Run or wandb_artifact.Artifact")
 
         if self._boxes:
             json_dict["boxes"] = {
@@ -576,7 +590,10 @@ class Image(BatchableMedia):
         data: Union["np.ndarray", "torch.Tensor"],
         file_type: Optional[str] = None,
     ) -> str:
-        """Guess what type of image the np.array is representing."""
+        """Guess what type of image the np.array is representing.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         # TODO: do we want to support dimensions being at the beginning of the array?
         ndims = data.ndim
         if util.is_pytorch_tensor_typename(util.get_full_typename(data)):
@@ -608,11 +625,14 @@ class Image(BatchableMedia):
     def seq_to_json(
         cls: Type["Image"],
         seq: Sequence["BatchableMedia"],
-        run: "LocalRun",
+        run: "wandb.Run",
         key: str,
         step: Union[int, str],
     ) -> dict:
-        """Combine a list of images into a meta dictionary object describing the child images."""
+        """Convert a sequence of Image objects to a JSON representation.
+
+        "<!-- lazydoc-ignore-classmethod: internal -->
+        """
         if TYPE_CHECKING:
             seq = cast(Sequence["Image"], seq)
 
@@ -682,10 +702,14 @@ class Image(BatchableMedia):
     def all_masks(
         cls: Type["Image"],
         images: Sequence["Image"],
-        run: "LocalRun",
+        run: "wandb.Run",
         run_key: str,
         step: Union[int, str],
     ) -> Union[List[Optional[dict]], bool]:
+        """Collect all masks from a list of images.
+
+        "<!-- lazydoc-ignore-classmethod: internal -->
+        """
         all_mask_groups: List[Optional[dict]] = []
         for image in images:
             if image._masks:
@@ -705,10 +729,14 @@ class Image(BatchableMedia):
     def all_boxes(
         cls: Type["Image"],
         images: Sequence["Image"],
-        run: "LocalRun",
+        run: "wandb.Run",
         run_key: str,
         step: Union[int, str],
     ) -> Union[List[Optional[dict]], bool]:
+        """Collect all boxes from a list of images.
+
+        "<!-- lazydoc-ignore-classmethod: internal -->
+        """
         all_box_groups: List[Optional[dict]] = []
         for image in images:
             if image._boxes:
@@ -728,6 +756,10 @@ class Image(BatchableMedia):
     def all_captions(
         cls: Type["Image"], images: Sequence["Media"]
     ) -> Union[bool, Sequence[Optional[str]]]:
+        """Get captions from a list of images.
+
+        "<!-- lazydoc-ignore-classmethod: internal -->
+        """
         return cls.captions(images)
 
     def __ne__(self, other: object) -> bool:
@@ -758,6 +790,10 @@ class Image(BatchableMedia):
             )
 
     def to_data_array(self) -> List[Any]:
+        """Convert to data array.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         res = []
         if self.image is not None:
             data = list(self.image.getdata())

wandb/sdk/data_types/molecule.py

@@ -23,14 +23,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Molecule(BatchableMedia):
-    """Wandb class for 3D Molecular data.
-
-    Args:
-        data_or_path: (pathlib.Path, string, io)
-            Molecule can be initialized from a file name or an io object.
-        caption: (string)
-            Caption associated with the molecule for display.
-    """
+    """W&B class for 3D Molecular data."""
 
     SUPPORTED_TYPES = {
         "pdb",
@@ -53,6 +46,12 @@ class Molecule(BatchableMedia):
         caption: Optional[str] = None,
         **kwargs: str,
     ) -> None:
+        """Initialize a Molecule object.
+
+        Args:
+            data_or_path: Molecule can be initialized from a file name or an io object.
+            caption: Caption associated with the molecule for display.
+        """
         super().__init__(caption=caption)
 
         if hasattr(data_or_path, "name"):
@@ -116,6 +115,8 @@ class Molecule(BatchableMedia):
                 This is an expensive operation that may take a long time for complicated molecules.
             mmff_optimize_molecule_max_iterations: (int)
                 Number of iterations to use in rdkit.Chem.AllChem.MMFFOptimizeMolecule
+
+        <!-- lazydoc-ignore-classmethod: internal -->
         """
         rdkit_chem = util.get_module(
             "rdkit.Chem",
@@ -172,17 +173,17 @@ class Molecule(BatchableMedia):
         """Convert SMILES string to wandb.Molecule.
 
         Args:
-            data: (string)
-                SMILES string.
-            caption: (string)
-                Caption associated with the molecule for display
-            sanitize: (bool)
-                Check if the molecule is chemically reasonable by the RDKit's definition.
-            convert_to_3d_and_optimize: (bool)
-                Convert to rdkit.Chem.rdchem.Mol with 3D coordinates.
-                This is an expensive operation that may take a long time for complicated molecules.
-            mmff_optimize_molecule_max_iterations: (int)
-                Number of iterations to use in rdkit.Chem.AllChem.MMFFOptimizeMolecule
+            data: SMILES string.
+            caption: Caption associated with the molecule for display.
+            sanitize: Check if the molecule is chemically reasonable by
+                the RDKit's definition.
+            convert_to_3d_and_optimize: Convert to rdkit.Chem.rdchem.Mol
+                with 3D coordinates. This is a computationally intensive
+                operation that may take a long time for complicated molecules.
+            mmff_optimize_molecule_max_iterations: Number of iterations to
+                use in rdkit.Chem.AllChem.MMFFOptimizeMolecule.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
         """
         rdkit_chem = util.get_module(
             "rdkit.Chem",
@@ -201,9 +202,17 @@ class Molecule(BatchableMedia):
 
     @classmethod
     def get_media_subdir(cls: Type["Molecule"]) -> str:
+        """Get media subdirectory.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         return os.path.join("media", "molecule")
 
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        """Returns the JSON representation expected by the backend.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         json_dict = super().to_json(run_or_artifact)
         json_dict["_type"] = self._log_type
         return json_dict
@@ -216,6 +225,10 @@ class Molecule(BatchableMedia):
         key: str,
         step: Union[int, str],
     ) -> dict:
+        """Convert a sequence of Molecule objects to a JSON representation.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         seq = list(seq)
 
         jsons = [obj.to_json(run) for obj in seq]

wandb/sdk/data_types/object_3d.py

@@ -185,22 +185,7 @@ def box3d(
 
 
 class Object3D(BatchableMedia):
-    """Wandb class for 3D point clouds.
-
-    Args:
-        data_or_path: (numpy array, pathlib.Path, string, io)
-            Object3D can be initialized from a file or a numpy array.
-
-            You can pass a path to a file or an io object and a file_type
-            which must be one of SUPPORTED_TYPES
-
-    The shape of the numpy array must be one of either:
-    ```
-    [[x y z],       ...] nx3
-    [[x y z c],     ...] nx4 where c is a category with supported range [1, 14]
-    [[x y z r g b], ...] nx6 where is rgb is color
-    ```
-    """
+    """W&B class for 3D point clouds."""
 
     SUPPORTED_TYPES: ClassVar[Set[str]] = {
         "obj",
@@ -219,6 +204,21 @@ class Object3D(BatchableMedia):
         caption: Optional[str] = None,
         **kwargs: Optional[Union[str, "FileFormat3D"]],
     ) -> None:
+        """Creates a W&B Object3D object.
+
+        Args:
+            data_or_path: Object3D can be initialized from a file or a numpy array.
+            caption: Caption associated with the object for display.
+
+        Examples:
+        The shape of the numpy array must be one of either
+
+        ```text
+        [[x y z],       ...] nx3
+        [[x y z c],     ...] nx4 where c is a category with supported range [1, 14]
+        [[x y z r g b], ...] nx6 where is rgb is color
+        ```
+        """
         super().__init__(caption=caption)
 
         if hasattr(data_or_path, "name") and not isinstance(data_or_path, pathlib.Path):
@@ -347,6 +347,8 @@ class Object3D(BatchableMedia):
             data_or_path (Union["TextIO", str]): A path to a file or a `TextIO` stream.
             file_type (str): Specifies the data format passed to `data_or_path`. Required when `data_or_path` is a
                 `TextIO` stream. This parameter is ignored if a file path is provided. The type is taken from the file extension.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
         """
         # if file_type is not None and file_type not in cls.SUPPORTED_TYPES:
         #     raise ValueError(
@@ -364,11 +366,14 @@ class Object3D(BatchableMedia):
 
 
         The shape of the numpy array must be one of either:
-        ```
+
+        ```text
         [[x y z],       ...]  # nx3.
         [[x y z c],     ...]  # nx4 where c is a category with supported range [1, 14].
         [[x y z r g b], ...]  # nx6 where is rgb is color.
         ```
+
+        <!-- lazydoc-ignore-classmethod: internal -->
         """
         if not util.is_numpy_array(data):
             raise ValueError("`data` must be a numpy array")
@@ -403,6 +408,8 @@ class Object3D(BatchableMedia):
             vectors (Optional[Sequence["Vector3D"]]): Each vector is displayed in the point cloud
                 visualization. Can be used to indicate directionality of bounding boxes. Defaults to None.
             point_cloud_type ("lidar/beta"): At this time, only the "lidar/beta" type is supported. Defaults to "lidar/beta".
+
+        <!-- lazydoc-ignore-classmethod: internal -->
         """
         if point_cloud_type not in cls.SUPPORTED_POINT_CLOUD_TYPES:
             raise ValueError("Point cloud type not supported")
@@ -423,9 +430,17 @@ class Object3D(BatchableMedia):
 
     @classmethod
     def get_media_subdir(cls: Type["Object3D"]) -> str:
+        """Get media subdirectory.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         return os.path.join("media", "object3D")
 
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        """Returns the JSON representation expected by the backend.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         json_dict = super().to_json(run_or_artifact)
         json_dict["_type"] = Object3D._log_type
 
@@ -445,6 +460,10 @@ class Object3D(BatchableMedia):
         key: str,
         step: Union[int, str],
     ) -> dict:
+        """Convert a sequence of Audio objects to a JSON representation.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         seq = list(seq)
 
         jsons = [obj.to_json(run) for obj in seq]

wandb/sdk/data_types/plotly.py

@@ -31,11 +31,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Plotly(Media):
-    """Wandb class for plotly plots.
-
-    Args:
-        val: matplotlib or plotly figure
-    """
+    """W&B class for Plotly plots."""
 
     _log_type = "plotly-file"
 
@@ -43,6 +39,10 @@ class Plotly(Media):
     def make_plot_media(
         cls: Type["Plotly"], val: Union["plotly.Figure", "matplotlib.artist.Artist"]
     ) -> Union[Image, "Plotly"]:
+        """Create a Plotly object from a Plotly figure or a matplotlib artist.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         if util.is_matplotlib_typename(util.get_full_typename(val)):
             if util.matplotlib_contains_images(val):
                 return Image(val)
@@ -50,6 +50,11 @@ class Plotly(Media):
         return cls(val)
 
     def __init__(self, val: Union["plotly.Figure", "matplotlib.artist.Artist"]):
+        """Initialize a Plotly object.
+
+        Args:
+            val: Matplotlib or Plotly figure.
+        """
         super().__init__()
         # First, check to see if the incoming `val` object is a plotfly figure
         if not util.is_plotly_figure_typename(util.get_full_typename(val)):
@@ -74,9 +79,17 @@ class Plotly(Media):
 
     @classmethod
     def get_media_subdir(cls: Type["Plotly"]) -> str:
+        """Returns the media subdirectory for Plotly plots.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         return os.path.join("media", "plotly")
 
     def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        """Convert the Plotly object to a JSON representation.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         json_dict = super().to_json(run_or_artifact)
         json_dict["_type"] = self._log_type
         return json_dict

wandb/sdk/data_types/saved_model.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
     from wandb.sdk.artifacts.artifact import Artifact
-    from wandb.sdk.wandb_run import Run as LocalRun
 
 
 DEBUG_MODE = False
@@ -137,15 +136,14 @@ class _SavedModel(WBValue, Generic[SavedModelObjType]):
         # and specified adapter.
         return cls(dl_path)
 
-    def to_json(self, run_or_artifact: LocalRun | Artifact) -> dict:
+    def to_json(self, run_or_artifact: wandb.Run | Artifact) -> dict:
         # Unlike other data types, we do not allow adding to a Run directly. There is a
         # 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.
-        from wandb.sdk.wandb_run import Run
-
-        if isinstance(run_or_artifact, Run):
+        if isinstance(run_or_artifact, wandb.Run):
             raise TypeError("SavedModel cannot be added to run - must use artifact")
+
         artifact = run_or_artifact
         json_obj = {
             "type": self._log_type,
@@ -329,7 +327,7 @@ class _PicklingSavedModel(_SavedModel[SavedModelObjType]):
 
         return inst  # type: ignore
 
-    def to_json(self, run_or_artifact: LocalRun | Artifact) -> dict:
+    def to_json(self, run_or_artifact: wandb.Run | Artifact) -> dict:
         json_obj = super().to_json(run_or_artifact)
         assert isinstance(run_or_artifact, wandb.Artifact)
         if self._dep_py_files_path is not None: