wandb 0.17.0rc2__py3-none-macosx_11_0_arm64.whl → 0.17.2__py3-none-macosx_11_0_arm64.whl

wandb/__init__.py

@@ -11,7 +11,7 @@ For scripts and interactive notebooks, see https://github.com/wandb/examples.
 
 For reference documentation, see https://docs.wandb.com/ref/python.
 """
-__version__ = "0.17.0rc2"
+__version__ = "0.17.2"
 
 
 # Used with pypi checks and other messages related to pip
@@ -85,7 +85,6 @@ from wandb.wandb_agent import agent
 # from wandb.core import *
 from wandb.viz import visualize
 from wandb import plot
-from wandb import plots  # deprecating this
 from wandb.integration.sagemaker import sagemaker_auth
 from wandb.sdk.internal import profiler
 
@@ -215,9 +214,12 @@ from .analytics import Sentry as _Sentry
 if "dev" in __version__:
     import os
 
+    # disable error reporting in dev versions for the python client
     os.environ["WANDB_ERROR_REPORTING"] = os.environ.get(
         "WANDB_ERROR_REPORTING", "false"
     )
+    # turn on wandb-core for dev versions
+    os.environ["WANDB__REQUIRE_CORE"] = os.environ.get("WANDB__REQUIRE_CORE", "true")
 
 _sentry = _Sentry()
 _sentry.setup()

wandb/apis/importers/internals/internal.py

@@ -323,7 +323,6 @@ def _make_settings(
         "_sync": True,
         "_live_policy_rate_limit": 15,  # matches dir_watcher
         "_live_policy_wait_time": 600,  # matches dir_watcher
-        "_async_upload_concurrency_limit": None,
         "_file_stream_timeout_seconds": 60,
     }
 

wandb/apis/importers/wandb.py

@@ -17,14 +17,14 @@ import filelock
 import polars as pl
 import requests
 import urllib3
+import wandb_workspaces.reports.v1 as wr
 import yaml
 from wandb_gql import gql
+from wandb_workspaces.reports.v1 import Report
 
 import wandb
-import wandb.apis.reports as wr
 from wandb.apis.public import ArtifactCollection, Run
 from wandb.apis.public.files import File
-from wandb.apis.reports import Report
 from wandb.util import coalesce, remove_keys_with_none_values
 
 from . import validation
@@ -266,11 +266,10 @@ class WandbRun:
         yield from self._files
 
     def logs(self) -> Optional[Iterable[str]]:
-        if (fname := self._find_in_files("output.log")) is None:
-            return
-
-        with open(fname) as f:
-            yield from f.readlines()
+        log_files = self._find_all_in_files_regex(r"^.*output\.log$")
+        for path in log_files:
+            with open(path) as f:
+                yield from f.readlines()
 
     def _metadata_file(self) -> Dict[str, Any]:
         if (fname := self._find_in_files("wandb-metadata.json")) is None:
@@ -323,6 +322,12 @@ class WandbRun:
                     return path
         return None
 
+    def _find_all_in_files_regex(self, regex: str) -> Iterable[str]:
+        if files := self.files():
+            for path, _ in files:
+                if re.match(regex, path):
+                    yield path
+
 
 class WandbImporter:
     """Transfers runs, reports, and artifact sequences between W&B instances."""

wandb/apis/internal.py

@@ -170,9 +170,6 @@ class Api:
     def upload_multipart_file_chunk_retry(self, *args, **kwargs):
         return self.api.upload_multipart_file_chunk_retry(*args, **kwargs)
 
-    async def upload_file_retry_async(self, *args, **kwargs):
-        return await self.api.upload_file_retry_async(*args, **kwargs)
-
     def get_run_info(self, *args, **kwargs):
         return self.api.get_run_info(*args, **kwargs)
 

wandb/apis/public/api.py

@@ -15,7 +15,7 @@ import json
 import logging
 import os
 import urllib
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 import requests
 from wandb_gql import Client, gql
@@ -30,13 +30,9 @@ from wandb.apis.public.const import RETRY_TIMEDELTA
 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
+from wandb.sdk.lib.deprecate import Deprecated, deprecate
 from wandb.sdk.lib.gql_request import GraphQLSession
 
-if TYPE_CHECKING:
-    import wandb.apis.reports
-    import wandb.apis.reports.util
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -69,7 +65,7 @@ class RetryingClient:
         check_retry_fn=util.no_retry_auth,
         retryable_exceptions=(RetryError, requests.RequestException),
     )
-    def execute(self, *args, **kwargs):
+    def execute(self, *args, **kwargs):  # noqa: D102  # User not encouraged to use this class directly
         try:
             return self._client.execute(*args, **kwargs)
         except requests.exceptions.ReadTimeout:
@@ -88,7 +84,7 @@ class RetryingClient:
             self._server_info = self.execute(self.INFO_QUERY).get("serverInfo")
         return self._server_info
 
-    def version_supported(self, min_version):
+    def version_supported(self, min_version: str) -> bool:  # noqa: D102  # User not encouraged to use this class directly
         from wandb.util import parse_version
 
         return parse_version(min_version) <= parse_version(
@@ -110,6 +106,17 @@ class Api:
     """
 
     _HTTP_TIMEOUT = env.get_http_timeout(19)
