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

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:
+    singleton = wandb_setup.singleton_if_setup()
+    if singleton and (singleton.settings.quiet or singleton.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/internal/internal_api.py

@@ -284,6 +284,7 @@ class Api:
         self._extra_http_headers.update(_thread_local_api_settings.headers or {})
 
         auth = None
+        api_key = api_key or self.default_settings.get("api_key")
         if api_key:
             auth = ("api", api_key)
         elif self.access_token is not None:
@@ -3234,6 +3235,7 @@ class Api:
         entity: Optional[str] = None,
         state: Optional[str] = None,
         prior_runs: Optional[List[str]] = None,
+        display_name: Optional[str] = None,
         template_variable_values: Optional[Dict[str, Any]] = None,
     ) -> Tuple[str, List[str]]:
         """Upsert a sweep object.
@@ -3248,6 +3250,7 @@ class Api:
             entity (str): entity to use
             state (str): state
             prior_runs (list): IDs of existing runs to add to the sweep
+            display_name (str): display name for the sweep
             template_variable_values (dict): template variable values
         """
         project_query = """
@@ -3271,6 +3274,7 @@ class Api:
             $scheduler: JSONString,
             $state: String,
             $priorRunsFilters: JSONString,
+            $displayName: String,
         ) {
             upsertSweep(input: {
                 id: $id,
@@ -3282,6 +3286,7 @@ class Api:
                 scheduler: $scheduler,
                 state: $state,
                 priorRunsFilters: $priorRunsFilters,
+                displayName: $displayName,
             }) {
                 sweep {
                     name
@@ -3358,6 +3363,7 @@ class Api:
                     "templateVariableValues": json.dumps(template_variable_values),
                     "scheduler": scheduler,
                     "priorRunsFilters": filters,
+                    "displayName": display_name,
                 }
                 if state:
                     variables["state"] = state

wandb/sdk/internal/job_builder.py

@@ -109,6 +109,7 @@ class JobSourceDict(TypedDict, total=False):
     input_types: Dict[str, Any]
     output_types: Dict[str, Any]
     runtime: Optional[str]
+    services: Dict[str, str]
 
 
 class ArtifactInfoForJob(TypedDict):
@@ -143,6 +144,7 @@ class JobBuilder:
     _job_version_alias: Optional[str]
     _is_notebook_run: bool
     _verbose: bool
+    _services: Dict[str, str]
 
     def __init__(self, settings: SettingsStatic, verbose: bool = False):
         self._settings = settings
@@ -162,6 +164,7 @@ class JobBuilder:
         self._is_notebook_run = self._get_is_notebook_run()
         self._verbose = verbose
         self._partial = False
+        self._services = {}
 
     def set_config(self, config: Dict[str, Any]) -> None:
         self._config = config
@@ -544,6 +547,9 @@ class JobBuilder:
             "runtime": runtime,
         }
 
+        if self._services:
+            source_info["services"] = self._services
+
         assert source_info is not None
         assert name is not None
 

wandb/sdk/launch/agent/agent.py

@@ -1,6 +1,7 @@
 """Implementation of launch agent."""
 
 import asyncio
+import copy
 import logging
 import os
 import pprint
@@ -421,6 +422,7 @@ class LaunchAgent:
         """Removes the job from our list for now."""
         with self._jobs_lock:
             job_and_run_status = self._jobs[thread_id]
+
         if (
             job_and_run_status.entity is not None
             and job_and_run_status.entity != self._entity
@@ -516,7 +518,11 @@ class LaunchAgent:
         Arguments:
             job: Job to run.
         """
-        _msg = f"{LOG_PREFIX}Launch agent received job:\n{pprint.pformat(job)}\n"
+        job_copy = copy.deepcopy(job)
+        if "runSpec" in job_copy and "_wandb_api_key" in job_copy["runSpec"]:
+            job_copy["runSpec"]["_wandb_api_key"] = "<redacted>"
+
+        _msg = f"{LOG_PREFIX}Launch agent received job:\n{pprint.pformat(job_copy)}\n"
         wandb.termlog(_msg)
         _logger.info(_msg)
         # update agent status
@@ -727,6 +733,7 @@ class LaunchAgent:
         backend = loader.runner_from_config(
             resource, api, backend_config, environment, registry
         )
