wandb 0.13.10__py3-none-any.whl → 0.14.0__py3-none-any.whl

wandb/sdk/data_types/helper_types/bounding_boxes_2d.py

@@ -57,51 +57,34 @@ class BoundingBoxes2D(JSONMetadata):
         wandb.init()
         image = np.random.randint(low=0, high=256, size=(200, 300, 3))
 
-        class_labels = {
-            0: "person",
-            1: "car",
-            2: "road",
-            3: "building"
-        }
-
-        img = wandb.Image(image, boxes={
-            "predictions": {
-                "box_data": [
-                    {
-                        # one box expressed in the default relative/fractional domain
-                        "position": {
-                            "minX": 0.1,
-                            "maxX": 0.2,
-                            "minY": 0.3,
-                            "maxY": 0.4
+        class_labels = {0: "person", 1: "car", 2: "road", 3: "building"}
+
+        img = wandb.Image(
+            image,
+            boxes={
+                "predictions": {
+                    "box_data": [
+                        {
+                            # one box expressed in the default relative/fractional domain
+                            "position": {"minX": 0.1, "maxX": 0.2, "minY": 0.3, "maxY": 0.4},
+                            "class_id": 1,
+                            "box_caption": class_labels[1],
+                            "scores": {"acc": 0.2, "loss": 1.2},
                         },
-                        "class_id" : 1,
-                        "box_caption": class_labels[1],
-                        "scores" : {
-                            "acc": 0.2,
-                            "loss": 1.2
-                        }
-                    },
-                    {
-                        # another box expressed in the pixel domain
-                        "position": {
-                            "middle": [150, 20],
-                            "width": 68,
-                            "height": 112
+                        {
+                            # another box expressed in the pixel domain
+                            "position": {"middle": [150, 20], "width": 68, "height": 112},
+                            "domain": "pixel",
+                            "class_id": 3,
+                            "box_caption": "a building",
+                            "scores": {"acc": 0.5, "loss": 0.7},
                         },
-                        "domain" : "pixel",
-                        "class_id" : 3,
-                        "box_caption": "a building",
-                        "scores" : {
-                            "acc": 0.5,
-                            "loss": 0.7
-                        }
-                    },
-                    # Log as many boxes an as needed
-                ],
-                "class_labels": class_labels
-            }
-        })
+                        # Log as many boxes an as needed
+                    ],
+                    "class_labels": class_labels,
+                }
+            },
+        )
 
         wandb.log({"driving_scene": img})
         ```
@@ -109,65 +92,50 @@ 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.init()
         image = np.random.randint(low=0, high=256, size=(200, 300, 3))
 
-        class_labels = {
-            0: "person",
-            1: "car",
-            2: "road",
-            3: "building"
-        }
-
-        class_set = wandb.Classes([
-            {"name" : "person", "id" : 0},
-            {"name" : "car", "id" : 1},
-            {"name" : "road", "id" : 2},
-            {"name" : "building", "id" : 3}
-        ])
-
-        img = wandb.Image(image, boxes={
-            "predictions": {
-                "box_data": [
-                    {
-                        # one box expressed in the default relative/fractional domain
-                        "position": {
-                            "minX": 0.1,
-                            "maxX": 0.2,
-                            "minY": 0.3,
-                            "maxY": 0.4
+        class_labels = {0: "person", 1: "car", 2: "road", 3: "building"}
+
+        class_set = wandb.Classes(
+            [
+                {"name": "person", "id": 0},
+                {"name": "car", "id": 1},
+                {"name": "road", "id": 2},
+                {"name": "building", "id": 3},
+            ]
+        )
+
+        img = wandb.Image(
+            image,
+            boxes={
+                "predictions": {
+                    "box_data": [
+                        {
+                            # one box expressed in the default relative/fractional domain
+                            "position": {"minX": 0.1, "maxX": 0.2, "minY": 0.3, "maxY": 0.4},
+                            "class_id": 1,
+                            "box_caption": class_labels[1],
+                            "scores": {"acc": 0.2, "loss": 1.2},
                         },
-                        "class_id" : 1,
-                        "box_caption": class_labels[1],
-                        "scores" : {
-                            "acc": 0.2,
-                            "loss": 1.2
-                        }
-                    },
-                    {
-                        # another box expressed in the pixel domain
-                        "position": {
-                            "middle": [150, 20],
-                            "width": 68,
-                            "height": 112
+                        {
+                            # another box expressed in the pixel domain
+                            "position": {"middle": [150, 20], "width": 68, "height": 112},
+                            "domain": "pixel",
+                            "class_id": 3,
+                            "box_caption": "a building",
+                            "scores": {"acc": 0.5, "loss": 0.7},
                         },
-                        "domain" : "pixel",
-                        "class_id" : 3,
-                        "box_caption": "a building",
-                        "scores" : {
-                            "acc": 0.5,
-                            "loss": 0.7
-                        }
-                    },
-                    # Log as many boxes an as needed
-                ],
-                "class_labels": class_labels
-            }
-        }, classes=class_set)
+                        # Log as many boxes an as needed
+                    ],
+                    "class_labels": class_labels,
+                }
+            },
+            classes=class_set,
+        )
 
         table = wandb.Table(columns=["image"])
         table.add_data(img)
@@ -180,36 +148,35 @@ class BoundingBoxes2D(JSONMetadata):
     # it here as _log_type, associate it in to_json
 
     def __init__(self, val: dict, key: str) -> None:
-        """
-        Arguments:
-            val: (dictionary) A dictionary of the following form:
-                box_data: (list of dictionaries) One dictionary for each bounding box, containing:
-                    position: (dictionary) the position and size of the bounding box, in one of two formats
-                        Note that boxes need not all use the same format.
-                        {"minX", "minY", "maxX", "maxY"}: (dictionary) A set of coordinates defining
-                            the upper and lower bounds of the box (the bottom left and top right corners)
-                        {"middle", "width", "height"}: (dictionary) A set of coordinates defining the
-                            center and dimensions of the box, with "middle" as a list [x, y] for the
-                            center point and "width" and "height" as numbers
-                    domain: (string) One of two options for the bounding box coordinate domain
-                        null: By default, or if no argument is passed, the coordinate domain
-                            is assumed to be relative to the original image, expressing this box as a fraction
-                            or percentage of the original image. This means all coordinates and dimensions
-                            passed into the "position" argument are floating point numbers between 0 and 1.
-                        "pixel": (string literal) The coordinate domain is set to the pixel space. This means all
-                            coordinates and dimensions passed into "position" are integers within the bounds
-                            of the image dimensions.
-                    class_id: (integer) The class label id for this box
-                    scores: (dictionary of string to number, optional) A mapping of named fields
-                            to numerical values (float or int), can be used for filtering boxes in the UI
-                            based on a range of values for the corresponding field
-                    box_caption: (string, optional) A string to be displayed as the label text above this
-                            box in the UI, often composed of the class label, class name, and/or scores
-
-                class_labels: (dictionary, optional) A map of integer class labels to their readable class names
-
-            key: (string)
-                The readable name or id for this set of bounding boxes (e.g. predictions, ground_truth)
+        """Initialize a BoundingBoxes object.
+
+        The input dictionary `val` should contain the keys:
+            box_data: a list of dictionaries, each of which describes a bounding box.
+            class_labels: (optional) A map of integer class labels to their readable
+                class names.
+
+        Each bounding box dictionary should contain the following keys:
+            position: (dictionary) the position and size of the bounding box.
+            domain: (string) One of two options for the bounding box coordinate domain.
+            class_id: (integer) The class label id for this box.
+            scores: (dictionary of string to number, optional) A mapping of named fields
+                to numerical values (float or int).
+            box_caption: (optional) The label text, often composed of the class label,
+                class name, and/or scores.
+
+        The position dictionary should be in one of two formats:
+            {"minX", "minY", "maxX", "maxY"}: (dictionary) A set of coordinates defining
+                the upper and lower bounds of the box (the bottom left and top right
+                corners).
+            {"middle", "width", "height"}: (dictionary) A set of coordinates defining
+                the center and dimensions of the box, with "middle" as a list [x, y] for
+                the center point and "width" and "height" as numbers.
+        Note that boxes need not all use the same format.
+
+        Args:
+            val: (dictionary) A dictionary containing the bounding box data.
+            key: (string) The readable name or id for this set of bounding boxes (e.g.
+                predictions, ground_truth)
         """
         super().__init__(val)
         self._val = val["box_data"]
@@ -308,7 +275,6 @@ class BoundingBoxes2D(JSONMetadata):
         return True
 
     def to_json(self, run_or_artifact: Union["LocalRun", "LocalArtifact"]) -> dict:
-
         if isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run):
             return super().to_json(run_or_artifact)
         elif isinstance(run_or_artifact, wandb.wandb_sdk.wandb_artifacts.Artifact):

wandb/sdk/data_types/helper_types/classes.py

@@ -17,7 +17,7 @@ class Classes(Media):
     _class_set: Sequence[dict]
 
     def __init__(self, class_set: Sequence[dict]) -> None:
-        """Classes is holds class metadata intended to be used in concert with other objects when visualizing artifacts
+        """Classes is holds class metadata intended to be used in concert with other objects when visualizing artifacts.
 
         Args:
             class_set (list): list of dicts in the form of {"id":int|str, "name":str}

wandb/sdk/data_types/helper_types/image_mask.py

@@ -116,19 +116,19 @@ class ImageMask(Media):
     _log_type = "mask"
 
     def __init__(self, val: dict, key: str) -> None:
-        """
+        """Initialize an ImageMask object.
+
         Arguments:
-            val: (dictionary)
-                One of these two keys to represent the image:
-                    mask_data : (2D numpy array) The mask containing an integer class label
-                        for each pixel in the image
-                    path : (string) The path to a saved image file of the mask
-                class_labels : (dictionary of integers to strings, optional) A mapping of the
-                    integer class labels in the mask to readable class names. These will default
-                    to class_0, class_1, class_2, etc.
-
-            key: (string)
-                The readable name or id for this mask type (e.g. predictions, ground_truth)
+            val: (dictionary) One of these two keys to represent the image:
+                mask_data : (2D numpy array) The mask containing an integer class label
+                    for each pixel in the image
+                path : (string) The path to a saved image file of the mask
+                class_labels : (dictionary of integers to strings, optional) A mapping
+                    of the integer class labels in the mask to readable class names.
+                    These will default to class_0, class_1, class_2, etc.
+
+        key: (string)
+            The readable name or id for this mask type (e.g. predictions, ground_truth)
         """
         super().__init__()
 

wandb/sdk/data_types/histogram.py

@@ -23,7 +23,7 @@ class Histogram(WBValue):
     Examples:
         Generate histogram from a sequence
         ```python
-        wandb.Histogram([1,2,3])
+        wandb.Histogram([1, 2, 3])
         ```
 
         Efficiently initialize from np.histogram.
@@ -52,7 +52,6 @@ class Histogram(WBValue):
         np_histogram: Optional["NumpyHistogram"] = None,
         num_bins: int = 64,
     ) -> None:
-
         if np_histogram:
             if len(np_histogram) == 2:
                 self.histogram = (
@@ -88,7 +87,9 @@ class Histogram(WBValue):
         return {"_type": self._log_type, "values": self.histogram, "bins": self.bins}
 
     def __sizeof__(self) -> int:
-        """This returns an estimated size in bytes, currently the factor of 1.7
-        is used to account for the JSON encoding.  We use this in tb_watcher.TBHistory
+        """Estimated size in bytes.
+
+        Currently the factor of 1.7 is used to account for the JSON encoding. We use
+        this in tb_watcher.TBHistory.
         """
         return int((sys.getsizeof(self.histogram) + sys.getsizeof(self.bins)) * 1.7)

wandb/sdk/data_types/html.py

@@ -17,8 +17,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Html(BatchableMedia):
-    """
-    Wandb class for arbitrary html
+    """Wandb class for arbitrary html.
 
     Arguments:
         data: (string or io object) HTML to display in wandb

wandb/sdk/data_types/image.py

@@ -34,13 +34,16 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 def _server_accepts_image_filenames() -> bool:
-    from pkg_resources import parse_version
+    if util._is_offline():
+        return True
 
     # Newer versions of wandb accept large image filenames arrays
     # but older versions would have issues with this.
     max_cli_version = util._get_max_cli_version()
     if max_cli_version is None:
         return False
+    from pkg_resources import parse_version
+
     accepts_image_filenames: bool = parse_version("0.12.10") <= parse_version(
         max_cli_version
     )
@@ -435,9 +438,7 @@ class Image(BatchableMedia):
         return json_dict
 
     def guess_mode(self, data: "np.ndarray") -> str:
-        """
-        Guess what type of image the np.array is representing
-        """
+        """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:
             return "L"
@@ -452,9 +453,10 @@ class Image(BatchableMedia):
 
     @classmethod
     def to_uint8(cls, data: "np.ndarray") -> "np.ndarray":
-        """
-        Converts floating point image on the range [0,1] and integer images
-        on the range [0,255] to uint8, clipping if necessary.
+        """Convert image data to uint8.
+
+        Convert floating point image on the range [0,1] and integer images on the range
+        [0,255] to uint8, clipping if necessary.
         """
         np = util.get_module(
             "numpy",
@@ -482,9 +484,7 @@ class Image(BatchableMedia):
         key: str,
         step: Union[int, str],
     ) -> dict:
-        """
-        Combines a list of images into a meta dictionary object describing the child images.
-        """
+        """Combine a list of images into a meta dictionary object describing the child images."""
         if TYPE_CHECKING:
             seq = cast(Sequence["Image"], seq)
 
@@ -528,7 +528,7 @@ class Image(BatchableMedia):
             ]
         else:
             wandb.termwarn(
-                "Unable to log image array filenames. In some cases, this can prevent images from being"
+                "Unable to log image array filenames. In some cases, this can prevent images from being "
                 "viewed in the UI. Please upgrade your wandb server",
                 repeat=False,
             )

wandb/sdk/data_types/molecule.py

@@ -21,8 +21,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Molecule(BatchableMedia):
-    """
-    Wandb class for 3D Molecular data
+    """Wandb class for 3D Molecular data.
 
     Arguments:
         data_or_path: (string, io)
@@ -103,8 +102,7 @@ class Molecule(BatchableMedia):
         convert_to_3d_and_optimize: bool = True,
         mmff_optimize_molecule_max_iterations: int = 200,
     ) -> "Molecule":
-        """
-        Convert RDKit-supported file/object types to wandb.Molecule
+        """Convert RDKit-supported file/object types to wandb.Molecule.
 
         Arguments:
             data_or_path: (string, rdkit.Chem.rdchem.Mol)
@@ -171,8 +169,7 @@ class Molecule(BatchableMedia):
         convert_to_3d_and_optimize: bool = True,
         mmff_optimize_molecule_max_iterations: int = 200,
     ) -> "Molecule":
-        """
-        Convert SMILES string to wandb.Molecule
+        """Convert SMILES string to wandb.Molecule.
 
         Arguments:
             data: (string)

wandb/sdk/data_types/object_3d.py

@@ -75,8 +75,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Object3D(BatchableMedia):
-    """
-    Wandb class for 3D point clouds.
+    """Wandb class for 3D point clouds.
 
     Arguments:
         data_or_path: (numpy array, string, io)

wandb/sdk/data_types/plotly.py

@@ -30,8 +30,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class Plotly(Media):
-    """
-    Wandb class for plotly plots.
+    """Wandb class for plotly plots.
 
     Arguments:
         val: matplotlib or plotly figure

wandb/sdk/data_types/saved_model.py

@@ -71,8 +71,7 @@ SavedModelObjType = TypeVar("SavedModelObjType")
 
 
 class _SavedModel(WBValue, Generic[SavedModelObjType]):
-    """SavedModel is a private data type that can be used to store a model object
-    inside of a W&B Artifact.
+    """Internal W&B Artifact model storage.
 
     _model_type_id: (str) The id of the SavedModel subclass used to serialize the model.
     """
@@ -184,7 +183,7 @@ class _SavedModel(WBValue, Generic[SavedModelObjType]):
         return json_obj
 
     def model_obj(self) -> SavedModelObjType:
-        """Returns the model object."""
+        """Return the model object."""
         if self._model_obj is None:
             assert self._path is not None, "Cannot load model object without path"
             self._set_obj(self._deserialize(self._path))
@@ -195,19 +194,22 @@ class _SavedModel(WBValue, Generic[SavedModelObjType]):
     # Methods to be implemented by subclasses
     @staticmethod
     def _deserialize(path: str) -> SavedModelObjType:
-        """Returns the model object from a path. Allowed to throw errors"""
+        """Return the model object from a path. Allowed to throw errors."""
         raise NotImplementedError
 
     @staticmethod
     def _validate_obj(obj: Any) -> bool:
-        """Validates the model object. Allowed to throw errors"""
+        """Validate the model object. Allowed to throw errors."""
         raise NotImplementedError
 
     @staticmethod
     def _serialize(obj: SavedModelObjType, dir_or_file_path: str) -> None:
-        """Save the model to disk. The method will receive a directory path which all
-        files needed for deserialization should be saved. A directory will always be passed if
-        _path_extension is an empty string, else a single file will be passed. Allowed to throw errors
+        """Save the model to disk.
+
+        The method will receive a directory path which all files needed for
+        deserialization should be saved. A directory will always be passed if
+        _path_extension is an empty string, else a single file will be passed. Allowed
+        to throw errors.
         """
         raise NotImplementedError
 

wandb/sdk/data_types/video.py

@@ -183,7 +183,7 @@ class Video(BatchableMedia):
         return json_dict
 
     def _prepare_video(self, video: "np.ndarray") -> "np.ndarray":
-        """This logic was mostly taken from tensorboardX"""
+        """This logic was mostly taken from tensorboardX."""
         np = util.get_module(
             "numpy",
             required='wandb.Video requires numpy when passing raw data. To get it, run "pip install numpy".',

wandb/sdk/integration_utils/data_logging.py

@@ -44,7 +44,7 @@ class ValidationDataLogger:
         class_labels: Optional[List[str]] = None,
         infer_missing_processors: bool = True,
     ) -> None:
-        """Initializes a new ValidationDataLogger.
+        """Initialize a new ValidationDataLogger.
 
         Args:
             inputs: A list of input vectors or dictionary of lists of input vectors
@@ -143,7 +143,7 @@ class ValidationDataLogger:
     def make_predictions(
         self, predict_fn: Callable
     ) -> Union[Sequence, Dict[str, Sequence]]:
-        """Produces predictions by passing `validation_inputs` to `predict_fn`.
+        """Produce predictions by passing `validation_inputs` to `predict_fn`.
 
         Args:
             predict_fn (Callable): Any function which can accept `validation_inputs` and produce
@@ -162,7 +162,7 @@ class ValidationDataLogger:
         table_name: str = "validation_predictions",
         commit: bool = True,
     ) -> wandb.data_types.Table:
-        """Logs a set of predictions.
+        """Log a set of predictions.
 
         Intended usage:
 
@@ -221,7 +221,7 @@ def _make_example(data: Any) -> Optional[Union[Dict, Sequence, Any]]:
 
 
 def _get_example_shape(example: Union[Sequence, Any]):
-    """Gets the shape of an object if applicable."""
+    """Get the shape of an object if applicable."""
     shape = []
     if type(example) is not str and hasattr(example, "__len__"):
         length = len(example)
@@ -232,7 +232,7 @@ def _get_example_shape(example: Union[Sequence, Any]):
 
 
 def _bind(lambda_fn: Callable, **closure_kwargs: Any) -> Callable:
-    """Creates a closure around a lambda function by binding `closure_kwargs` to the function."""
+    """Create a closure around a lambda function by binding `closure_kwargs` to the function."""
 
     def closure(*args: Any, **kwargs: Any) -> Any:
         _k = {}