+    DEFAULT_ENTITY_QUERY = gql(
+        """
+        query Viewer{
+            viewer {
+                id
+                entity
+            }
+        }
+        """
+    )
+
     VIEWER_QUERY = gql(
         """
         query Viewer{
@@ -222,7 +229,7 @@ class Api:
 
     def __init__(
         self,
-        overrides=None,
+        overrides: Optional[Dict[str, Any]] = None,
         timeout: Optional[int] = None,
         api_key: Optional[str] = None,
     ) -> None:
@@ -264,38 +271,43 @@ class Api:
                 # https://bugs.python.org/issue22889
                 timeout=self._timeout,
                 auth=auth,
-                url="%s/graphql" % self.settings["base_url"],
+                url="{}/graphql".format(self.settings["base_url"]),
                 cookies=_thread_local_api_settings.cookies,
                 proxies=proxies,
             )
         )
         self._client = RetryingClient(self._base_client)
 
-    def create_project(self, name: str, entity: str):
-        self.client.execute(self.CREATE_PROJECT, {"entityName": entity, "name": name})
+    def create_project(self, name: str, entity: str) -> None:
+        """Create a new project.
 
-    def create_run(self, **kwargs):
-        """Create a new run."""
-        if kwargs.get("entity") is None:
-            kwargs["entity"] = self.default_entity
-        return public.Run.create(self, **kwargs)
+        Arguments:
+            name: (str) The name of the new project.
+            entity: (str) The entity of the new project.
+        """
+        self.client.execute(self.CREATE_PROJECT, {"entityName": entity, "name": name})
 
-    def create_report(
+    def create_run(
         self,
-        project: str,
-        entity: str = "",
-        title: Optional[str] = "Untitled Report",
-        description: Optional[str] = "",
-        width: Optional[str] = "readable",
-        blocks: Optional["wandb.apis.reports.util.Block"] = None,
-    ) -> "wandb.apis.reports.Report":
-        if entity == "":
-            entity = self.default_entity or ""
-        if blocks is None:
-            blocks = []
-        return wandb.apis.reports.Report(
-            project, entity, title, description, width, blocks
-        ).save()
+        *,
+        run_id: Optional[str] = None,
+        project: Optional[str] = None,
+        entity: Optional[str] = None,
+    ) -> "public.Run":
+        """Create a new run.
+
+        Arguments:
+            run_id: (str, optional) The ID to assign to the run, if given.  The run ID is automatically generated by
+                default, so in general, you do not need to specify this and should only do so at your own risk.
+            project: (str, optional) If given, the project of the new run.
+            entity: (str, optional) If given, the entity of the new run.
+
+        Returns:
+            The newly created `Run`.
+        """
+        if entity is None:
+            entity = self.default_entity
+        return public.Run.create(self, run_id=run_id, project=project, entity=entity)
 
     def create_run_queue(
         self,
@@ -409,22 +421,6 @@ class Api:
             _default_resource_config=config,
         )
 
-    def load_report(self, path: str) -> "wandb.apis.reports.Report":
-        """Get report at a given path.
-
-        Arguments:
-            path: (str) Path to the target report in the form `entity/project/reports/reportId`.
-                You can get this by copy-pasting the URL after your wandb url.  For example:
-                `megatruong/report-editing/reports/My-fabulous-report-title--VmlldzoxOTc1Njk0`
-
-        Returns:
-            A `BetaReport` object which represents the report at `path`
-
-        Raises:
-            wandb.Error if path is invalid
-        """
-        return wandb.apis.reports.Report.from_url(path)
-
     def create_user(self, email, admin=False):
         """Create a new user.
 
@@ -462,15 +458,15 @@ class Api:
         return self.run("/".join([entity, project, run_id]))
 
     @property
-    def client(self):
+    def client(self) -> RetryingClient:
         return self._client
 
     @property
-    def user_agent(self):
-        return "W&B Public Client %s" % wandb.__version__
+    def user_agent(self) -> str:
+        return "W&B Public Client {}".format(wandb.__version__)
 
     @property
-    def api_key(self):
+    def api_key(self) -> Optional[str]:
         # just use thread local api key if it's set
         if _thread_local_api_settings.api_key:
             return _thread_local_api_settings.api_key
@@ -487,14 +483,14 @@ class Api:
         return key
 
     @property
-    def default_entity(self):
+    def default_entity(self) -> Optional[str]:
         if self._default_entity is None:
-            res = self._client.execute(self.VIEWER_QUERY)
+            res = self._client.execute(self.DEFAULT_ENTITY_QUERY)
             self._default_entity = (res.get("viewer") or {}).get("entity")
         return self._default_entity
 
     @property
-    def viewer(self):
+    def viewer(self) -> "public.User":
         if self._viewer is None:
             self._viewer = public.User(
                 self._client, self._client.execute(self.VIEWER_QUERY).get("viewer")
@@ -618,27 +614,33 @@ class Api:
         entity = self.settings["entity"] or self.default_entity
         if path is None:
             return entity, project
+
+        path, colon, alias = path.partition(":")
+        full_alias = colon + alias
+
         parts = path.split("/")
         if len(parts) > 3:
-            raise ValueError("Invalid artifact path: %s" % path)
+            raise ValueError("Invalid artifact path: {}".format(path))
         elif len(parts) == 1:
-            return entity, project, path
+            return entity, project, path + full_alias
         elif len(parts) == 2:
-            return entity, parts[0], parts[1]
+            return entity, parts[0], parts[1] + full_alias
+        parts[-1] += full_alias
         return parts
 
-    def projects(self, entity=None, per_page=200):
+    def projects(
+        self, entity: Optional[str] = None, per_page: Optional[int] = 200
+    ) -> "public.Projects":
         """Get projects for a given entity.
 
         Arguments:
-            entity: (str) Name of the entity requested.  If None, will fall back to
+            entity: (str) Name of the entity requested.  If None, will fall back to the
                 default entity passed to `Api`.  If no default entity, will raise a `ValueError`.
             per_page: (int) Sets the page size for query pagination.  None will use the default size.
                 Usually there is no reason to change this.
 
         Returns:
             A `Projects` object which is an iterable collection of `Project` objects.
-
         """
         if entity is None:
             entity = self.settings["entity"] or self.default_entity
@@ -652,19 +654,31 @@ class Api:
             )
         return self._projects[entity]
 
-    def project(self, name, entity=None):
+    def project(self, name: str, entity: Optional[str] = None) -> "public.Project":
+        """Return the `Project` with the given name (and entity, if given).
+
+        Arguments:
+            name: (str) The project name.
+            entity: (str) Name of the entity requested.  If None, will fall back to the
+                default entity passed to `Api`.  If no default entity, will raise a `ValueError`.
+
+        Returns:
+            A `Project` object.
+        """
         if entity is None:
             entity = self.settings["entity"] or self.default_entity
         return public.Project(self.client, entity, name, {})
 
-    def reports(self, path="", name=None, per_page=50):
+    def reports(
+        self, path: str = "", name: Optional[str] = None, per_page: Optional[int] = 50
+    ) -> "public.Reports":
         """Get reports for a given project path.
 
         WARNING: This api is in beta and will likely change in a future release
 
         Arguments:
             path: (str) path to project the report resides in, should be in the form: "entity/project"
-            name: (str) optional name of the report requested.
+            name: (str, optional) optional name of the report requested.
             per_page: (int) Sets the page size for query pagination.  None will use the default size.
                 Usually there is no reason to change this.
 
@@ -700,10 +714,18 @@ class Api:
         """
         return public.Team.create(self, team, admin_username)
 
-    def team(self, team):
+    def team(self, team: str) -> "public.Team":
+        """Return the matching `Team` with the given name.
+
+        Arguments:
+            team: (str) The name of the team.
+
+        Returns:
+            A `Team` object.
+        """
         return public.Team(self.client, team)
 
-    def user(self, username_or_email):
+    def user(self, username_or_email: str) -> Optional["public.User"]:
         """Return a user from a username or email address.
 
         Note: This function only works for Local Admins, if you are trying to get your own user object, please use `api.viewer`.
@@ -725,7 +747,7 @@ class Api:
             )
         return public.User(self._client, res["users"]["edges"][0]["node"])
 
-    def users(self, username_or_email):
+    def users(self, username_or_email: str) -> List["public.User"]:
         """Return all users from a partial username or email address query.
 
         Note: This function only works for Local Admins, if you are trying to get your own user object, please use `api.viewer`.
@@ -745,7 +767,7 @@ class Api:
         self,
         path: Optional[str] = None,
         filters: Optional[Dict[str, Any]] = None,
-        order: str = "-created_at",
+        order: str = "+created_at",
         per_page: int = 50,
         include_sweeps: bool = True,
     ):
@@ -800,6 +822,8 @@ class Api:
                 If you prepend order with a + order is ascending.
                 If you prepend order with a - order is descending (default).
                 The default order is run.created_at from newest to oldest.
+            per_page: (int) Sets the page size for query pagination.
+            include_sweeps: (bool) Whether to include the sweep runs in the results.
 
         Returns:
             A `Runs` object, which is an iterable collection of `Run` objects.
@@ -892,29 +916,63 @@ class Api:
         return self._sweeps[path]
 
     @normalize_exceptions
-    def artifact_types(self, project=None):
+    def artifact_types(self, project: Optional[str] = None) -> "public.ArtifactTypes":
+        """Return a collection of matching artifact types.
+
+        Arguments:
+            project: (str, optional) If given, a project name or path to filter on.
+
+        Returns:
+            An iterable `ArtifactTypes` object.
+        """
         entity, project = self._parse_project_path(project)
         return public.ArtifactTypes(self.client, entity, project)
 
     @normalize_exceptions
-    def artifact_type(self, type_name, project=None):
+    def artifact_type(
+        self, type_name: str, project: Optional[str] = None
+    ) -> "public.ArtifactType":
+        """Return the matching `ArtifactType`.
+
+        Arguments:
+            type_name: (str) The name of the artifact type to retrieve.
+            project: (str, optional) If given, a project name or path to filter on.
+
+        Returns:
+            An `ArtifactType` object.
+        """
         entity, project = self._parse_project_path(project)
         return public.ArtifactType(self.client, entity, project, type_name)
 
     @normalize_exceptions
-    def artifact_collections(self, project_name: str, type_name: str, per_page=50):
+    def artifact_collections(
+        self, project_name: str, type_name: str, per_page: Optional[int] = 50
+    ) -> "public.ArtifactCollections":
+        """Return a collection of matching artifact collections.
+
+        Arguments:
+            project_name: (str) The name of the project to filter on.
+            type_name: (str) The name of the artifact type to filter on.
+            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.
+
+        Returns:
+            An iterable `ArtifactCollections` object.
+        """
         entity, project = self._parse_project_path(project_name)
         return public.ArtifactCollections(
             self.client, entity, project, type_name, per_page=per_page
         )
 
     @normalize_exceptions
-    def artifact_collection(self, type_name: str, name: str):
+    def artifact_collection(
+        self, type_name: str, name: str
+    ) -> "public.ArtifactCollection":
         """Return a single artifact collection by type and parsing path in the form `entity/project/name`.
 
         Arguments:
+            type_name: (str) The type of artifact collection to fetch.
             name: (str) An artifact collection name. May be prefixed with entity/project.
-            type: (str) The type of artifact collection to fetch.
 
         Returns:
             An `ArtifactCollection` object.
@@ -926,14 +984,31 @@ class Api:
 
     @normalize_exceptions
     def artifact_versions(self, type_name, name, per_page=50):
-        """Deprecated, use artifacts(type_name, name) instead."""
-        wandb.termwarn(
-            "Api.artifact_versions(type_name, name) is deprecated, use Api.artifacts(type_name, name) instead."
+        """Deprecated, use `artifacts(type_name, name)` instead."""
+        deprecate(
+            field_name=Deprecated.api__artifact_versions,
+            warning_message=(
+                "Api.artifact_versions(type_name, name) is deprecated, "
+                "use Api.artifacts(type_name, name) instead."
+            ),
         )
         return self.artifacts(type_name, name, per_page=per_page)
 
     @normalize_exceptions
-    def artifacts(self, type_name, name, per_page=50):
+    def artifacts(
+        self, type_name: str, name: str, per_page: Optional[int] = 50
+    ) -> "public.Artifacts":
+        """Return an `Artifacts` collection from the given parameters.
+
+        Arguments:
+            type_name: (str) The type of artifacts to fetch.
+            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.
+
+        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
@@ -966,7 +1041,16 @@ class Api:
         return artifact
 
     @normalize_exceptions
-    def job(self, name, path=None):
+    def job(self, name: Optional[str], path: Optional[str] = None) -> "public.Job":
+        """Return a `Job` from the given parameters.
+
+        Arguments:
+            name: (str) The job name.
+            path: (str, optional) If given, the root path in which to download the job artifact.
+
+        Returns:
+            A `Job` object.
+        """
         if name is None:
             raise ValueError("You must specify name= to fetch a job.")
         elif name.count("/") != 2 or ":" not in name:
@@ -976,7 +1060,16 @@ class Api:
         return public.Job(self, name, path)
 
     @normalize_exceptions
-    def list_jobs(self, entity, project):
+    def list_jobs(self, entity: str, project: str) -> List[Dict[str, Any]]:
+        """Return a list of jobs, if any, for the given entity and project.
+
+        Arguments:
+            entity: (str) The entity for the listed job(s).
+            project: (str) The project for the listed job(s).
+
+        Returns:
+            A list of matching jobs.
+        """
         if entity is None:
             raise ValueError("Specify an entity when listing jobs")
         if project is None:
@@ -1043,3 +1136,44 @@ class Api:
             return [x["node"]["artifacts"] for x in artifacts]
         except requests.exceptions.HTTPError:
             return False
+
+    @normalize_exceptions
+    def artifact_exists(self, name: str, type: Optional[str] = None) -> bool:
+        """Return whether an artifact version exists within a specified project and entity.
+
+        Arguments:
+            name: (str) An artifact name. May be prefixed with entity/project.
+                If entity or project is not specified, it will be inferred from the override params if populated.
+                Otherwise, entity will be pulled from the user settings and project will default to "uncategorized".
+                Valid names can be in the following forms:
+                    name:version
+                    name:alias
+            type: (str, optional) The type of artifact
+
+        Returns:
+            True if the artifact version exists, False otherwise.
+        """
+        try:
+            self.artifact(name, type)
+            return True
+        except wandb.errors.CommError:
+            return False
+
+    @normalize_exceptions
+    def artifact_collection_exists(self, name: str, type: str) -> bool:
+        """Return whether an artifact collection exists within a specified project and entity.
+
+        Arguments:
+            name: (str) An artifact collection name. May be prefixed with entity/project.
+                If entity or project is not specified, it will be inferred from the override params if populated.
+                Otherwise, entity will be pulled from the user settings and project will default to "uncategorized".
+            type: (str) The type of artifact collection
+
+        Returns:
+            True if the artifact collection exists, False otherwise.
+        """
+        try:
+            self.artifact_collection(type, name)
+            return True
+        except wandb.errors.CommError:
+            return False