+
         if not (
             project.docker_image
             or project.job_base_image

wandb/sdk/launch/agent/run_queue_item_file_saver.py

@@ -11,7 +11,7 @@ FileSubtypes = Literal["warning", "error"]
 class RunQueueItemFileSaver:
     def __init__(
         self,
-        agent_run: Optional["wandb.sdk.wandb_run.Run"],
+        agent_run: Optional["wandb.Run"],
         run_queue_item_id: str,
     ):
         self.run_queue_item_id = run_queue_item_id
@@ -20,7 +20,7 @@ class RunQueueItemFileSaver:
     def save_contents(
         self, contents: str, fname: str, file_sub_type: FileSubtypes
     ) -> Optional[List[str]]:
-        if not isinstance(self.run, wandb.sdk.wandb_run.Run):
+        if not isinstance(self.run, wandb.Run):
             wandb.termwarn("Not saving file contents because agent has no run")
             return None
         root_dir = self.run._settings.files_dir

wandb/sdk/launch/create_job.py

@@ -115,6 +115,7 @@ def _create_job(
     build_context: Optional[str] = None,
     dockerfile: Optional[str] = None,
     base_image: Optional[str] = None,
+    services: Optional[Dict[str, str]] = None,
 ) -> Tuple[Optional[Artifact], str, List[str]]:
     wandb.termlog(f"Creating launch job of type: {job_type}...")
 
@@ -169,6 +170,7 @@ def _create_job(
 
     job_builder = _configure_job_builder_for_partial(tempdir.name, job_source=job_type)
     job_builder._settings.job_name = name
+    job_builder._services = services or {}
     if job_type == "code":
         assert entrypoint is not None
         job_name = _make_code_artifact(
@@ -421,7 +423,7 @@ def _configure_job_builder_for_partial(tmpdir: str, job_source: str) -> JobBuild
 def _make_code_artifact(
     api: Api,
     job_builder: JobBuilder,
-    run: "wandb.sdk.wandb_run.Run",
+    run: "wandb.Run",
     path: str,
     entrypoint: str,
     entity: Optional[str],

wandb/sdk/launch/inputs/internal.py

@@ -17,7 +17,6 @@ import wandb
 import wandb.data_types
 from wandb.sdk.launch.errors import LaunchError
 from wandb.sdk.launch.inputs.schema import META_SCHEMA
-from wandb.sdk.wandb_run import Run
 from wandb.util import get_module
 
 from .files import config_path_is_valid, override_file
@@ -93,7 +92,7 @@ class StagedLaunchInputs:
     ):
         self._staged_inputs.append(input_arguments)
 
-    def apply(self, run: Run):
+    def apply(self, run: wandb.Run):
         """Apply the staged inputs to the given run."""
         for input in self._staged_inputs:
             _publish_job_input(input, run)
@@ -101,13 +100,13 @@ class StagedLaunchInputs:
 
 def _publish_job_input(
     input: JobInputArguments,
-    run: Run,
+    run: wandb.Run,
 ) -> None:
     """Publish a job input to the backend interface of the given run.
 
     Arguments:
         input (JobInputArguments): The arguments for the job input.
-        run (Run): The run to publish the job input to.
+        run (wandb.Run): The run to publish the job input to.
     """
     assert run._backend is not None
     assert run._backend.interface is not None

wandb/sdk/launch/inputs/schema.py

@@ -7,6 +7,7 @@ META_SCHEMA = {
         },
         "title": {"type": "string"},
         "description": {"type": "string"},
+        "format": {"type": "string"},
         "enum": {"type": "array", "items": {"type": ["integer", "number", "string"]}},
         "properties": {"type": "object", "patternProperties": {".*": {"$ref": "#"}}},
         "allOf": {"type": "array", "items": {"$ref": "#"}},

wandb/sdk/launch/runner/kubernetes_monitor.py

@@ -27,6 +27,7 @@ WANDB_K8S_LABEL_NAMESPACE = "wandb.ai"
 WANDB_K8S_RUN_ID = f"{WANDB_K8S_LABEL_NAMESPACE}/run-id"
 WANDB_K8S_LABEL_AGENT = f"{WANDB_K8S_LABEL_NAMESPACE}/agent"
 WANDB_K8S_LABEL_MONITOR = f"{WANDB_K8S_LABEL_NAMESPACE}/monitor"
+WANDB_K8S_LABEL_AUXILIARY_RESOURCE = f"{WANDB_K8S_LABEL_NAMESPACE}/auxiliary-resource"
 
 
 class Resources: