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

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:

wandb/sdk/data_types/table.py

@@ -203,7 +203,7 @@ class Table(Media):
     This means you can embed `Images`, `Video`, `Audio`, and other sorts of rich, annotated media
     directly in Tables, alongside other traditional scalar values.
 
-    This class is the primary class used to generate the W&B Tables
+    This class is the primary class used to generate W&B Tables
     https://docs.wandb.ai/guides/models/tables/.
     """
 
@@ -236,6 +236,7 @@ class Table(Media):
             data: (List[List[any]]) 2D row-oriented array of values.
             dataframe: (pandas.DataFrame) DataFrame object used to create the table.
                 When set, `data` and `columns` arguments are ignored.
+            rows: (List[List[any]]) 2D row-oriented array of values.
             optional: (Union[bool,List[bool]]) Determines if `None` values are allowed. Default to True
                 - If a singular bool value, then the optionality is enforced for all
                 columns specified at construction time
@@ -410,13 +411,15 @@ class Table(Media):
     def cast(self, col_name, dtype, optional=False):
         """Casts a column to a specific data type.
 
-        This can be one of the normal python classes, an internal W&B type, or an
-        example object, like an instance of wandb.Image or wandb.Classes.
+        This can be one of the normal python classes, an internal W&B type,
+        or an example object, like an instance of wandb.Image or
+        wandb.Classes.
 
         Args:
-            col_name: (str) - The name of the column to cast.
-            dtype: (class, wandb.wandb_sdk.interface._dtypes.Type, any) - The target dtype.
-            optional: (bool) - If the column should allow Nones.
+            col_name (str): The name of the column to cast.
+            dtype (class, wandb.wandb_sdk.interface._dtypes.Type, any): The
+                target dtype.
+            optional (bool): If the column should allow Nones.
         """
         assert col_name in self.columns
 
@@ -499,14 +502,17 @@ class Table(Media):
 
     @allow_relogging_after_mutation
     def add_row(self, *row):
-        """Deprecated; use add_data instead."""
+        """Deprecated. Use `Table.add_data` method instead."""
         logging.warning("add_row is deprecated, use add_data")
         self.add_data(*row)
 
     @allow_relogging_after_mutation
     @allow_incremental_logging_after_append
     def add_data(self, *data):
-        """Adds a new row of data to the table. The maximum amount of rows in a table is determined by `wandb.Table.MAX_ARTIFACT_ROWS`.
+        """Adds a new row of data to the table.
+
+        The maximum amount ofrows in a table is determined by
+        `wandb.Table.MAX_ARTIFACT_ROWS`.
 
         The length of the data should match the length of the table column.
         """
@@ -589,6 +595,10 @@ class Table(Media):
             return {"columns": self.columns, "data": self.data[:max_rows]}
 
     def bind_to_run(self, *args, **kwargs):
+        """Bind this object to a run.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         # We set `warn=False` since Tables will now always be logged to both
         # files and artifacts. The file limit will never practically matter and
         # this code path will be ultimately removed. The 10k limit warning confuses
@@ -603,10 +613,18 @@ class Table(Media):
 
     @classmethod
     def get_media_subdir(cls):
+        """Get media subdirectory.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         return os.path.join("media", "table")
 
     @classmethod
     def from_json(cls, json_obj, source_artifact: "artifact.Artifact"):
+        """Deserialize JSON object into it's class representation.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         data = []
         column_types = None
         np_deserialized_columns = {}
@@ -690,6 +708,10 @@ class Table(Media):
         return new_obj
 
     def to_json(self, run_or_artifact):
+        """Returns the JSON representation expected by the backend.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         json_dict = super().to_json(run_or_artifact)
 
         if self.log_mode == "INCREMENTAL":
@@ -705,7 +727,7 @@ class Table(Media):
                 }
             )
 
-        if isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run):
+        if isinstance(run_or_artifact, wandb.Run):
             if self.log_mode == "INCREMENTAL":
                 wbvalue_type = "incremental-table-file"
             else:
@@ -799,11 +821,11 @@ class Table(Media):
 
         Yields:
         ------
-        index : int
-            The index of the row. Using this value in other W&B tables
+        index: The index of the row. Using this value in other W&B tables
             will automatically build a relationship between the tables
-        row : List[any]
-            The data of the row.
+        row: The data of the row.
+
+        <!-- lazydoc-ignore: internal -->
         """
         for ndx in range(len(self.data)):
             index = _TableIndex(ndx)
@@ -812,12 +834,20 @@ class Table(Media):
 
     @allow_relogging_after_mutation
     def set_pk(self, col_name):
+        """Set primary key type for Table object.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         # TODO: Docs
         assert col_name in self.columns
         self.cast(col_name, _PrimaryKeyType())
 
     @allow_relogging_after_mutation
     def set_fk(self, col_name, table, table_col):
+        """Set foreign key type for Table object.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         # TODO: Docs
         assert col_name in self.columns
         assert col_name != self._pk_col
@@ -1003,7 +1033,10 @@ class Table(Media):
         return pd.DataFrame.from_records(self.data, columns=self.columns)
 
     def index_ref(self, index):
-        """Gets a reference of the index of a row in the table."""
+        """Gets a reference of the index of a row in the table.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         assert index < len(self.data)
         _index = _TableIndex(index)
         _index.set_table(self)
@@ -1015,14 +1048,12 @@ class Table(Media):
         """Adds one or more computed columns based on existing data.
 
         Args:
-            fn: A function which accepts one or two parameters, ndx (int) and row (dict),
-                which is expected to return a dict representing new columns for that row, keyed
-                by the new column names.
-
-                `ndx` is an integer representing the index of the row. Only included if `include_ndx`
+            fn: A function which accepts one or two parameters, ndx (int) and
+                row (dict), which is expected to return a dict representing
+                new columns for that row, keyed by the new column names.
+            - `ndx` is an integer representing the index of the row. Only included if `include_ndx`
                       is set to `True`.
-
-                `row` is a dictionary keyed by existing columns
+            - `row` is a dictionary keyed by existing columns
         """
         new_columns = {}
         for ndx, row in self.iterrows():
@@ -1056,7 +1087,8 @@ class _PartitionTablePartEntry:
 class PartitionedTable(Media):
     """A table which is composed of multiple sub-tables.
 
-    Currently, PartitionedTable is designed to point to a directory within an artifact.
+    Currently, PartitionedTable is designed to point to a directory within an
+    artifact.
     """
 
     _log_type = "partitioned-table"
@@ -1075,7 +1107,7 @@ class PartitionedTable(Media):
         json_obj = {
             "_type": PartitionedTable._log_type,
         }
-        if isinstance(artifact_or_run, wandb.wandb_sdk.wandb_run.Run):
+        if isinstance(artifact_or_run, wandb.Run):
             artifact_entry_url = self._get_artifact_entry_ref_url()
             if artifact_entry_url is None:
                 raise ValueError(
@@ -1099,12 +1131,9 @@ class PartitionedTable(Media):
     def iterrows(self):
         """Iterate over rows as (ndx, row).
 
-        Yields:
-        ------
-        index : int
-            The index of the row.
-        row : List[any]
-            The data of the row.
+        Args:
+            index (int): The index of the row.
+            row (List[any]): The data of the row.
         """
         columns = None
         ndx = 0
@@ -1233,7 +1262,7 @@ class JoinedTable(Media):
         json_obj = {
             "_type": JoinedTable._log_type,
         }
-        if isinstance(artifact_or_run, wandb.wandb_sdk.wandb_run.Run):
+        if isinstance(artifact_or_run, wandb.Run):
             artifact_entry_url = self._get_artifact_entry_ref_url()
             if artifact_entry_url is None:
                 raise ValueError(

wandb/sdk/data_types/video.py

@@ -6,7 +6,8 @@ from io import BytesIO
 from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, Type, Union
 
 import wandb
-from wandb import util
+from wandb import env, util
+from wandb.sdk import wandb_setup
 from wandb.sdk.lib import filesystem, printer, printer_asyncio, runid
 
 from . import _dtypes
@@ -23,6 +24,14 @@ if TYPE_CHECKING:  # pragma: no cover
     from ..wandb_run import Run as LocalRun
 
 
+def _should_print_spinner() -> bool:
+    settings = wandb_setup.singleton().settings_if_loaded
+    if settings and (settings.quiet or settings.silent):
+        return False
+
+    return not env.is_quiet() and not env.is_silent()
+
+
 # This helper function is a workaround for the issue discussed here:
 # https://github.com/wandb/wandb/issues/3472
 #
@@ -80,40 +89,38 @@ class Video(BatchableMedia):
         """Initialize a W&B Video object.
 
         Args:
-            data_or_path:
-                Video can be initialized with a path to a file or an io object.
-                Video can be initialized with a numpy tensor.
-                The numpy tensor must be either 4 dimensional or 5 dimensional.
+            data_or_path: Video can be initialized with a path to a file or an io object.
+                Video can be initialized with a numpy tensor. The numpy tensor
+                must be either 4 dimensional or 5 dimensional.
                 The dimensions should be (number of frames, channel, height, width) or
                 (batch, number of frames, channel, height, width)
                 The format parameter must be specified with the format argument
                 when initializing with a numpy array
                 or io object.
             caption: Caption associated with the video for display.
-            fps:
-                The frame rate to use when encoding raw video frames.
+            fps: The frame rate to use when encoding raw video frames.
                 Default value is 4.
                 This parameter has no effect when data_or_path is a string, or bytes.
-            format:
-                Format of video, necessary if initializing with a numpy array
+            format: Format of video, necessary if initializing with a numpy array
                 or io object. This parameter will be used to determine the format
                 to use when encoding the video data. Accepted values are "gif",
                 "mp4", "webm", or "ogg".
                 If no value is provided, the default format will be "gif".
 
         Examples:
-            ### Log a numpy array as a video
-            ```python
-            import numpy as np
-            import wandb
-
-            with wandb.init() as run:
-                # axes are (number of frames, channel, height, width)
-                frames = np.random.randint(
-                    low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8
-                )
-                run.log({"video": wandb.Video(frames, format="mp4", fps=4)})
-            ```
+        Log a numpy array as a video
+
+        ```python
+        import numpy as np
+        import wandb
+
+        with wandb.init() as run:
+            # axes are (number of frames, channel, height, width)
+            frames = np.random.randint(
+                low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8
+            )
+            run.log({"video": wandb.Video(frames, format="mp4", fps=4)})
+        ```
         """
         super().__init__(caption=caption)
 
@@ -167,13 +174,21 @@ class Video(BatchableMedia):
                     "wandb.Video accepts a file path or numpy like data as input"
                 )
             fps = fps or 4
-            printer_asyncio.run_async_with_spinner(
-                printer.new_printer(),
-                "Encoding video...",
-                functools.partial(self.encode, fps=fps),
-            )
+
+            if _should_print_spinner():
+                printer_asyncio.run_async_with_spinner(
+                    printer.new_printer(),
+                    "Encoding video...",
+                    functools.partial(self.encode, fps=fps),
+                )
+            else:
+                self.encode(fps=fps)
 
     def encode(self, fps: int = 4) -> None:
+        """Encode the video data to a file.
+
+        <!-- lazydoc-ignore: internal -->
+        """
         # import ImageSequenceClip from the appropriate MoviePy module
         mpy = util.get_module(
             "moviepy.video.io.ImageSequenceClip",
@@ -199,9 +214,17 @@ class Video(BatchableMedia):
 
     @classmethod
     def get_media_subdir(cls: Type["Video"]) -> str:
+        """Get media subdirectory for video files.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         return os.path.join("media", "videos")
 
     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
 
@@ -256,6 +279,10 @@ class Video(BatchableMedia):
         key: str,
         step: Union[int, str],
     ) -> dict:
+        """Convert a sequence of Video objects to a JSON representation.
+
+        <!-- lazydoc-ignore-classmethod: internal -->
+        """
         base_path = os.path.join(run.dir, cls.get_media_subdir())
         filesystem.mkdir_exists_ok(base_path)
 

wandb/sdk/integration_utils/auto_logging.py

@@ -71,7 +71,7 @@ class PatchAPI:
             )
         return self._api
 
-    def patch(self, run: "wandb.sdk.wandb_run.Run") -> None:
+    def patch(self, run: "wandb.Run") -> None:
         """Patches the API to log media or metrics to W&B."""
         for symbol in self.symbols:
             # split on dots, e.g. "Client.generate" -> ["Client", "generate"]
@@ -163,7 +163,7 @@ class AutologAPI:
             resolver=resolver,
         )
         self._name = self._patch_api.name
-        self._run: Optional[wandb.sdk.wandb_run.Run] = None
+        self._run: Optional[wandb.Run] = None
         self.__run_created_by_autolog: bool = False
 
     @property

wandb/sdk/interface/interface_queue.py

@@ -8,8 +8,6 @@ import logging
 from multiprocessing.process import BaseProcess
 from typing import TYPE_CHECKING, Optional
 
-from wandb.sdk.mailbox import Mailbox
-
 from .interface_shared import InterfaceShared
 
 if TYPE_CHECKING:
@@ -27,12 +25,11 @@ class InterfaceQueue(InterfaceShared):
         record_q: Optional["Queue[pb.Record]"] = None,
         result_q: Optional["Queue[pb.Result]"] = None,
         process: Optional[BaseProcess] = None,
-        mailbox: Optional[Mailbox] = None,
     ) -> None:
         self.record_q = record_q
         self.result_q = result_q
         self._process = process
-        super().__init__(mailbox=mailbox)
+        super().__init__()
 
     def _publish(self, record: "pb.Record", local: Optional[bool] = None) -> None:
         if self._process and not self._process.is_alive():

wandb/sdk/interface/interface_shared.py

@@ -10,7 +10,7 @@ from typing import Any, Optional, cast
 
 from wandb.proto import wandb_internal_pb2 as pb
 from wandb.proto import wandb_telemetry_pb2 as tpb
-from wandb.sdk.mailbox import Mailbox, MailboxHandle
+from wandb.sdk.mailbox import MailboxHandle
 from wandb.util import json_dumps_safer, json_friendly
 
 from .interface import InterfaceBase
@@ -19,9 +19,8 @@ logger = logging.getLogger("wandb")
 
 
 class InterfaceShared(InterfaceBase):
-    def __init__(self, mailbox: Optional[Mailbox] = None) -> None:
+    def __init__(self) -> None:
         super().__init__()
-        self._mailbox = mailbox
 
     def _publish_output(self, outdata: pb.OutputRecord) -> None:
         rec = pb.Record()
@@ -67,7 +66,7 @@ class InterfaceShared(InterfaceBase):
         self, job_input: pb.JobInputRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(job_input=job_input)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _make_stats(self, stats_dict: dict) -> pb.StatsRecord:
         stats = pb.StatsRecord()
@@ -263,6 +262,9 @@ class InterfaceShared(InterfaceBase):
     def _publish(self, record: pb.Record, local: Optional[bool] = None) -> None:
         raise NotImplementedError
 
+    def _deliver(self, record: pb.Record) -> "MailboxHandle[pb.Result]":
+        raise NotImplementedError
+
     def _publish_defer(self, state: "pb.DeferRequest.DeferState.V") -> None:
         defer = pb.DeferRequest(state=state)
         rec = self._make_request(defer=defer)
@@ -333,19 +335,19 @@ class InterfaceShared(InterfaceBase):
         log_artifact: pb.LogArtifactRequest,
     ) -> MailboxHandle[pb.Result]:
         rec = self._make_request(log_artifact=log_artifact)
-        return self._deliver_record(rec)
+        return self._deliver(rec)
 
     def _deliver_download_artifact(
         self, download_artifact: pb.DownloadArtifactRequest
     ) -> MailboxHandle[pb.Result]:
         rec = self._make_request(download_artifact=download_artifact)
-        return self._deliver_record(rec)
+        return self._deliver(rec)
 
     def _deliver_link_artifact(
         self, link_artifact: pb.LinkArtifactRequest
     ) -> MailboxHandle[pb.Result]:
         rec = self._make_request(link_artifact=link_artifact)
-        return self._deliver_record(rec)
+        return self._deliver(rec)
 
     def _publish_artifact(self, proto_artifact: pb.ArtifactRecord) -> None:
         rec = self._make_record(artifact=proto_artifact)
@@ -360,7 +362,7 @@ class InterfaceShared(InterfaceBase):
         status: pb.StatusRequest,
     ) -> MailboxHandle[pb.Result]:
         req = self._make_request(status=status)
-        return self._deliver_record(req)
+        return self._deliver(req)
 
     def _publish_exit(self, exit_data: pb.RunExitRecord) -> None:
         rec = self._make_record(exit=exit_data)
@@ -373,110 +375,97 @@ class InterfaceShared(InterfaceBase):
     def _deliver_shutdown(self) -> MailboxHandle[pb.Result]:
         request = pb.Request(shutdown=pb.ShutdownRequest())
         record = self._make_record(request=request)
-        return self._deliver_record(record)
-
-    def _get_mailbox(self) -> Mailbox:
-        mailbox = self._mailbox
-        assert mailbox
-        return mailbox
-
-    def _deliver_record(self, record: pb.Record) -> MailboxHandle[pb.Result]:
-        mailbox = self._get_mailbox()
-
-        handle = mailbox.require_response(record)
-        self._publish(record)
-
-        return handle.map(lambda resp: resp.result_communicate)
+        return self._deliver(record)
 
     def _deliver_run(self, run: pb.RunRecord) -> MailboxHandle[pb.Result]:
         record = self._make_record(run=run)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_finish_sync(
         self,
         sync_finish: pb.SyncFinishRequest,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(sync_finish=sync_finish)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_run_start(
         self,
         run_start: pb.RunStartRequest,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(run_start=run_start)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_get_summary(
         self,
         get_summary: pb.GetSummaryRequest,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(get_summary=get_summary)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_get_system_metrics(
         self, get_system_metrics: pb.GetSystemMetricsRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(get_system_metrics=get_system_metrics)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_exit(
         self,
         exit_data: pb.RunExitRecord,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_record(exit=exit_data)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def deliver_operation_stats(self):
         record = self._make_request(operation_stats=pb.OperationStatsRequest())
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_poll_exit(
         self,
         poll_exit: pb.PollExitRequest,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(poll_exit=poll_exit)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_finish_without_exit(
         self, run_finish_without_exit: pb.RunFinishWithoutExitRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(run_finish_without_exit=run_finish_without_exit)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_stop_status(
         self,
         stop_status: pb.StopStatusRequest,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(stop_status=stop_status)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_attach(
         self,
         attach: pb.AttachRequest,
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(attach=attach)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_network_status(
         self, network_status: pb.NetworkStatusRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(network_status=network_status)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_internal_messages(
         self, internal_message: pb.InternalMessagesRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(internal_messages=internal_message)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_request_sampled_history(
         self, sampled_history: pb.SampledHistoryRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(sampled_history=sampled_history)
-        return self._deliver_record(record)
+        return self._deliver(record)
 
     def _deliver_request_run_status(
         self, run_status: pb.RunStatusRequest
     ) -> MailboxHandle[pb.Result]:
         record = self._make_request(run_status=run_status)
-        return self._deliver_record(record)
+        return self._deliver(record)