wandb 0.18.1__py3-none-win32.whl → 0.18.2__py3-none-win32.whl

wandb/__init__.py

@@ -8,7 +8,7 @@ For scripts and interactive notebooks, see https://github.com/wandb/examples.
 
 For reference documentation, see https://docs.wandb.com/ref/python.
 """
-__version__ = "0.18.1"
+__version__ = "0.18.2"
 
 from typing import Optional
 
@@ -76,8 +76,7 @@ from wandb.data_types import JoinedTable
 
 from wandb.wandb_agent import agent
 
-from wandb.sdk.lib.viz import visualize
-from wandb import plot
+from wandb.plot.viz import visualize
 from wandb.integration.sagemaker import sagemaker_auth
 from wandb.sdk.internal import profiler
 
@@ -242,4 +241,5 @@ __all__ = (
     "use_model",
     "link_model",
     "define_metric",
+    "watch",
 )

wandb/__init__.pyi

@@ -9,6 +9,8 @@ For scripts and interactive notebooks, see https://github.com/wandb/examples.
 For reference documentation, see https://docs.wandb.com/ref/python.
 """
 
+from __future__ import annotations
+
 __all__ = (
     "__version__",
     "init",
@@ -49,12 +51,23 @@ __all__ = (
     "Artifact",
     "Settings",
     "teardown",
+    "watch",
 )
 
 import os
-from typing import Any, Callable, Dict, List, Literal, Optional, Sequence, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Union,
+)
 
-from wandb.analytics import Sentry as _Sentry
+from wandb.analytics import Sentry
 from wandb.apis import InternalApi, PublicApi
 from wandb.data_types import (
     Audio,
@@ -79,17 +92,20 @@ from wandb.sdk.wandb_run import Run
 from wandb.sdk.wandb_setup import _WandbSetup
 from wandb.wandb_controller import _WandbController
 
-__version__: str = "0.18.1"
+if TYPE_CHECKING:
+    import torch  # type: ignore [import-not-found]
 
-run: Optional[Run] = None
-config = wandb_config.Config
-summary = wandb_summary.Summary
-Api = PublicApi
-api = InternalApi()
-_sentry = _Sentry()
+__version__: str = "0.18.2"
 
-# record of patched libraries
-patched = {"tensorboard": [], "keras": [], "gym": []}  # type: ignore
+run: Run | None
+config: wandb_config.Config
+summary: wandb_summary.Summary
+Api: PublicApi
+
+# private attributes
+_sentry: Sentry
+api: InternalApi
+patched: Dict[str, List[Callable]]
 
 def setup(
     settings: Optional[Settings] = None,
@@ -183,7 +199,7 @@ def init(
     allow_val_change: Optional[bool] = None,
     resume: Optional[Union[bool, str]] = None,
     force: Optional[bool] = None,
-    tensorboard: Optional[bool] = None,  # alias for sync_tensorboard
+    tensorboard: Optional[bool] = None,
     sync_tensorboard: Optional[bool] = None,
     monitor_gym: Optional[bool] = None,
     save_code: Optional[bool] = None,
@@ -1082,3 +1098,42 @@ def link_model(
         None
     """
     ...
+
+def watch(
+    models: torch.nn.Module | Sequence[torch.nn.Module],
+    criterion: torch.F | None = None,
+    log: Literal["gradients", "parameters", "all"] | None = "gradients",
+    log_freq: int = 1000,
+    idx: int | None = None,
+    log_graph: bool = False,
+) -> Graph:
+    """Hooks into the given PyTorch model(s) to monitor gradients and the model's computational graph.
+
+    This function can track parameters, gradients, or both during training. It should be
+    extended to support arbitrary machine learning models in the future.
+
+    Args:
+        models (Union[torch.nn.Module, Sequence[torch.nn.Module]]):
+            A single model or a sequence of models to be monitored.
+        criterion (Optional[torch.F]):
+            The loss function being optimized (optional).
+        log (Optional[Literal["gradients", "parameters", "all"]]):
+            Specifies whether to log "gradients", "parameters", or "all".
+            Set to None to disable logging. (default="gradients")
+        log_freq (int):
+            Frequency (in batches) to log gradients and parameters. (default=1000)
+        idx (Optional[int]):
+            Index used when tracking multiple models with `wandb.watch`. (default=None)
+         log_graph (bool):
+            Whether to log the model's computational graph. (default=False)
+
+    Returns:
+        wandb.Graph:
+            The graph object, which will be populated after the first backward pass.
+
+    Raises:
+        ValueError:
+            If `wandb.init` has not been called or if any of the models are not instances
+            of `torch.nn.Module`.
+    """
+    ...

wandb/apis/internal.py

@@ -204,6 +204,9 @@ class Api:
     def create_run_queue(self, *args, **kwargs):
         return self.api.create_run_queue(*args, **kwargs)
 
+    def upsert_run_queue(self, *args, **kwargs):
+        return self.api.upsert_run_queue(*args, **kwargs)
+
     def update_launch_agent_status(self, *args, **kwargs):
         return self.api.update_launch_agent_status(*args, **kwargs)
 

wandb/apis/public/api.py

@@ -421,6 +421,121 @@ class Api:
             _default_resource_config=config,
         )
 
+    def upsert_run_queue(
+        self,
+        name: str,
+        resource_config: dict,
+        resource_type: "public.RunQueueResourceType",
+        entity: Optional[str] = None,
+        template_variables: Optional[dict] = None,
+        external_links: Optional[dict] = None,
+        prioritization_mode: Optional["public.RunQueuePrioritizationMode"] = None,
+    ):
+        """Upsert a run queue (launch).
+
+        Arguments:
+            name: (str) Name of the queue to create
+            entity: (str) Optional name of the entity to create the queue. If None, will use the configured or default entity.
+            resource_config: (dict) Optional default resource configuration to be used for the queue. Use handlebars (eg. "{{var}}") to specify template variables.
+            resource_type: (str) Type of resource to be used for the queue. One of "local-container", "local-process", "kubernetes", "sagemaker", or "gcp-vertex".
+            template_variables: (dict) A dictionary of template variable schemas to be used with the config. Expected format of:
+                {
+                    "var-name": {
+                        "schema": {
+                            "type": ("string", "number", or "integer"),
+                            "default": (optional value),
+                            "minimum": (optional minimum),
+                            "maximum": (optional maximum),
+                            "enum": [..."(options)"]
+                        }
+                    }
+                }
+            external_links: (dict) Optional dictionary of external links to be used with the queue. Expected format of:
+                {
+                    "name": "url"
+                }
+            prioritization_mode: (str) Optional version of prioritization to use. Either "V0" or None
+
+        Returns:
+            The upserted `RunQueue`.
+
+        Raises:
+            ValueError if any of the parameters are invalid
+            wandb.Error on wandb API errors
+        """
+        if entity is None:
+            entity = self.settings["entity"] or self.default_entity
+            if entity is None:
+                raise ValueError(
+                    "entity must be passed as a parameter, or set in settings"
+                )
+
+        if len(name) == 0:
+            raise ValueError("name must be non-empty")
+        if len(name) > 64:
+            raise ValueError("name must be less than 64 characters")
+
+        prioritization_mode = prioritization_mode or "DISABLED"
+        prioritization_mode = prioritization_mode.upper()
+        if prioritization_mode not in ["V0", "DISABLED"]:
+            raise ValueError(
+                "prioritization_mode must be 'V0' or 'DISABLED' if present"
+            )
+
+        if resource_type not in [
+            "local-container",
+            "local-process",
+            "kubernetes",
+            "sagemaker",
+            "gcp-vertex",
+        ]:
+            raise ValueError(
+                "resource_type must be one of 'local-container', 'local-process', 'kubernetes', 'sagemaker', or 'gcp-vertex'"
+            )
+
+        self.create_project(LAUNCH_DEFAULT_PROJECT, entity)
+        api = InternalApi(
+            default_settings={
+                "entity": entity,
+                "project": self.project(LAUNCH_DEFAULT_PROJECT),
+            },
+            retry_timedelta=RETRY_TIMEDELTA,
+        )
+        # User provides external_links as a dict with name: url format
+        # but backend stores it as a list of dicts with url and label keys.
+        external_links = external_links or {}
+        external_links = {
+            "links": [
+                {
+                    "label": key,
+                    "url": value,
+                }
+                for key, value in external_links.items()
+            ]
+        }
+        upsert_run_queue_result = api.upsert_run_queue(
+            name,
+            entity,
+            resource_type,
+            {"resource_args": {resource_type: resource_config}},
+            template_variables=template_variables,
+            external_links=external_links,
+            prioritization_mode=prioritization_mode,
+        )
+        if not upsert_run_queue_result["success"]:
+            raise wandb.Error("failed to create run queue")
+        schema_errors = (
+            upsert_run_queue_result.get("configSchemaValidationErrors") or []
+        )
+        for error in schema_errors:
+            wandb.termwarn(f"resource config validation: {error}")
+
+        return public.RunQueue(
+            client=self.client,
+            name=name,
+            entity=entity,
+        )
+
     def create_user(self, email, admin=False):
         """Create a new user.
 
@@ -996,7 +1111,11 @@ class Api:
 
     @normalize_exceptions
     def artifacts(
-        self, type_name: str, name: str, per_page: Optional[int] = 50
+        self,
+        type_name: str,
+        name: str,
+        per_page: Optional[int] = 50,
+        tags: Optional[List[str]] = None,
     ) -> "public.Artifacts":
         """Return an `Artifacts` collection from the given parameters.
 
@@ -1005,13 +1124,20 @@ class Api:
             name: (str) An artifact collection name. May be prefixed with entity/project.
             per_page: (int, optional) Sets the page size for query pagination.  None will use the default size.
                 Usually there is no reason to change this.
+            tags: (list[str], optional) Only return artifacts with all of these tags.
 
         Returns:
             An iterable `Artifacts` object.
         """
         entity, project, collection_name = self._parse_artifact_path(name)
         return public.Artifacts(
-            self.client, entity, project, collection_name, type_name, per_page=per_page
+            self.client,
+            entity,
+            project,
+            collection_name,
+            type_name,
+            per_page=per_page,
+            tags=tags,
         )
 
     @normalize_exceptions

wandb/apis/public/artifacts.py

@@ -3,7 +3,7 @@
 import json
 import re
 from copy import copy
-from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Sequence
+from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Sequence, Union
 
 from wandb_gql import Client, gql
 
@@ -757,12 +757,14 @@ class Artifacts(Paginator):
         filters: Optional[Mapping[str, Any]] = None,
         order: Optional[str] = None,
         per_page: int = 50,
+        tags: Optional[Union[str, List[str]]] = None,
     ):
         self.entity = entity
         self.collection_name = collection_name
         self.type = type
         self.project = project
         self.filters = {"state": "COMMITTED"} if filters is None else filters
+        self.tags = [tags] if isinstance(tags, str) else tags
         self.order = order
         variables = {
             "project": self.project,
@@ -835,9 +837,9 @@ class Artifacts(Paginator):
             return None
 
     def convert_objects(self):
-        if self.last_response["project"]["artifactType"]["artifactCollection"] is None:
-            return []
-        return [
+        collection = self.last_response["project"]["artifactType"]["artifactCollection"]
+        artifact_edges = collection.get("artifacts", {}).get("edges", [])
+        artifacts = (
             wandb.Artifact._from_attrs(
                 self.entity,
                 self.project,
@@ -845,9 +847,11 @@ class Artifacts(Paginator):
                 a["node"],
                 self.client,
             )
-            for a in self.last_response["project"]["artifactType"][
-                "artifactCollection"
-            ]["artifacts"]["edges"]
+            for a in artifact_edges
+        )
+        required_tags = set(self.tags or [])
+        return [
+            artifact for artifact in artifacts if required_tags.issubset(artifact.tags)
         ]
 
 

wandb/apis/public/jobs.py

@@ -473,6 +473,12 @@ class RunQueue:
             self._get_metadata()
         return self._access
 
+    @property
+    def external_links(self) -> Dict[str, str]:
+        if self._external_links is None:
+            self._get_metadata()
+        return self._external_links
+
     @property
     def type(self) -> RunQueueResourceType:
         if self._type is None:
@@ -549,6 +555,7 @@ class RunQueue:
                         access
                         defaultResourceConfigID
                         prioritizationMode
+                        externalLinks
                     }
                 }
             }
@@ -565,6 +572,7 @@ class RunQueue:
         self._default_resource_config_id = res["project"]["runQueue"][
             "defaultResourceConfigID"
         ]
+        self._external_links = res["project"]["runQueue"]["externalLinks"]
         if self._default_resource_config_id is None:
             self._default_resource_config = {}
         self._prioritization_mode = res["project"]["runQueue"]["prioritizationMode"]

wandb/apis/public/runs.py

@@ -6,7 +6,7 @@ import sys
 import tempfile
 import time
 import urllib
-from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Collection, Dict, List, Mapping, Optional
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -794,13 +794,20 @@ class Run(Attrs):
             raise ValueError("You must pass a wandb.Api().artifact() to use_artifact")
 
     @normalize_exceptions
-    def log_artifact(self, artifact, aliases=None):
+    def log_artifact(
+        self,
+        artifact: "wandb.Artifact",
+        aliases: Optional[Collection[str]] = None,
+        tags: Optional[Collection[str]] = None,
+    ):
         """Declare an artifact as output of a run.
 
         Arguments:
             artifact (`Artifact`): An artifact returned from
-                `wandb.Api().artifact(name)`
-            aliases (list, optional): Aliases to apply to this artifact
+                `wandb.Api().artifact(name)`.
+            aliases (list, optional): Aliases to apply to this artifact.
+            tags: (list, optional) Tags to apply to this artifact, if any.
+
         Returns:
             A `Artifact` object.
         """
@@ -825,7 +832,11 @@ class Run(Attrs):
 
         artifact_collection_name = artifact.source_name.split(":")[0]
         api.create_artifact(
-            artifact.type, artifact_collection_name, artifact.digest, aliases=aliases
+            artifact.type,
+            artifact_collection_name,
+            artifact.digest,
+            aliases=aliases,
+            tags=tags,
         )
         return artifact
 

wandb/cli/cli.py

@@ -275,7 +275,6 @@ def login(key, host, cloud, relogin, anonymously, verify, no_offline=False):
 @click.option("--address", default=None, help="The address to bind service.")
 @click.option("--pid", default=None, type=int, help="The parent process id to monitor.")
 @click.option("--debug", is_flag=True, help="log debug info")
-@click.option("--serve-sock", is_flag=True, help="use socket mode")
 @display_error
 def service(
     sock_port=None,
@@ -283,7 +282,6 @@ def service(
     address=None,
     pid=None,
     debug=False,
-    serve_sock=False,
 ):
     from wandb.sdk.service.server import WandbServer
 
@@ -293,7 +291,6 @@ def service(
         address=address,
         pid=pid,
         debug=debug,
-        serve_sock=serve_sock,
     )
     server.serve()
 

wandb/errors/__init__.py

@@ -1,46 +1,17 @@
-__all__ = [
+__all__ = (
     "Error",
     "CommError",
     "AuthenticationError",
     "UsageError",
     "UnsupportedError",
     "WandbCoreNotAvailableError",
-]
-
-from typing import Optional
-
-
-class Error(Exception):
-    """Base W&B Error."""
-
-    def __init__(self, message, context: Optional[dict] = None) -> None:
-        super().__init__(message)
-        self.message = message
-        # sentry context capture
-        if context:
-            self.context = context
-
-
-class CommError(Error):
-    """Error communicating with W&B servers."""
-
-    def __init__(self, msg, exc=None) -> None:
-        self.exc = exc
-        self.message = msg
-        super().__init__(self.message)
-
-
-class AuthenticationError(CommError):
-    """Raised when authentication fails."""
-
-
-class UsageError(Error):
-    """Raised when an invalid usage of the SDK API is detected."""
-
-
-class UnsupportedError(UsageError):
-    """Raised when trying to use a feature that is not supported."""
-
-
-class WandbCoreNotAvailableError(Error):
-    """Raised when wandb core is not available."""
+)
+
+from .errors import (
+    AuthenticationError,
+    CommError,
+    Error,
+    UnsupportedError,
+    UsageError,
+    WandbCoreNotAvailableError,
+)

wandb/errors/errors.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+
+class Error(Exception):
+    """Base W&B Error."""
+
+    def __init__(self, message, context: Optional[dict] = None) -> None:
+        super().__init__(message)
+        self.message = message
+        # sentry context capture
+        if context:
+            self.context = context
+
+
+class CommError(Error):
+    """Error communicating with W&B servers."""
+
+    def __init__(self, msg, exc=None) -> None:
+        self.exc = exc
+        self.message = msg
+        super().__init__(self.message)
+
+
+class AuthenticationError(CommError):
+    """Raised when authentication fails."""
+
+
+class UsageError(Error):
+    """Raised when an invalid usage of the SDK API is detected."""
+
+
+class UnsupportedError(UsageError):
+    """Raised when trying to use a feature that is not supported."""
+
+
+class WandbCoreNotAvailableError(Error):
+    """Raised when wandb core is not available."""

wandb/errors/warnings.py

@@ -0,0 +1,2 @@
+class WandbWarning(Warning):
+    """Base W&B Warning."""

wandb/integration/tensorboard/log.py

@@ -5,8 +5,8 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import wandb
 import wandb.util
+from wandb.plot.viz import custom_chart
 from wandb.sdk.lib import telemetry
-from wandb.sdk.lib.viz import custom_chart
 
 if TYPE_CHECKING:
     import numpy as np