wandb 0.18.3__py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.18.5__py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

wandb/__init__.py

@@ -8,9 +8,10 @@ For scripts and interactive notebooks, see https://github.com/wandb/examples.
 
 For reference documentation, see https://docs.wandb.com/ref/python.
 """
-__version__ = "0.18.3"
+from __future__ import annotations
+
+__version__ = "0.18.5"
 
-from typing import Optional
 
 from wandb.errors import Error
 
@@ -28,8 +29,6 @@ setup = wandb_sdk.setup
 _attach = wandb_sdk._attach
 _sync = wandb_sdk._sync
 _teardown = wandb_sdk.teardown
-watch = wandb_sdk.watch
-unwatch = wandb_sdk.unwatch
 finish = wandb_sdk.finish
 join = finish
 login = wandb_sdk.login
@@ -112,10 +111,12 @@ def _assert_is_user_process():
 # globals
 Api = PublicApi
 api = InternalApi()
-run: Optional["wandb_sdk.wandb_run.Run"] = None
+run: wandb_sdk.wandb_run.Run | None = None
 config = _preinit.PreInitObject("wandb.config", wandb_sdk.wandb_config.Config)
 summary = _preinit.PreInitObject("wandb.summary", wandb_sdk.wandb_summary.Summary)
 log = _preinit.PreInitCallable("wandb.log", wandb_sdk.wandb_run.Run.log)  # type: ignore
+watch = _preinit.PreInitCallable("wandb.watch", wandb_sdk.wandb_run.Run.watch)  # type: ignore
+unwatch = _preinit.PreInitCallable("wandb.unwatch", wandb_sdk.wandb_run.Run.unwatch)  # type: ignore
 save = _preinit.PreInitCallable("wandb.save", wandb_sdk.wandb_run.Run.save)  # type: ignore
 restore = wandb_sdk.wandb_run.restore
 use_artifact = _preinit.PreInitCallable(
@@ -200,9 +201,16 @@ if "dev" in __version__:
     import wandb.env
     import os
 
-    # disable error reporting in dev versions for the python client
+    # Disable error reporting in dev versions.
     os.environ[wandb.env.ERROR_REPORTING] = os.environ.get(
-        wandb.env.ERROR_REPORTING, "false"
+        wandb.env.ERROR_REPORTING,
+        "false",
+    )
+
+    # Enable new features in dev versions.
+    os.environ["WANDB__SHOW_OPERATION_STATS"] = os.environ.get(
+        "WANDB__SHOW_OPERATION_STATS",
+        "true",
     )
 
 _sentry = _Sentry()
@@ -242,4 +250,5 @@ __all__ = (
     "link_model",
     "define_metric",
     "watch",
+    "unwatch",
 )

wandb/__init__.pyi

@@ -52,6 +52,7 @@ __all__ = (
     "Settings",
     "teardown",
     "watch",
+    "unwatch",
 )
 
 import os
@@ -95,12 +96,14 @@ from wandb.wandb_controller import _WandbController
 if TYPE_CHECKING:
     import torch  # type: ignore [import-not-found]
 
-__version__: str = "0.18.3"
+    from wandb.plot.viz import CustomChart
+
+__version__: str = "0.18.5"
 
 run: Run | None
 config: wandb_config.Config
 summary: wandb_summary.Summary
-Api: PublicApi
+Api: type[PublicApi]
 
 # private attributes
 _sentry: Sentry
@@ -181,32 +184,32 @@ def teardown(exit_code: Optional[int] = None) -> None:
     ...
 
 def init(
-    job_type: Optional[str] = None,
-    dir: Optional[StrPath] = None,
-    config: Union[Dict, str, None] = None,
-    project: Optional[str] = None,
-    entity: Optional[str] = None,
-    reinit: Optional[bool] = None,
-    tags: Optional[Sequence] = None,
-    group: Optional[str] = None,
-    name: Optional[str] = None,
-    notes: Optional[str] = None,
-    magic: Optional[Union[dict, str, bool]] = None,
-    config_exclude_keys: Optional[List[str]] = None,
-    config_include_keys: Optional[List[str]] = None,
-    anonymous: Optional[str] = None,
-    mode: Optional[str] = None,
-    allow_val_change: Optional[bool] = None,
-    resume: Optional[Union[bool, str]] = None,
-    force: Optional[bool] = None,
-    tensorboard: Optional[bool] = None,
-    sync_tensorboard: Optional[bool] = None,
-    monitor_gym: Optional[bool] = None,
-    save_code: Optional[bool] = None,
-    id: Optional[str] = None,
-    fork_from: Optional[str] = None,
-    resume_from: Optional[str] = None,
-    settings: Union[Settings, Dict[str, Any], None] = None,
+    job_type: str | None = None,
+    dir: StrPath | None = None,
+    config: dict | str | None = None,
+    project: str | None = None,
+    entity: str | None = None,
+    reinit: bool | None = None,
+    tags: Sequence | None = None,
+    group: str | None = None,
+    name: str | None = None,
+    notes: str | None = None,
+    magic: dict | str | bool | None = None,
+    config_exclude_keys: list[str] | None = None,
+    config_include_keys: list[str] | None = None,
+    anonymous: str | None = None,
+    mode: str | None = None,
+    allow_val_change: bool | None = None,
+    resume: bool | str | None = None,
+    force: bool | None = None,
+    tensorboard: bool | None = None,  # alias for sync_tensorboard
+    sync_tensorboard: bool | None = None,
+    monitor_gym: bool | None = None,
+    save_code: bool | None = None,
+    id: str | None = None,
+    fork_from: str | None = None,
+    resume_from: str | None = None,
+    settings: Settings | dict[str, Any] | None = None,
 ) -> Run:
     r"""Start a new run to track and log to W&B.
 
@@ -420,7 +423,7 @@ def init(
     """
     ...
 
-def finish(exit_code: Optional[int] = None, quiet: Optional[bool] = None) -> None:
+def finish(exit_code: int | None = None, quiet: bool | None = None) -> None:
     """Mark a run as finished, and finish uploading all data.
 
     This is used when creating multiple runs in the same process.
@@ -470,10 +473,10 @@ def login(
     ...
 
 def log(
-    data: Dict[str, Any],
-    step: Optional[int] = None,
-    commit: Optional[bool] = None,
-    sync: Optional[bool] = None,
+    data: dict[str, Any],
+    step: int | None = None,
+    commit: bool | None = None,
+    sync: bool | None = None,
 ) -> None:
     """Upload run data.
 
@@ -704,10 +707,10 @@ def log(
     ...
 
 def save(
-    glob_str: Optional[Union[str, os.PathLike]] = None,
-    base_path: Optional[Union[str, os.PathLike]] = None,
+    glob_str: str | os.PathLike | None = None,
+    base_path: str | os.PathLike | None = None,
     policy: PolicyName = "live",
-) -> Union[bool, List[str]]:
+) -> bool | list[str]:
     """Sync one or more files to W&B.
 
     Relative paths are relative to the current working directory.
@@ -846,12 +849,12 @@ def agent(
 
 def define_metric(
     name: str,
-    step_metric: Union[str, wandb_metric.Metric, None] = None,
-    step_sync: Optional[bool] = None,
-    hidden: Optional[bool] = None,
-    summary: Optional[str] = None,
-    goal: Optional[str] = None,
-    overwrite: Optional[bool] = None,
+    step_metric: str | wandb_metric.Metric | None = None,
+    step_sync: bool | None = None,
+    hidden: bool | None = None,
+    summary: str | None = None,
+    goal: str | None = None,
+    overwrite: bool | None = None,
 ) -> wandb_metric.Metric:
     """Customize metrics logged with `wandb.log()`.
 
@@ -882,11 +885,11 @@ def define_metric(
     ...
 
 def log_artifact(
-    artifact_or_path: Union[Artifact, StrPath],
-    name: Optional[str] = None,
-    type: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
-    tags: Optional[List[str]] = None,
+    artifact_or_path: Artifact | StrPath,
+    name: str | None = None,
+    type: str | None = None,
+    aliases: list[str] | None = None,
+    tags: list[str] | None = None,
 ) -> Artifact:
     """Declare an artifact as an output of a run.
 
@@ -915,10 +918,10 @@ def log_artifact(
     ...
 
 def use_artifact(
-    artifact_or_name: Union[str, Artifact],
-    type: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
-    use_as: Optional[str] = None,
+    artifact_or_name: str | Artifact,
+    type: str | None = None,
+    aliases: list[str] | None = None,
+    use_as: str | None = None,
 ) -> Artifact:
     """Declare an artifact as an input to a run.
 
@@ -926,8 +929,9 @@ def use_artifact(
 
     Arguments:
         artifact_or_name: (str or Artifact) An artifact name.
-            May be prefixed with entity/project/. Valid names
-            can be in the following forms:
+            May be prefixed with project/ or entity/project/.
+            If no entity is specified in the name, the Run or API setting's entity is used.
+            Valid names can be in the following forms:
                 - name:version
                 - name:alias
             You can also pass an Artifact object created by calling `wandb.Artifact`
@@ -943,8 +947,8 @@ def use_artifact(
 
 def log_model(
     path: StrPath,
-    name: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
+    name: str | None = None,
+    aliases: list[str] | None = None,
 ) -> None:
     """Logs a model artifact containing the contents inside the 'path' to a run and marks it as an output to this run.
 
@@ -1031,8 +1035,8 @@ def use_model(name: str) -> FilePathStr:
 def link_model(
     path: StrPath,
     registered_model_name: str,
-    name: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
+    name: str | None = None,
+    aliases: list[str] | None = None,
 ) -> None:
     """Log a model artifact version and link it to a registered model in the model registry.
 
@@ -1099,6 +1103,28 @@ def link_model(
     """
     ...
 
+def plot_table(
+    vega_spec_name: str,
+    data_table: Table,
+    fields: dict[str, Any],
+    string_fields: dict[str, Any] | None = None,
+    split_table: bool | None = False,
+) -> CustomChart:
+    """Create a custom plot on a table.
+
+    Arguments:
+        vega_spec_name: the name of the spec for the plot
+        data_table: a wandb.Table object containing the data to
+            be used on the visualization
+        fields: a dict mapping from table keys to fields that the custom
+            visualization needs
+        string_fields: a dict that provides values for any string constants
+            the custom visualization needs
+        split_table: a boolean that indicates whether the table should be in
+            a separate section in the UI
+    """
+    ...
+
 def watch(
     models: torch.nn.Module | Sequence[torch.nn.Module],
     criterion: torch.F | None = None,
@@ -1106,7 +1132,7 @@ def watch(
     log_freq: int = 1000,
     idx: int | None = None,
     log_graph: bool = False,
-) -> Graph:
+) -> None:
     """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
@@ -1124,16 +1150,23 @@ def watch(
             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):
+        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`.
     """
     ...
+
+def unwatch(
+    models: torch.nn.Module | Sequence[torch.nn.Module] | None = None,
+) -> None:
+    """Remove pytorch model topology, gradient and parameter hooks.
+
+    Args:
+        models (torch.nn.Module | Sequence[torch.nn.Module]):
+            Optional list of pytorch models that have had watch called on them
+    """
+    ...

wandb/analytics/sentry.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 __all__ = ("Sentry",)
 
 
@@ -7,7 +9,7 @@ import os
 import pathlib
 import sys
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Callable
 from urllib.parse import quote
 
 if sys.version_info >= (3, 8):
@@ -16,6 +18,7 @@ else:
     from typing_extensions import Literal
 
 import sentry_sdk  # type: ignore
+import sentry_sdk.scope  # type: ignore
 import sentry_sdk.utils  # type: ignore
 
 import wandb
@@ -36,7 +39,7 @@ def _safe_noop(func: Callable) -> Callable:
     """Decorator to ensure that Sentry methods do nothing if disabled and don't raise."""
 
     @functools.wraps(func)
-    def wrapper(self: Type["Sentry"], *args: Any, **kwargs: Any) -> Any:
+    def wrapper(self: type[Sentry], *args: Any, **kwargs: Any) -> Any:
         if self._disabled:
             return None
         try:
@@ -59,7 +62,7 @@ class Sentry:
 
         self.dsn = os.environ.get(wandb.env.SENTRY_DSN, SENTRY_DEFAULT_DSN)
 
-        self.hub: Optional[sentry_sdk.hub.Hub] = None
+        self.scope: sentry_sdk.scope.Scope | None = None
 
         # ensure we always end the Sentry session
         atexit.register(self.end_session)
@@ -87,47 +90,50 @@ class Sentry:
             environment=self.environment,
             release=wandb.__version__,
         )
-        self.hub = sentry_sdk.Hub(client)
+        self.scope = sentry_sdk.get_global_scope().fork()
+        self.scope.clear()
+        self.scope.set_client(client)
 
     @_safe_noop
-    def message(self, message: str, repeat: bool = True) -> None:
+    def message(self, message: str, repeat: bool = True) -> str | None:
         """Send a message to Sentry."""
         if not repeat and message in self._sent_messages:
-            return
+            return None
         self._sent_messages.add(message)
-        self.hub.capture_message(message)  # type: ignore
+        with sentry_sdk.scope.use_isolation_scope(self.scope):  # type: ignore
+            return sentry_sdk.capture_message(message)  # type: ignore
 
     @_safe_noop
     def exception(
         self,
-        exc: Union[
-            str,
-            BaseException,
-            Tuple[
-                Optional[Type[BaseException]],
-                Optional[BaseException],
-                Optional[TracebackType],
-            ],
-            None,
-        ],
+        exc: str
+        | BaseException
+        | tuple[
+            type[BaseException] | None,
+            BaseException | None,
+            TracebackType | None,
+        ]
+        | None,
         handled: bool = False,
-        status: Optional["SessionStatus"] = None,
-    ) -> None:
+        status: SessionStatus | None = None,
+    ) -> str | None:
         """Log an exception to Sentry."""
-        error = Exception(exc) if isinstance(exc, str) else exc
-        # based on self.hub.capture_exception(_exc)
-        if error is not None:
-            exc_info = sentry_sdk.utils.exc_info_from_error(error)
+        if isinstance(exc, str):
+            exc_info = sentry_sdk.utils.exc_info_from_error(Exception(exc))
+        elif isinstance(exc, BaseException):
+            exc_info = sentry_sdk.utils.exc_info_from_error(exc)
         else:
             exc_info = sys.exc_info()
 
-        event, hint = sentry_sdk.utils.event_from_exception(
+        event, _ = sentry_sdk.utils.event_from_exception(
             exc_info,
-            client_options=self.hub.client.options,  # type: ignore
+            client_options=self.scope.get_client().options,  # type: ignore
             mechanism={"type": "generic", "handled": handled},
         )
+        event_id = None
         try:
-            self.hub.capture_event(event, hint=hint)  # type: ignore
+            with sentry_sdk.scope.use_isolation_scope(self.scope):  # type: ignore
+                event_id = sentry_sdk.capture_event(event)  # type: ignore
         except Exception:
             pass
 
@@ -136,11 +142,11 @@ class Sentry:
         status = status or ("crashed" if not handled else "errored")  # type: ignore
         self.mark_session(status=status)
 
-        client, _ = self.hub._stack[-1]  # type: ignore
+        client = self.scope.get_client()  # type: ignore
         if client is not None:
             client.flush()
 
-        return None
+        return event_id
 
     def reraise(self, exc: Any) -> None:
         """Re-raise an exception after logging it to Sentry.
@@ -157,33 +163,31 @@ class Sentry:
     @_safe_noop
     def start_session(self) -> None:
         """Start a new session."""
-        assert self.hub is not None
+        assert self.scope is not None
         # get the current client and scope
-        _, scope = self.hub._stack[-1]
-        session = scope._session
+        session = self.scope._session
 
         # if there's no session, start one
         if session is None:
-            self.hub.start_session()
+            self.scope.start_session()
 
     @_safe_noop
     def end_session(self) -> None:
         """End the current session."""
-        assert self.hub is not None
+        assert self.scope is not None
         # get the current client and scope
-        client, scope = self.hub._stack[-1]
-        session = scope._session
+        client = self.scope.get_client()
+        session = self.scope._session
 
         if session is not None and client is not None:
-            self.hub.end_session()
+            self.scope.end_session()
             client.flush()
 
     @_safe_noop
-    def mark_session(self, status: Optional["SessionStatus"] = None) -> None:
+    def mark_session(self, status: SessionStatus | None = None) -> None:
         """Mark the current session with a status."""
-        assert self.hub is not None
-        _, scope = self.hub._stack[-1]
-        session = scope._session
+        assert self.scope is not None
+        session = self.scope._session
 
         if session is not None:
             session.update(status=status)
@@ -191,8 +195,8 @@ class Sentry:
     @_safe_noop
     def configure_scope(
         self,
-        tags: Optional[Dict[str, Any]] = None,
-        process_context: Optional[str] = None,
+        tags: dict[str, Any] | None = None,
+        process_context: str | None = None,
     ) -> None:
         """Configure the Sentry scope for the current thread.
 
@@ -201,7 +205,7 @@ class Sentry:
         all events sent from this thread. It also tries to start a session
         if one doesn't already exist for this thread.
         """
-        assert self.hub is not None
+        assert self.scope is not None
         settings_tags = (
             "entity",
             "project",
@@ -215,51 +219,50 @@ class Sentry:
             "launch",
         )
 
-        with self.hub.configure_scope() as scope:
-            scope.set_tag("platform", wandb.util.get_platform_name())
-
-            # set context
-            if process_context:
-                scope.set_tag("process_context", process_context)
-
-            # apply settings tags
-            if tags is None:
-                return None
-
-            for tag in settings_tags:
-                val = tags.get(tag, None)
-                if val not in (None, ""):
-                    scope.set_tag(tag, val)
-
-            if tags.get("_colab", None):
-                python_runtime = "colab"
-            elif tags.get("_jupyter", None):
-                python_runtime = "jupyter"
-            elif tags.get("_ipython", None):
-                python_runtime = "ipython"
-            else:
-                python_runtime = "python"
-            scope.set_tag("python_runtime", python_runtime)
-
-            # Construct run_url and sweep_url given run_id and sweep_id
-            for obj in ("run", "sweep"):
-                obj_id, obj_url = f"{obj}_id", f"{obj}_url"
-                if tags.get(obj_url, None):
-                    continue
-
-                try:
-                    app_url = wandb.util.app_url(tags["base_url"])  # type: ignore
-                    entity, project = (quote(tags[k]) for k in ("entity", "project"))  # type: ignore
-                    scope.set_tag(
-                        obj_url,
-                        f"{app_url}/{entity}/{project}/{obj}s/{tags[obj_id]}",
-                    )
-                except Exception:
-                    pass
-
-            email = tags.get("email")
-            if email:
-                scope.user = {"email": email}  # noqa
+        self.scope.set_tag("platform", wandb.util.get_platform_name())
+
+        # set context
+        if process_context:
+            self.scope.set_tag("process_context", process_context)
+
+        # apply settings tags
+        if tags is None:
+            return None
+
+        for tag in settings_tags:
+            val = tags.get(tag, None)
+            if val not in (None, ""):
+                self.scope.set_tag(tag, val)
+
+        if tags.get("_colab", None):
+            python_runtime = "colab"
+        elif tags.get("_jupyter", None):
+            python_runtime = "jupyter"
+        elif tags.get("_ipython", None):
+            python_runtime = "ipython"
+        else:
+            python_runtime = "python"
+        self.scope.set_tag("python_runtime", python_runtime)
+
+        # Construct run_url and sweep_url given run_id and sweep_id
+        for obj in ("run", "sweep"):
+            obj_id, obj_url = f"{obj}_id", f"{obj}_url"
+            if tags.get(obj_url, None):
+                continue
+
+            try:
+                app_url = wandb.util.app_url(tags["base_url"])  # type: ignore
+                entity, project = (quote(tags[k]) for k in ("entity", "project"))  # type: ignore
+                self.scope.set_tag(
+                    obj_url,
+                    f"{app_url}/{entity}/{project}/{obj}s/{tags[obj_id]}",
+                )
+            except Exception:
+                pass
+
+        email = tags.get("email")
+        if email:
+            self.scope.user = {"email": email}  # noqa
 
         # todo: add back the option to pass general tags see: c645f625d1c1a3db4a6b0e2aa8e924fee101904c (wandb/util.py)
 

wandb/apis/public/api.py

@@ -27,6 +27,7 @@ from wandb.apis import public
 from wandb.apis.internal import Api as InternalApi
 from wandb.apis.normalize import normalize_exceptions
 from wandb.apis.public.const import RETRY_TIMEDELTA
+from wandb.sdk.artifacts._validators import is_artifact_registry_project
 from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
 from wandb.sdk.launch.utils import LAUNCH_DEFAULT_PROJECT
 from wandb.sdk.lib import retry, runid
@@ -1142,11 +1143,12 @@ class Api:
 
     @normalize_exceptions
     def artifact(self, name, type=None):
-        """Return a single artifact by parsing path in the form `entity/project/name`.
+        """Return a single artifact by parsing path in the form `project/name` or `entity/project/name`.
 
         Arguments:
-            name: (str) An artifact name. May be prefixed with entity/project. Valid names
-                can be in the following forms:
+            name: (str) An artifact name. May be prefixed with project/ or entity/project/.
+                    If no entity is specified in the name, the Run or API setting's entity is used.
+                Valid names can be in the following forms:
                     name:version
                     name:alias
             type: (str, optional) The type of artifact to fetch.
@@ -1157,8 +1159,20 @@ class Api:
         if name is None:
             raise ValueError("You must specify name= to fetch an artifact.")
         entity, project, artifact_name = self._parse_artifact_path(name)
+
+        organization = ""
+        # If its an Registry artifact, the entity is an org instead
+        if is_artifact_registry_project(project):
+            # Update `organization` only if an organization name was provided,
+            # otherwise use the default that you already set above.
+            try:
+                organization, _, _ = name.split("/")
+            except ValueError:
+                organization = ""
+            # set entity to match the settings since in above code it was potentially set to an org
+            entity = self.settings["entity"] or self.default_entity
         artifact = wandb.Artifact._from_name(
-            entity, project, artifact_name, self.client
+            entity, project, artifact_name, self.client, organization
         )
         if type is not None and artifact.type != type:
             raise ValueError(