wandb 0.19.12rc1__py3-none-win32.whl → 0.20.1__py3-none-win32.whl

wandb/cli/cli.py

@@ -20,9 +20,6 @@ import click
 import yaml
 from click.exceptions import ClickException
 
-# pycreds has a find_executable that works in windows
-from dockerpycreds.utils import find_executable
-
 import wandb
 import wandb.env
 import wandb.errors
@@ -31,6 +28,7 @@ from wandb import Config, Error, env, util, wandb_agent, wandb_sdk
 from wandb.apis import InternalApi, PublicApi
 from wandb.apis.public import RunQueue
 from wandb.errors.links import url_registry
+from wandb.sdk import wandb_setup
 from wandb.sdk.artifacts._validators import is_artifact_registry_project
 from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
 from wandb.sdk.internal.internal_api import Api as SDKInternalApi
@@ -67,6 +65,9 @@ logging.basicConfig(
 logging.basicConfig(stream=sys.stdout, level=logging.INFO)
 logger = logging.getLogger("wandb")
 
+_HAS_DOCKER = bool(shutil.which("docker"))
+_HAS_NVIDIA_DOCKER = bool(shutil.which("nvidia-docker"))
+
 # Click Contexts
 CONTEXT = {"default_map": {}}
 RUN_CONTEXT = {
@@ -104,7 +105,7 @@ def display_error(func):
         except wandb.Error as e:
             exc_type, exc_value, exc_traceback = sys.exc_info()
             lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
-            logger.error("".join(lines))
+            logger.exception("".join(lines))
             wandb.termerror(f"Find detailed error logs at: {_wandb_log_path}")
             click_exc = ClickWandbException(e)
             click_exc.orig_type = exc_type
@@ -118,9 +119,6 @@ _api = None  # caching api instance allows patching from unit tests
 
 def _get_cling_api(reset=None):
     """Get a reference to the internal api with cling settings."""
-    # TODO: move CLI to wandb-core backend
-    wandb.require("legacy-service")
-
     global _api
     if reset:
         _api = None
@@ -128,7 +126,7 @@ def _get_cling_api(reset=None):
     if _api is None:
         # TODO(jhr): make a settings object that is better for non runs.
         # only override the necessary setting
-        wandb.setup(settings=wandb.Settings(x_cli_only_mode=True))
+        wandb_setup.singleton().settings.x_cli_only_mode = True
         _api = InternalApi()
     return _api
 
@@ -195,9 +193,9 @@ def projects(entity, display=True):
     api = _get_cling_api()
     projects = api.list_projects(entity=entity)
     if len(projects) == 0:
-        message = "No projects found for {}".format(entity)
+        message = f"No projects found for {entity}"
     else:
-        message = 'Latest projects for "{}"'.format(entity)
+        message = f'Latest projects for "{entity}"'
     if display:
         click.echo(click.style(message, bold=True))
         for project in projects:
@@ -231,9 +229,6 @@ def projects(entity, display=True):
 )
 @display_error
 def login(key, host, cloud, relogin, anonymously, verify, no_offline=False):
-    # TODO: move CLI to wandb-core backend
-    wandb.require("legacy-service")
-
     # TODO: handle no_offline
     anon_mode = "must" if anonymously else "never"
 
@@ -242,12 +237,9 @@ def login(key, host, cloud, relogin, anonymously, verify, no_offline=False):
     key = key[0] if key is not None and len(key) > 0 else None
     relogin = True if key or relogin else False
 
-    wandb.setup(
-        settings=wandb.Settings(
-            x_cli_only_mode=True,
-            x_disable_viewer=relogin and not verify,
-        )
-    )
+    global_settings = wandb_setup.singleton().settings
+    global_settings.x_cli_only_mode = True
+    global_settings.x_disable_viewer = relogin and not verify
 
     wandb.login(
         anonymous=anon_mode,
@@ -421,7 +413,7 @@ def init(ctx, project, entity, reset, mode):
         """
         ).format(
             code1=click.style("import wandb", bold=True),
-            code2=click.style('wandb.init(project="{}")'.format(project), bold=True),
+            code2=click.style(f'wandb.init(project="{project}")', bold=True),
             run=click.style("python <train.py>", bold=True),
         )
     )
@@ -777,7 +769,7 @@ def sweep(
             "resume": "Resuming",
         }
         wandb.termlog(f"{ings[state]} sweep {entity}/{project}/{sweep_id}")
-        getattr(api, "{}_sweep".format(state))(sweep_id, entity=entity, project=project)
+        getattr(api, f"{state}_sweep")(sweep_id, entity=entity, project=project)
         wandb.termlog("Done.")
         return
     else:
@@ -1518,11 +1510,11 @@ def launch(
                 wandb.termerror("Launched run exited with non-zero status")
                 sys.exit(1)
         except LaunchError as e:
-            logger.error("=== %s ===", e)
+            logger.exception("An error occurred.")
             wandb._sentry.exception(e)
             sys.exit(e)
         except ExecutionError as e:
-            logger.error("=== %s ===", e)
+            logger.exception("An error occurred.")
             wandb._sentry.exception(e)
             sys.exit(e)
         except asyncio.CancelledError:
@@ -1552,7 +1544,7 @@ def launch(
 
         except Exception as e:
             wandb._sentry.exception(e)
-            raise e
+            raise
 
 
 @cli.command(
@@ -1643,7 +1635,7 @@ def launch_agent(
         _launch.create_and_run_agent(api, agent_config)
     except Exception as e:
         wandb._sentry.exception(e)
-        raise e
+        raise
 
 
 @cli.command(context_settings=CONTEXT, help="Run the W&B agent")
@@ -1721,7 +1713,7 @@ def scheduler(
         _scheduler.start()
     except Exception as e:
         wandb._sentry.exception(e)
-        raise e
+        raise
 
 
 @cli.group(help="Commands for managing and viewing W&B jobs")
@@ -1974,13 +1966,13 @@ def docker_run(ctx, docker_run_args):
 
     See `docker run --help` for more details.
     """
+    import wandb.docker
+
     api = InternalApi()
     args = list(docker_run_args)
     if len(args) > 0 and args[0] == "run":
         args.pop(0)
-    if len([a for a in args if a.startswith("--runtime")]) == 0 and find_executable(
-        "nvidia-docker"
-    ):
+    if len([a for a in args if a.startswith("--runtime")]) == 0 and _HAS_NVIDIA_DOCKER:
         args = ["--runtime", "nvidia"] + args
     #  TODO: image_from_docker_args uses heuristics to find the docker image arg, there are likely cases
     #  where this won't work
@@ -1989,13 +1981,13 @@ def docker_run(ctx, docker_run_args):
     if image:
         resolved_image = wandb.docker.image_id(image)
     if resolved_image:
-        args = ["-e", "WANDB_DOCKER={}".format(resolved_image)] + args
+        args = ["-e", f"WANDB_DOCKER={resolved_image}"] + args
     else:
         wandb.termlog(
             "Couldn't detect image argument, running command without the WANDB_DOCKER env variable"
         )
     if api.api_key:
-        args = ["-e", "WANDB_API_KEY={}".format(api.api_key)] + args
+        args = ["-e", f"WANDB_API_KEY={api.api_key}"] + args
     else:
         wandb.termlog(
             "Not logged in, run `wandb login` from the host machine to enable result logging"
@@ -2009,7 +2001,7 @@ def docker_run(ctx, docker_run_args):
 @click.argument("docker_image", required=False)
 @click.option(
     "--nvidia/--no-nvidia",
-    default=find_executable("nvidia-docker") is not None,
+    default=_HAS_NVIDIA_DOCKER,
     help="Use the nvidia runtime, defaults to nvidia if nvidia-docker is present",
 )
 @click.option(
@@ -2066,8 +2058,11 @@ def docker(
     variable to an existing docker run command, see the wandb docker-run command.
     """
     api = InternalApi()
-    if not find_executable("docker"):
+    if not _HAS_DOCKER:
         raise ClickException("Docker not installed, install it from https://docker.com")
+
+    import wandb.docker
+
     args = list(docker_run_args)
     image = docker_image or ""
     # remove run for users used to nvidia-docker
@@ -2086,17 +2081,13 @@ def docker(
     resolved_image = wandb.docker.image_id(image)
     if resolved_image is None:
         raise ClickException(
-            "Couldn't find image locally or in a registry, try running `docker pull {}`".format(
-                image
-            )
+            f"Couldn't find image locally or in a registry, try running `docker pull {image}`"
         )
     if digest:
         sys.stdout.write(resolved_image)
         exit(0)
 
-    existing = wandb.docker.shell(
-        ["ps", "-f", "ancestor={}".format(resolved_image), "-q"]
-    )
+    existing = wandb.docker.shell(["ps", "-f", f"ancestor={resolved_image}", "-q"])
     if existing:
         if click.confirm(
             "Found running container with the same image, do you want to attach?"
@@ -2110,7 +2101,7 @@ def docker(
         "-e",
         "LANG=C.UTF-8",
         "-e",
-        "WANDB_DOCKER={}".format(resolved_image),
+        f"WANDB_DOCKER={resolved_image}",
         "--ipc=host",
         "-v",
         wandb.docker.entrypoint + ":/wandb-entrypoint.sh",
@@ -2123,7 +2114,7 @@ def docker(
         #  TODO: We should default to the working directory if defined
         command.extend(["-v", cwd + ":" + dir, "-w", dir])
     if api.api_key:
-        command.extend(["-e", "WANDB_API_KEY={}".format(api.api_key)])
+        command.extend(["-e", f"WANDB_API_KEY={api.api_key}"])
     else:
         wandb.termlog(
             "Couldn't find WANDB_API_KEY, run `wandb login` to enable streaming metrics"
@@ -2131,15 +2122,13 @@ def docker(
     if jupyter:
         command.extend(["-e", "WANDB_ENSURE_JUPYTER=1", "-p", port + ":8888"])
         no_tty = True
-        cmd = "jupyter lab --no-browser --ip=0.0.0.0 --allow-root --NotebookApp.token= --notebook-dir {}".format(
-            dir
-        )
+        cmd = f"jupyter lab --no-browser --ip=0.0.0.0 --allow-root --NotebookApp.token= --notebook-dir {dir}"
     command.extend(args)
     if no_tty:
         command.extend([image, shell, "-c", cmd])
     else:
         if cmd:
-            command.extend(["-e", "WANDB_COMMAND={}".format(cmd)])
+            command.extend(["-e", f"WANDB_COMMAND={cmd}"])
         command.extend(["-it", image, shell])
         wandb.termlog("Launching docker container \U0001f6a2")
     subprocess.call(command)
@@ -2199,8 +2188,11 @@ def server():
 @display_error
 def start(ctx, port, env, daemon, upgrade, edge):
     api = InternalApi()
-    if not find_executable("docker"):
+    if not _HAS_DOCKER:
         raise ClickException("Docker not installed, install it from https://docker.com")
+
+    import wandb.docker
+
     local_image_sha = wandb.docker.image_id("wandb/local").split("wandb/local")[-1]
     registry_image_sha = wandb.docker.image_id_from_registry("wandb/local").split(
         "wandb/local"
@@ -2213,7 +2205,7 @@ def start(ctx, port, env, daemon, upgrade, edge):
                 "A new version of the W&B server is available, upgrade by calling `wandb server start --upgrade`"
             )
     running = subprocess.check_output(
-        ["docker", "ps", "--filter", "name=wandb-local", "--format", "{{.ID}}"]
+        ["docker", "ps", "--filter", "name=^wandb-local$", "--format", "{{.ID}}"]
     )
     if running != b"":
         if upgrade:
@@ -2225,7 +2217,7 @@ def start(ctx, port, env, daemon, upgrade, edge):
             exit(1)
     image = "docker.pkg.github.com/wandb/core/local" if edge else "wandb/local"
     username = getpass.getuser()
-    env_vars = ["-e", "LOCAL_USERNAME={}".format(username)]
+    env_vars = ["-e", f"LOCAL_USERNAME={username}"]
     for e in env:
         env_vars.append("-e")
         env_vars.append(e)
@@ -2259,9 +2251,7 @@ def start(ctx, port, env, daemon, upgrade, edge):
             )
             exit(1)
         else:
-            wandb.termlog(
-                "W&B server started at http://localhost:{} \U0001f680".format(port)
-            )
+            wandb.termlog(f"W&B server started at http://localhost:{port} \U0001f680")
             wandb.termlog("You can stop the server by running `wandb server stop`")
             if not api.api_key:
                 # Let the server start before potentially launching a browser
@@ -2271,7 +2261,7 @@ def start(ctx, port, env, daemon, upgrade, edge):
 
 @server.command(context_settings=RUN_CONTEXT, help="Stop a local W&B server")
 def stop():
-    if not find_executable("docker"):
+    if not _HAS_DOCKER:
         raise ClickException("Docker not installed, install it from https://docker.com")
     subprocess.call(["docker", "stop", "wandb-local"])
 
@@ -2407,7 +2397,7 @@ def get(path, root, type):
         )
         artifact = public_api.artifact(full_path, type=type)
         path = artifact.download(root=root)
-        wandb.termlog("Artifact downloaded to {}".format(path))
+        wandb.termlog(f"Artifact downloaded to {path}")
     except ValueError:
         raise ClickException("Unable to download artifact")
 
@@ -2434,12 +2424,7 @@ def ls(path, type):
             )
             latest = next(versions)
             wandb.termlog(
-                "{:<15s}{:<15s}{:>15s} {:<20s}".format(
-                    kind.type,
-                    latest.updated_at,
-                    util.to_human_size(latest.size),
-                    latest.name,
-                )
+                f"{kind.type:<15s}{latest.updated_at:<15s}{util.to_human_size(latest.size):>15s} {latest.name:<20s}"
             )
 
 
@@ -2485,17 +2470,17 @@ def pull(run, project, entity):
 
     for name in urls:
         if api.file_current(name, urls[name]["md5"]):
-            click.echo("File {} is up to date".format(name))
+            click.echo(f"File {name} is up to date")
         else:
             length, response = api.download_file(urls[name]["url"])
             # TODO: I had to add this because some versions in CI broke click.progressbar
-            sys.stdout.write("File {}\r".format(name))
+            sys.stdout.write(f"File {name}\r")
             dirname = os.path.dirname(name)
             if dirname != "":
                 filesystem.mkdir_exists_ok(dirname)
             with click.progressbar(
                 length=length,
-                label="File {}".format(name),
+                label=f"File {name}",
                 fill_char=click.style("&", fg="green"),
             ) as bar:
                 with open(name, "wb") as f:
@@ -2541,8 +2526,8 @@ def restore(ctx, run, no_git, branch, project, entity):
     )
     repo = metadata.get("git", {}).get("repo")
     image = metadata.get("docker")
-    restore_message = """`wandb restore` needs to be run from the same git repository as the original run.
-Run `git clone {}` and restore from there or pass the --no-git flag.""".format(repo)
+    restore_message = f"""`wandb restore` needs to be run from the same git repository as the original run.
+Run `git clone {repo}` and restore from there or pass the --no-git flag."""
     if no_git:
         commit = None
     elif not api.git.enabled:
@@ -2587,21 +2572,17 @@ Run `git clone {}` and restore from there or pass the --no-git flag.""".format(r
             else:
                 patch_path = None
 
-        branch_name = "wandb/{}".format(run)
+        branch_name = f"wandb/{run}"
         if branch and branch_name not in api.git.repo.branches:
             api.git.repo.git.checkout(commit, b=branch_name)
-            wandb.termlog(
-                "Created branch {}".format(click.style(branch_name, bold=True))
-            )
+            wandb.termlog(f"Created branch {click.style(branch_name, bold=True)}")
         elif branch:
             wandb.termlog(
-                "Using existing branch, run `git branch -D {}` from master for a clean checkout".format(
-                    branch_name
-                )
+                f"Using existing branch, run `git branch -D {branch_name}` from master for a clean checkout"
             )
             api.git.repo.git.checkout(branch_name)
         else:
-            wandb.termlog("Checking out {} in detached mode".format(commit))
+            wandb.termlog(f"Checking out {commit} in detached mode")
             api.git.repo.git.checkout(commit)
 
         if patch_path:
@@ -2639,7 +2620,7 @@ Run `git clone {}` and restore from there or pass the --no-git flag.""".format(r
     with open(config_path, "w") as f:
         f.write(s)
 
-    wandb.termlog("Restored config variables to {}".format(config_path))
+    wandb.termlog(f"Restored config variables to {config_path}")
     if image:
         if not metadata["program"].startswith("<") and metadata.get("args") is not None:
             # TODO: we may not want to default to python here.

wandb/docker/__init__.py

@@ -1,13 +1,11 @@
 import json
 import logging
 import os
+import shutil
 import subprocess
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-import requests
-from dockerpycreds.utils import find_executable  # type: ignore
-
-from wandb.docker import auth, www_authenticate
+from wandb.docker import names
 from wandb.errors import Error
 
 
@@ -46,7 +44,6 @@ class DockerError(Error):
 entrypoint = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), "wandb-entrypoint.sh"
 )
-auth_config = auth.load_config()
 log = logging.getLogger(__name__)
 
 
@@ -74,7 +71,7 @@ def is_buildx_installed() -> bool:
     global _buildx_installed
     if _buildx_installed is not None:
         return _buildx_installed  # type: ignore
-    if not find_executable("docker"):
+    if not shutil.which("docker"):
         _buildx_installed = False
     else:
         help_output = shell(["buildx", "--help"])
@@ -203,7 +200,7 @@ def default_image(gpu: bool = False) -> str:
     tag = "all"
     if not gpu:
         tag += "-cpu"
-    return "wandb/deepo:{}".format(tag)
+    return f"wandb/deepo:{tag}"
 
 
 def parse_repository_tag(repo_name: str) -> Tuple[str, Optional[str]]:
@@ -218,75 +215,25 @@ def parse_repository_tag(repo_name: str) -> Tuple[str, Optional[str]]:
 
 def parse(image_name: str) -> Tuple[str, str, str]:
     repository, tag = parse_repository_tag(image_name)
-    registry, repo_name = auth.resolve_repository_name(repository)
+    registry, repo_name = names.resolve_repository_name(repository)
     if registry == "docker.io":
         registry = "index.docker.io"
     return registry, repo_name, (tag or "latest")
 
 
-def auth_token(registry: str, repo: str) -> Dict[str, str]:
-    """Make a request to the root of a v2 docker registry to get the auth url.
-
-    Always returns a dictionary, if there's no token key we couldn't authenticate
-    """
-    # TODO: Cache tokens?
-    auth_info = auth_config.resolve_authconfig(registry)
-    if auth_info:
-        normalized = {k.lower(): v for k, v in auth_info.items()}
-        normalized_auth_info = (
-            normalized.get("username"),
-            normalized.get("password"),
-        )
-    else:
-        normalized_auth_info = None
-    response = requests.get(f"https://{registry}/v2/", timeout=3)
-    if response.headers.get("www-authenticate"):
-        try:
-            info: Dict = www_authenticate.parse(response.headers["www-authenticate"])
-        except ValueError:
-            info = {}
-    else:
-        log.error(
-            f"Received {response} when attempting to authenticate with {registry}"
-        )
-        info = {}
-    if info.get("bearer"):
-        res = requests.get(
-            info["bearer"]["realm"]
-            + "?service={}&scope=repository:{}:pull".format(
-                info["bearer"]["service"], repo
-            ),
-            auth=normalized_auth_info,  # type: ignore
-            timeout=3,
-        )
-        res.raise_for_status()
-        result_json: Dict[str, str] = res.json()
-        return result_json
-    return {}
+def image_id_from_registry(image_name: str) -> Optional[str]:
+    """Query the image manifest to get its full ID including the digest.
 
+    Args:
+        image_name: The image name, such as "wandb/local".
 
-def image_id_from_registry(image_name: str) -> Optional[str]:
-    """Get the docker id from a public or private registry."""
-    registry, repository, tag = parse(image_name)
-    res = None
-    try:
-        token = auth_token(registry, repository).get("token")
-        # dockerhub is crazy
-        if registry == "index.docker.io":
-            registry = "registry-1.docker.io"
-        res = requests.head(
-            f"https://{registry}/v2/{repository}/manifests/{tag}",
-            headers={
-                "Authorization": f"Bearer {token}",
-                "Accept": "application/vnd.docker.distribution.manifest.v2+json",
-            },
-            timeout=5,
-        )
-        res.raise_for_status()
-    except requests.RequestException:
-        log.error(f"Received {res} when attempting to get digest for {image_name}")
-        return None
-    return "@".join([registry + "/" + repository, res.headers["Docker-Content-Digest"]])
+    Returns:
+        The image name followed by its digest, like "wandb/local@sha256:...".
+    """
+    # https://docs.docker.com/reference/cli/docker/buildx/imagetools/inspect
+    inspect_cmd = ["buildx", "imagetools", "inspect", image_name]
+    format_args = ["--format", r"{{.Name}}@{{.Manifest.Digest}}"]
+    return shell([*inspect_cmd, *format_args])
 
 
 def image_id(image_name: str) -> Optional[str]:
@@ -295,11 +242,12 @@ def image_id(image_name: str) -> Optional[str]:
         return image_name
     else:
         digests = shell(["inspect", image_name, "--format", "{{json .RepoDigests}}"])
+
+        if digests is None:
+            return image_id_from_registry(image_name)
+
         try:
-            if digests is None:
-                raise ValueError
-            im_id: str = json.loads(digests)[0]
-            return im_id
+            return json.loads(digests)[0]
         except (ValueError, IndexError):
             return image_id_from_registry(image_name)
 
@@ -332,7 +280,6 @@ __all__ = [
     "image_id",
     "image_id_from_registry",
     "is_docker_installed",
-    "auth_token",
     "parse",
     "parse_repository_tag",
     "default_image",

wandb/docker/names.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+
+class InvalidRepositoryError(Exception):
+    """The given string is not a valid repository name."""
+
+
+def resolve_repository_name(repo_name: str) -> tuple[str, str]:
+    if "://" in repo_name:
+        raise InvalidRepositoryError(
+            f"Repository name cannot contain a scheme ({repo_name})"
+        )
+
+    index_name, remote_name = split_repo_name(repo_name)
+    if index_name[0] == "-" or index_name[-1] == "-":
+        raise InvalidRepositoryError(
+            f"Invalid index name ({index_name}). Cannot begin or end with a hyphen."
+        )
+    return resolve_index_name(index_name), remote_name
+
+
+def resolve_index_name(index_name: str) -> str:
+    index_name = convert_to_hostname(index_name)
+    if index_name == "index.docker.io":
+        index_name = "docker.io"
+    return index_name
+
+
+def split_repo_name(repo_name: str) -> tuple[str, str]:
+    parts = repo_name.split("/", 1)
+    if len(parts) == 1 or (
+        "." not in parts[0] and ":" not in parts[0] and parts[0] != "localhost"
+    ):
+        # This is a docker index repo (ex: username/foobar or ubuntu)
+        return "docker.io", repo_name
+    return parts[0], parts[1]
+
+
+def convert_to_hostname(url: str) -> str:
+    return url.replace("http://", "").replace("https://", "").split("/", 1)[0]

wandb/env.py

@@ -78,7 +78,6 @@ ARTIFACT_FETCH_FILE_URL_BATCH_SIZE = "WANDB_ARTIFACT_FETCH_FILE_URL_BATCH_SIZE"
 CACHE_DIR = "WANDB_CACHE_DIR"
 DISABLE_SSL = "WANDB_INSECURE_DISABLE_SSL"
 SERVICE = "WANDB_SERVICE"
-_DISABLE_SERVICE = "WANDB_DISABLE_SERVICE"
 SENTRY_DSN = "WANDB_SENTRY_DSN"
 INIT_TIMEOUT = "WANDB_INIT_TIMEOUT"
 GIT_COMMIT = "WANDB_GIT_COMMIT"

wandb/errors/util.py

@@ -47,7 +47,7 @@ class ProtobufErrorHandler:
             The corresponding protobuf error message.
         """
         if not isinstance(exc, Error):
-            raise ValueError("exc must be a subclass of wandb.errors.Error")
+            raise TypeError("exc must be a subclass of wandb.errors.Error")
 
         code = None
         for subclass in type(exc).__mro__:

wandb/filesync/step_checksum.py

@@ -128,7 +128,7 @@ class StepChecksum:
             elif isinstance(req, RequestFinish):
                 break
             else:
-                raise Exception("internal error")
+                raise TypeError
 
         self._output_queue.put(step_upload.RequestFinish(req.callback))
 

wandb/filesync/step_upload.py

@@ -176,7 +176,7 @@ class StepUpload:
                 self._artifacts[event.artifact_id]["pending_count"] += 1
             self._start_upload_job(event)
         else:
-            raise Exception("Programming error: unhandled event: {}".format(str(event)))
+            raise TypeError(f"Event has unexpected type: {event!s}")
 
     def _start_upload_job(self, event: RequestUpload) -> None:
         # Operations on a single backend file must be serialized. if

wandb/integration/diffusers/resolvers/multimodal.py

@@ -669,8 +669,7 @@ class DiffusersMultiModalPipelineResolver:
                 )
 
             # Return the WandB loggable dict
-            loggable_dict = self.prepare_loggable_dict(pipeline, response, kwargs)
-            return loggable_dict
+            return self.prepare_loggable_dict(pipeline, response, kwargs)
         except Exception as e:
             logger.warning(e)
         return None

wandb/integration/gym/__init__.py

@@ -9,8 +9,7 @@ _gym_version_lt_0_26: Optional[bool] = None
 _gymnasium_version_lt_1_0_0: Optional[bool] = None
 
 _required_error_msg = (
-    "Couldn't import the gymnasium python package, "
-    "install with `pip install gymnasium`"
+    "Couldn't import the gymnasium python package, install with `pip install gymnasium`"
 )
 GymLib = Literal["gym", "gymnasium"]
 
@@ -40,11 +39,11 @@ def monitor():
         else:
             import gymnasium as gym  # type: ignore
 
-        from wandb.util import parse_version
+        from packaging.version import parse
 
-        gym_lib_version = parse_version(gym.__version__)
-        _gym_version_lt_0_26 = gym_lib_version < parse_version("0.26.0")
-        _gymnasium_version_lt_1_0_0 = gym_lib_version < parse_version("1.0.0a1")
+        gym_lib_version = parse(gym.__version__)
+        _gym_version_lt_0_26 = gym_lib_version < parse("0.26.0")
+        _gymnasium_version_lt_1_0_0 = gym_lib_version < parse("1.0.0a1")
 
     path = "path"  # Default path
     if gym_lib == "gymnasium" and not _gymnasium_version_lt_1_0_0: