wandb 0.16.3__py3-none-any.whl → 0.16.5__py3-none-any.whl

wandb/sdk/artifacts/storage_policies/wandb_storage_policy.py

@@ -1,6 +1,7 @@
 """WandB storage policy."""
 import hashlib
 import math
+import os
 import shutil
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
 from urllib.parse import quote
@@ -8,12 +9,12 @@ from urllib.parse import quote
 import requests
 import urllib3
 
-from wandb.apis import InternalApi
 from wandb.errors.term import termwarn
 from wandb.sdk.artifacts.artifact_file_cache import (
     ArtifactFileCache,
     get_artifact_file_cache,
 )
+from wandb.sdk.artifacts.staging import get_staging_dir
 from wandb.sdk.artifacts.storage_handlers.azure_handler import AzureHandler
 from wandb.sdk.artifacts.storage_handlers.gcs_handler import GCSHandler
 from wandb.sdk.artifacts.storage_handlers.http_handler import HTTPHandler
@@ -28,6 +29,7 @@ from wandb.sdk.artifacts.storage_handlers.wb_local_artifact_handler import (
 from wandb.sdk.artifacts.storage_layout import StorageLayout
 from wandb.sdk.artifacts.storage_policies.register import WANDB_STORAGE_POLICY
 from wandb.sdk.artifacts.storage_policy import StoragePolicy
+from wandb.sdk.internal.internal_api import Api as InternalApi
 from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
 from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, hex_to_b64_id
 from wandb.sdk.lib.paths import FilePathStr, URIStr
@@ -60,8 +62,10 @@ class WandbStoragePolicy(StoragePolicy):
         return WANDB_STORAGE_POLICY
 
     @classmethod
-    def from_config(cls, config: Dict) -> "WandbStoragePolicy":
-        return cls(config=config)
+    def from_config(
+        cls, config: Dict, api: Optional[InternalApi] = None
+    ) -> "WandbStoragePolicy":
+        return cls(config=config, api=api)
 
     def __init__(
         self,
@@ -131,6 +135,7 @@ class WandbStoragePolicy(StoragePolicy):
         if manifest_entry._download_url is None:
             auth = None
             if not _thread_local_api_settings.cookies:
+                assert self._api.api_key is not None
                 auth = ("api", self._api.api_key)
             response = self._session.get(
                 self._file_url(self._api, artifact.entity, manifest_entry),
@@ -222,9 +227,10 @@ class WandbStoragePolicy(StoragePolicy):
                     extra_headers={
                         "content-md5": md5_b64_str,
                         "content-length": str(len(data)),
-                        "content-type": extra_headers.get("Content-Type"),
+                        "content-type": extra_headers.get("Content-Type", ""),
                     },
                 )
+                assert upload_resp is not None
                 etags.append(
                     {"partNumber": part_number, "hexMD5": upload_resp.headers["ETag"]}
                 )
@@ -311,7 +317,6 @@ class WandbStoragePolicy(StoragePolicy):
             return True
         if entry.local_path is None:
             return False
-
         extra_headers = {
             header.split(":", 1)[0]: header.split(":", 1)[1]
             for header in (resp.upload_headers or {})
@@ -333,6 +338,7 @@ class WandbStoragePolicy(StoragePolicy):
                 multipart_urls,
                 extra_headers,
             )
+            assert resp.storage_path is not None
             self._api.complete_multipart_upload_artifact(
                 artifact_id, resp.storage_path, etags, resp.upload_id
             )
@@ -389,9 +395,16 @@ class WandbStoragePolicy(StoragePolicy):
             B64MD5(entry.digest),
             entry.size if entry.size is not None else 0,
         )
-        if not hit:
-            try:
+
+        staging_dir = get_staging_dir()
+        try:
+            if not entry.skip_cache and not hit:
                 with cache_open("wb") as f, open(entry.local_path, "rb") as src:
                     shutil.copyfileobj(src, f)
-            except OSError as e:
-                termwarn(f"Failed to cache {entry.local_path}, ignoring {e}")
+            if entry.local_path.startswith(staging_dir):
+                # Delete staged files here instead of waiting till
+                # all the files are uploaded
+                os.chmod(entry.local_path, 0o600)
+                os.remove(entry.local_path)
+        except OSError as e:
+            termwarn(f"Failed to cache {entry.local_path}, ignoring {e}")

wandb/sdk/artifacts/storage_policy.py

@@ -1,6 +1,7 @@
 """Storage policy."""
 from typing import TYPE_CHECKING, Dict, Optional, Sequence, Type, Union
 
+from wandb.sdk.internal.internal_api import Api as InternalApi
 from wandb.sdk.lib.paths import FilePathStr, URIStr
 
 if TYPE_CHECKING:
@@ -25,7 +26,9 @@ class StoragePolicy:
         raise NotImplementedError
 
     @classmethod
-    def from_config(cls, config: Dict) -> "StoragePolicy":
+    def from_config(
+        cls, config: Dict, api: Optional[InternalApi] = None
+    ) -> "StoragePolicy":
         raise NotImplementedError
 
     def config(self) -> Dict:

wandb/sdk/data_types/base_types/wb_value.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 def _server_accepts_client_ids() -> bool:
-    from pkg_resources import parse_version
+    from wandb.util import parse_version
 
     # First, if we are offline, assume the backend server cannot
     # accept client IDs. Unfortunately, this is the best we can do

wandb/sdk/data_types/image.py

@@ -42,7 +42,7 @@ def _server_accepts_image_filenames() -> bool:
     max_cli_version = util._get_max_cli_version()
     if max_cli_version is None:
         return False
-    from pkg_resources import parse_version
+    from wandb.util import parse_version
 
     accepts_image_filenames: bool = parse_version("0.12.10") <= parse_version(
         max_cli_version
@@ -51,7 +51,7 @@ def _server_accepts_image_filenames() -> bool:
 
 
 def _server_accepts_artifact_path() -> bool:
-    from pkg_resources import parse_version
+    from wandb.util import parse_version
 
     target_version = "0.12.14"
     max_cli_version = util._get_max_cli_version() if not util._is_offline() else None

wandb/sdk/interface/interface.py

@@ -13,7 +13,17 @@ import os
 import sys
 import time
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Dict, Iterable, NewType, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    NewType,
+    Optional,
+    Tuple,
+    Union,
+)
 
 from wandb.proto import wandb_internal_pb2 as pb
 from wandb.proto import wandb_telemetry_pb2 as tpb
@@ -34,6 +44,7 @@ from wandb.util import (
 from ..data_types.utils import history_dict_to_json, val_to_json
 from ..lib.mailbox import MailboxHandle
 from . import summary_record as sr
+from .message_future import MessageFuture
 
 GlobStr = NewType("GlobStr", str)
 
@@ -339,6 +350,7 @@ class InterfaceBase:
                 proto_entry.ref = entry.ref
             if entry.local_path:
                 proto_entry.local_path = entry.local_path
+            proto_entry.skip_cache = entry.skip_cache
             for k, v in entry.extra.items():
                 proto_extra = proto_entry.extra.add()
                 proto_extra.key = k
@@ -452,7 +464,7 @@ class InterfaceBase:
     def _publish_use_artifact(self, proto_artifact: pb.UseArtifactRecord) -> None:
         raise NotImplementedError
 
-    def deliver_artifact(
+    def communicate_artifact(
         self,
         run: "Run",
         artifact: "Artifact",
@@ -461,7 +473,7 @@ class InterfaceBase:
         is_user_created: bool = False,
         use_after_commit: bool = False,
         finalize: bool = True,
-    ) -> MailboxHandle:
+    ) -> MessageFuture:
         proto_run = self._make_run(run)
         proto_artifact = self._make_artifact(artifact)
         proto_artifact.run_id = proto_run.run_id
@@ -478,11 +490,13 @@ class InterfaceBase:
         if history_step is not None:
             log_artifact.history_step = history_step
         log_artifact.staging_dir = get_staging_dir()
-        resp = self._deliver_artifact(log_artifact)
+        resp = self._communicate_artifact(log_artifact)
         return resp
 
     @abstractmethod
-    def _deliver_artifact(self, log_artifact: pb.LogArtifactRequest) -> MailboxHandle:
+    def _communicate_artifact(
+        self, log_artifact: pb.LogArtifactRequest
+    ) -> MessageFuture:
         raise NotImplementedError
 
     def deliver_download_artifact(
@@ -753,6 +767,36 @@ class InterfaceBase:
         run_start.run.CopyFrom(run_pb)
         return self._deliver_run_start(run_start)
 
+    def publish_launch_wandb_config_parameters(
+        self, include_paths: List[List[str]], exclude_paths: List[List[str]]
+    ):
+        """Tells the internal process to treat wandb.config fields as job inputs.
+
+        The paths provided as arguments are sequences of dictionary keys that
+        specify a path within the wandb.config. If a path is included, the
+        corresponding field will be treated as a job input. If a path is
+        excluded, the corresponding field will not be treated as a job input.
+
+        Args:
+            include_paths: paths within config to include as job inputs.
+            exclude_paths: paths within config to exclude as job inputs.
+
+        Returns:
+            None
+        """
+        config_parameters = pb.LaunchWandbConfigParametersRecord()
+        include_records = [pb.ConfigFilterPath(path=path) for path in include_paths]
+        exclude_records = [pb.ConfigFilterPath(path=path) for path in exclude_paths]
+        config_parameters.include_paths.extend(include_records)
+        config_parameters.exclude_paths.extend(exclude_records)
+        return self._publish_launch_wandb_config_parameters(config_parameters)
+
+    @abstractmethod
+    def _publish_launch_wandb_config_parameters(
+        self, config_parameters: pb.LaunchWandbConfigParametersRecord
+    ) -> None:
+        raise NotImplementedError
+
     @abstractmethod
     def _deliver_run_start(self, run_start: pb.RunStartRequest) -> MailboxHandle:
         raise NotImplementedError
@@ -868,11 +912,3 @@ class InterfaceBase:
         self, run_status: pb.RunStatusRequest
     ) -> MailboxHandle:
         raise NotImplementedError
-
-    def deliver_request_job_info(self) -> MailboxHandle:
-        job_info = pb.JobInfoRequest()
-        return self._deliver_request_job_info(job_info)
-
-    @abstractmethod
-    def _deliver_request_job_info(self, job_info: pb.JobInfoRequest) -> MailboxHandle:
-        raise NotImplementedError

wandb/sdk/interface/interface_shared.py

@@ -145,7 +145,6 @@ class InterfaceShared(InterfaceBase):
         cancel: Optional[pb.CancelRequest] = None,
         summary_record: Optional[pb.SummaryRecordRequest] = None,
         telemetry_record: Optional[pb.TelemetryRecordRequest] = None,
-        job_info: Optional[pb.JobInfoRequest] = None,
         get_system_metrics: Optional[pb.GetSystemMetricsRequest] = None,
         python_packages: Optional[pb.PythonPackagesRequest] = None,
     ) -> pb.Record:
@@ -202,8 +201,6 @@ class InterfaceShared(InterfaceBase):
             request.summary_record.CopyFrom(summary_record)
         elif telemetry_record:
             request.telemetry_record.CopyFrom(telemetry_record)
-        elif job_info:
-            request.job_info.CopyFrom(job_info)
         elif get_system_metrics:
             request.get_system_metrics.CopyFrom(get_system_metrics)
         elif sync:
@@ -242,6 +239,9 @@ class InterfaceShared(InterfaceBase):
         use_artifact: Optional[pb.UseArtifactRecord] = None,
         output: Optional[pb.OutputRecord] = None,
         output_raw: Optional[pb.OutputRawRecord] = None,
+        launch_wandb_config_parameters: Optional[
+            pb.LaunchWandbConfigParametersRecord
+        ] = None,
     ) -> pb.Record:
         record = pb.Record()
         if run:
@@ -286,6 +286,8 @@ class InterfaceShared(InterfaceBase):
             record.output.CopyFrom(output)
         elif output_raw:
             record.output_raw.CopyFrom(output_raw)
+        elif launch_wandb_config_parameters:
+            record.wandb_config_parameters.CopyFrom(launch_wandb_config_parameters)
         else:
             raise Exception("Invalid record")
         return record
@@ -389,17 +391,17 @@ class InterfaceShared(InterfaceBase):
         rec = self._make_record(files=files)
         self._publish(rec)
 
-    def _publish_link_artifact(self, link_artifact: pb.LinkArtifactRecord) -> None:
+    def _publish_link_artifact(self, link_artifact: pb.LinkArtifactRecord) -> Any:
         rec = self._make_record(link_artifact=link_artifact)
         self._publish(rec)
 
-    def _publish_use_artifact(self, use_artifact: pb.UseArtifactRecord) -> None:
+    def _publish_use_artifact(self, use_artifact: pb.UseArtifactRecord) -> Any:
         rec = self._make_record(use_artifact=use_artifact)
         self._publish(rec)
 
-    def _deliver_artifact(self, log_artifact: pb.LogArtifactRequest) -> MailboxHandle:
+    def _communicate_artifact(self, log_artifact: pb.LogArtifactRequest) -> Any:
         rec = self._make_request(log_artifact=log_artifact)
-        return self._deliver_record(rec)
+        return self._communicate_async(rec)
 
     def _deliver_download_artifact(
         self, download_artifact: pb.DownloadArtifactRequest
@@ -415,6 +417,14 @@ class InterfaceShared(InterfaceBase):
         rec = self._make_record(alert=proto_alert)
         self._publish(rec)
 
+    def _publish_launch_wandb_config_parameters(
+        self, launch_wandb_config_parameters: pb.LaunchWandbConfigParametersRecord
+    ) -> None:
+        rec = self._make_record(
+            launch_wandb_config_parameters=launch_wandb_config_parameters
+        )
+        self._publish(rec)
+
     def _communicate_status(
         self, status: pb.StatusRequest
     ) -> Optional[pb.StatusResponse]:
@@ -523,10 +533,6 @@ class InterfaceShared(InterfaceBase):
         record = self._make_request(run_status=run_status)
         return self._deliver_record(record)
 
-    def _deliver_request_job_info(self, job_info: pb.JobInfoRequest) -> MailboxHandle:
-        record = self._make_request(job_info=job_info)
-        return self._deliver_record(record)
-
     def _transport_keepalive_failed(self, keepalive_interval: int = 5) -> bool:
         if self._transport_failed:
             return True

wandb/sdk/internal/file_stream.py

@@ -1,6 +1,7 @@
 import base64
 import functools
 import itertools
+import json
 import logging
 import os
 import queue
@@ -58,6 +59,7 @@ class Chunk(NamedTuple):
 class DefaultFilePolicy:
     def __init__(self, start_chunk_id: int = 0) -> None:
         self._chunk_id = start_chunk_id
+        self.has_debug_log = False
 
     def process_chunks(
         self, chunks: List[Chunk]
@@ -66,6 +68,21 @@ class DefaultFilePolicy:
         self._chunk_id += len(chunks)
         return {"offset": chunk_id, "content": [c.data for c in chunks]}
 
+    # TODO: this is very inefficient, this is meant for temporary debugging and will be removed in future releases
+    def _debug_log(self, data: Any):
+        if self.has_debug_log or not os.environ.get("WANDB_DEBUG_FILESTREAM_LOG"):
+            return
+
+        loaded = json.loads(data)
+        if not isinstance(loaded, dict):
+            return
+
+        # get key size and convert to MB
+        key_sizes = [(k, len(json.dumps(v))) for k, v in loaded.items()]
+        key_msg = [f"{k}: {v/1048576:.5f} MB" for k, v in key_sizes]
+        wandb.termerror(f"Step: {loaded['_step']} | {key_msg}", repeat=False)
+        self.has_debug_log = True
+
 
 class JsonlFilePolicy(DefaultFilePolicy):
     def process_chunks(self, chunks: List[Chunk]) -> "ProcessedChunk":
@@ -81,6 +98,7 @@ class JsonlFilePolicy(DefaultFilePolicy):
                 )
                 wandb.termerror(msg, repeat=False)
                 wandb._sentry.message(msg, repeat=False)
+                self._debug_log(chunk.data)
             else:
                 chunk_data.append(chunk.data)
 
@@ -99,6 +117,7 @@ class SummaryFilePolicy(DefaultFilePolicy):
             )
             wandb.termerror(msg, repeat=False)
             wandb._sentry.message(msg, repeat=False)
+            self._debug_log(data)
             return False
         return {"offset": 0, "content": [data]}
 
@@ -274,7 +293,7 @@ class CRDedupeFilePolicy(DefaultFilePolicy):
         ret = []
         for a, b in intervals:
             processed_chunk: ProcessedChunk = {
-                "offset": a,
+                "offset": self._chunk_id + a,
                 "content": [console[i] for i in range(a, b + 1)],
             }
             ret.append(processed_chunk)

wandb/sdk/internal/handler.py

@@ -689,7 +689,7 @@ class HandleManager:
             self._settings, interface=self._interface, run_proto=run_start.run
         )
 
-        if run_start.run.resumed:
+        if run_start.run.resumed or run_start.run.forked:
             self._step = run_start.run.starting_step
         result = proto_util._result_from_record(record)
         self._respond_result(result)
@@ -862,9 +862,6 @@ class HandleManager:
         self._respond_result(result)
         self._stopped.set()
 
-    def handle_request_job_info(self, record: Record) -> None:
-        self._dispatch_record(record, always_send=True)
-
     def finish(self) -> None:
         logger.info("shutting down handler")
         if self._system_monitor is not None:

wandb/sdk/internal/internal_api.py

@@ -2150,6 +2150,7 @@ class Api:
                             name
                         }
                     }
+                    historyLineCount
                 }
                 inserted
                 _Server_Settings_
@@ -2237,6 +2238,7 @@ class Api:
                 .get("serverSettings", {})
                 .get("serverMessages", [])
             )
+
         return (
             response["upsertBucket"]["bucket"],
             response["upsertBucket"]["inserted"],
@@ -3720,7 +3722,7 @@ class Api:
         artifact_id: str,
         storage_path: str,
         completed_parts: List[Dict[str, Any]],
-        upload_id: str,
+        upload_id: Optional[str],
         complete_multipart_action: str = "Complete",
     ) -> Optional[str]:
         mutation = gql(

wandb/sdk/internal/job_builder.py

@@ -4,7 +4,7 @@ import logging
 import os
 import re
 import sys
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
 
 import wandb
 from wandb.sdk.artifacts.artifact import Artifact
@@ -28,6 +28,8 @@ FROZEN_REQUIREMENTS_FNAME = "requirements.frozen.txt"
 JOB_FNAME = "wandb-job.json"
 JOB_ARTIFACT_TYPE = "job"
 
+LOG_LEVEL = Literal["log", "warn", "error"]
+
 
 class GitInfo(TypedDict):
     remote: str
@@ -89,8 +91,9 @@ class JobBuilder:
     _job_seq_id: Optional[str]
     _job_version_alias: Optional[str]
     _is_notebook_run: bool
+    _verbose: bool
 
-    def __init__(self, settings: SettingsStatic):
+    def __init__(self, settings: SettingsStatic, verbose: bool = False):
         self._settings = settings
         self._metadatafile_path = None
         self._requirements_path = None
@@ -106,6 +109,7 @@ class JobBuilder:
             Literal["repo", "artifact", "image"]
         ] = settings.job_source  # type: ignore[assignment]
         self._is_notebook_run = self._get_is_notebook_run()
+        self._verbose = verbose
 
     def set_config(self, config: Dict[str, Any]) -> None:
         self._config = config
@@ -121,7 +125,9 @@ class JobBuilder:
     def disable(self, val: bool) -> None:
         self._disable = val
 
-    def _handle_server_artifact(self, res: Dict, artifact: "ArtifactRecord") -> None:
+    def _handle_server_artifact(
+        self, res: Optional[Dict], artifact: "ArtifactRecord"
+    ) -> None:
         if artifact.type == "job" and res is not None:
             try:
                 if res["artifactSequence"]["latestArtifact"] is None:
@@ -135,7 +141,7 @@ class JobBuilder:
                 self._job_seq_id = res["artifactSequence"]["id"]
             except KeyError as e:
                 _logger.info(f"Malformed response from ArtifactSaver.save {e}")
-        if artifact.type == "code" and "id" in res:
+        if artifact.type == "code" and res is not None:
             self._logged_code_artifact = ArtifactInfoForJob(
                 {
                     "id": res["id"],
@@ -195,6 +201,21 @@ class JobBuilder:
 
         return source, name
 
+    def _log_if_verbose(self, message: str, level: LOG_LEVEL) -> None:
+        log_func: Optional[Union[Callable[[Any], None], Callable[[Any], None]]] = None
+        if level == "log":
+            _logger.info(message)
+            log_func = wandb.termlog
+        elif level == "warn":
+            _logger.warning(message)
+            log_func = wandb.termwarn
+        elif level == "error":
+            _logger.error(message)
+            log_func = wandb.termerror
+
+        if self._verbose and log_func is not None:
+            log_func(message)
+
     def _build_artifact_job_source(
         self,
         program_relpath: str,
@@ -210,8 +231,9 @@ class JobBuilder:
                 # at the directory the notebook is in instead of the jupyter core
                 if not os.path.exists(os.path.basename(program_relpath)):
                     _logger.info("target path does not exist, exiting")
-                    wandb.termwarn(
-                        "No program path found when generating artifact job source for a non-colab notebook run. See https://docs.wandb.ai/guides/launch/create-job"
+                    self._log_if_verbose(
+                        "No program path found when generating artifact job source for a non-colab notebook run. See https://docs.wandb.ai/guides/launch/create-job",
+                        "warn",
                     )
                     return None, None
                 full_program_relpath = os.path.basename(program_relpath)
@@ -297,22 +319,25 @@ class JobBuilder:
         if not os.path.exists(
             os.path.join(self._settings.files_dir, REQUIREMENTS_FNAME)
         ):
-            wandb.termwarn(
-                "No requirements.txt found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job"
+            self._log_if_verbose(
+                "No requirements.txt found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "warn",
             )
             return None
         metadata = self._handle_metadata_file()
         if metadata is None:
-            wandb.termwarn(
-                f"Ensure read and write access to run files dir: {self._settings.files_dir}, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables"
+            self._log_if_verbose(
+                f"Ensure read and write access to run files dir: {self._settings.files_dir}, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables",
+                "warn",
             )
             return None
 
         runtime: Optional[str] = metadata.get("python")
         # can't build a job without a python version
         if runtime is None:
-            wandb.termwarn(
-                "No python version found in metadata, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job"
+            self._log_if_verbose(
+                "No python version found in metadata, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "warn",
             )
             return None
 
@@ -343,13 +368,16 @@ class JobBuilder:
                     or self._settings.job_source
                     or self._source_type
                 ):
-                    wandb.termwarn("No source type found, not creating job artifact")
+                    self._log_if_verbose(
+                        "No source type found, not creating job artifact", "warn"
+                    )
                 return None
 
             program_relpath = self._get_program_relpath(source_type, metadata)
             if source_type != "image" and not program_relpath:
-                wandb.termwarn(
-                    "No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job"
+                self._log_if_verbose(
+                    "No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                    "warn",
                 )
                 return None
 
@@ -375,10 +403,11 @@ class JobBuilder:
 
             if source is None:
                 if source_type:
-                    wandb.termwarn(
+                    self._log_if_verbose(
                         f"Source type is set to '{source_type}' but some required information is missing "
                         "from the environment. A job will not be created from this run. See "
-                        "https://docs.wandb.ai/guides/launch/create-job"
+                        "https://docs.wandb.ai/guides/launch/create-job",
+                        "warn",
                     )
                 return None
 
@@ -445,8 +474,9 @@ class JobBuilder:
             program = metadata.get("program")
 
             if not program:
-                wandb.termwarn(
-                    "Notebook 'program' path not found in metadata. See https://docs.wandb.ai/guides/launch/create-job"
+                self._log_if_verbose(
+                    "Notebook 'program' path not found in metadata. See https://docs.wandb.ai/guides/launch/create-job",
+                    "warn",
                 )
 
             return program

wandb/sdk/internal/profiler.py

@@ -52,7 +52,7 @@ def torch_trace_handler():
             prof.step()
     ```
     """
-    from pkg_resources import parse_version
+    from wandb.util import parse_version
 
     torch = wandb.util.get_module(PYTORCH_MODULE, required=True)
     torch_profiler = wandb.util.get_module(PYTORCH_PROFILER_MODULE, required=True)