wandb 0.19.1__py3-none-win32.whl → 0.19.2__py3-none-win32.whl

wandb/sdk/artifacts/artifact.py

@@ -1685,11 +1685,7 @@ class Artifact:
         from wandb.sdk.backend.backend import Backend
 
         if wandb.run is None:
-            # ensure wandb-core is up and running
-            from wandb.sdk import wandb_setup
-
-            wl = wandb_setup.setup()
-            assert wl is not None
+            wl = wandb.setup()
 
             stream_id = generate_id()
 
@@ -1702,9 +1698,7 @@ class Artifact:
             settings.files_dir.value = str(tmp_dir / "files")
             settings.run_id.value = stream_id
 
-            service = wl.service
-            assert service
-
+            service = wl.ensure_service()
             service.inform_init(settings=settings, run_id=stream_id)
 
             mailbox = Mailbox()
@@ -1941,7 +1935,7 @@ class Artifact:
             else:
                 ref_count += 1
         if ref_count > 0:
-            print("Warning: skipped verification of {} refs".format(ref_count))
+            termwarn(f"skipped verification of {ref_count} refs")
 
     @ensure_logged
     def file(self, root: str | None = None) -> StrPath:

wandb/sdk/backend/backend.py

@@ -145,7 +145,7 @@ class Backend:
             return
 
         assert self._settings
-        settings = self._settings.copy()
+        settings = self._settings.model_copy()
         settings.x_log_level = self._log_level or logging.DEBUG
 
         start_method = settings.start_method

wandb/sdk/data_types/base_types/wb_value.py

@@ -135,7 +135,7 @@ class WBValue:
     def init_from_json(
         json_obj: dict, source_artifact: "Artifact"
     ) -> Optional["WBValue"]:
-        """Initialize a `WBValue` from a JSON blob based on the class that creatd it.
+        """Initialize a `WBValue` from a JSON blob based on the class that created it.
 
         Looks through all subclasses and tries to match the json obj with the class
         which created it. It will then call that subclass' `from_json` method.

wandb/sdk/data_types/graph.py

@@ -311,9 +311,9 @@ class Graph(Media):
 
     def pprint(self):
         for edge in self.edges:
-            pprint.pprint(edge.attributes)
+            pprint.pprint(edge.attributes)  # noqa: T203
         for node in self.nodes:
-            pprint.pprint(node.attributes)
+            pprint.pprint(node.attributes)  # noqa: T203
 
     def add_node(self, node=None, **node_kwargs):
         if node is None:

wandb/sdk/data_types/saved_model.py

@@ -231,7 +231,7 @@ class _SavedModel(WBValue, Generic[SavedModelObjType]):
             return cls(obj_or_path, **kwargs)
         except Exception as e:
             if DEBUG_MODE:
-                print(f"{cls}._maybe_init({obj_or_path}) failed: {e}")
+                print(f"{cls}._maybe_init({obj_or_path}) failed: {e}")  # noqa: T201
 
         for child_cls in cls.__subclasses__():
             maybe_instance = child_cls._maybe_init(obj_or_path, **kwargs)

wandb/sdk/data_types/video.py

@@ -212,7 +212,7 @@ class Video(BatchableMedia):
         )
         if video.ndim < 4:
             raise ValueError(
-                "Video must be atleast 4 dimensions: time, channels, height, width"
+                "Video must be at least 4 dimensions: time, channels, height, width"
             )
         if video.ndim == 4:
             video = video.reshape(1, *video.shape)

wandb/sdk/interface/interface.py

@@ -216,6 +216,13 @@ class InterfaceBase:
     def _publish_config(self, cfg: pb.ConfigRecord) -> None:
         raise NotImplementedError
 
+    def publish_metadata(self, metadata: pb.MetadataRequest) -> None:
+        self._publish_metadata(metadata)
+
+    @abstractmethod
+    def _publish_metadata(self, metadata: pb.MetadataRequest) -> None:
+        raise NotImplementedError
+
     @abstractmethod
     def _publish_metric(self, metric: pb.MetricRecord) -> None:
         raise NotImplementedError
@@ -722,7 +729,7 @@ class InterfaceBase:
             otype = pb.OutputRecord.OutputType.STDERR
         else:
             # TODO(jhr): throw error?
-            print("unknown type")
+            termwarn("unknown type")
         o = pb.OutputRecord(output_type=otype, line=data)
         o.timestamp.GetCurrentTime()
         self._publish_output(o)
@@ -742,7 +749,7 @@ class InterfaceBase:
             otype = pb.OutputRawRecord.OutputType.STDERR
         else:
             # TODO(jhr): throw error?
-            print("unknown type")
+            termwarn("unknown type")
         o = pb.OutputRawRecord(output_type=otype, line=data)
         o.timestamp.GetCurrentTime()
         self._publish_output_raw(o)
@@ -872,31 +879,14 @@ class InterfaceBase:
         run_record = self._make_run(run)
         return self._deliver_run(run_record)
 
-    def deliver_sync(
+    def deliver_finish_sync(
         self,
-        start_offset: int,
-        final_offset: int,
-        entity: Optional[str] = None,
-        project: Optional[str] = None,
-        run_id: Optional[str] = None,
-        skip_output_raw: Optional[bool] = None,
     ) -> MailboxHandle:
-        sync = pb.SyncRequest(
-            start_offset=start_offset,
-            final_offset=final_offset,
-        )
-        if entity:
-            sync.overwrite.entity = entity
-        if project:
-            sync.overwrite.project = project
-        if run_id:
-            sync.overwrite.run_id = run_id
-        if skip_output_raw:
-            sync.skip.output_raw = skip_output_raw
-        return self._deliver_sync(sync)
+        sync = pb.SyncFinishRequest()
+        return self._deliver_finish_sync(sync)
 
     @abstractmethod
-    def _deliver_sync(self, sync: pb.SyncRequest) -> MailboxHandle:
+    def _deliver_finish_sync(self, sync: pb.SyncFinishRequest) -> MailboxHandle:
         raise NotImplementedError
 
     @abstractmethod
@@ -954,8 +944,8 @@ class InterfaceBase:
         raise NotImplementedError
 
     def deliver_get_system_metrics(self) -> MailboxHandle:
-        get_summary = pb.GetSystemMetricsRequest()
-        return self._deliver_get_system_metrics(get_summary)
+        get_system_metrics = pb.GetSystemMetricsRequest()
+        return self._deliver_get_system_metrics(get_system_metrics)
 
     @abstractmethod
     def _deliver_get_system_metrics(
@@ -963,6 +953,16 @@ class InterfaceBase:
     ) -> MailboxHandle:
         raise NotImplementedError
 
+    def deliver_get_system_metadata(self) -> MailboxHandle:
+        get_system_metadata = pb.GetSystemMetadataRequest()
+        return self._deliver_get_system_metadata(get_system_metadata)
+
+    @abstractmethod
+    def _deliver_get_system_metadata(
+        self, get_system_metadata: pb.GetSystemMetadataRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
     def deliver_exit(self, exit_code: Optional[int]) -> MailboxHandle:
         exit_data = self._make_exit(exit_code)
         return self._deliver_exit(exit_data)

wandb/sdk/interface/interface_shared.py

@@ -145,15 +145,17 @@ class InterfaceShared(InterfaceBase):
         run_status: Optional[pb.RunStatusRequest] = None,
         sender_mark: Optional[pb.SenderMarkRequest] = None,
         sender_read: Optional[pb.SenderReadRequest] = None,
-        sync: Optional[pb.SyncRequest] = None,
+        sync_finish: Optional[pb.SyncFinishRequest] = None,
         status_report: Optional[pb.StatusReportRequest] = None,
         cancel: Optional[pb.CancelRequest] = None,
         summary_record: Optional[pb.SummaryRecordRequest] = None,
         telemetry_record: Optional[pb.TelemetryRecordRequest] = None,
         get_system_metrics: Optional[pb.GetSystemMetricsRequest] = None,
+        get_system_metadata: Optional[pb.GetSystemMetadataRequest] = None,
         python_packages: Optional[pb.PythonPackagesRequest] = None,
         job_input: Optional[pb.JobInputRequest] = None,
         run_finish_without_exit: Optional[pb.RunFinishWithoutExitRequest] = None,
+        metadata: Optional[pb.MetadataRequest] = None,
     ) -> pb.Record:
         request = pb.Request()
         if login:
@@ -212,14 +214,18 @@ class InterfaceShared(InterfaceBase):
             request.telemetry_record.CopyFrom(telemetry_record)
         elif get_system_metrics:
             request.get_system_metrics.CopyFrom(get_system_metrics)
-        elif sync:
-            request.sync.CopyFrom(sync)
+        elif get_system_metadata:
+            request.get_system_metadata.CopyFrom(get_system_metadata)
+        elif sync_finish:
+            request.sync_finish.CopyFrom(sync_finish)
         elif python_packages:
             request.python_packages.CopyFrom(python_packages)
         elif job_input:
             request.job_input.CopyFrom(job_input)
         elif run_finish_without_exit:
             request.run_finish_without_exit.CopyFrom(run_finish_without_exit)
+        elif metadata:
+            request.metadata.CopyFrom(metadata)
         else:
             raise Exception("Invalid request")
         record = self._make_record(request=request)
@@ -377,6 +383,10 @@ class InterfaceShared(InterfaceBase):
         rec = self._make_record(summary=summary)
         self._publish(rec)
 
+    def _publish_metadata(self, metadata: pb.MetadataRequest) -> None:
+        rec = self._make_request(metadata=metadata)
+        self._publish(rec)
+
     def _publish_metric(self, metric: pb.MetricRecord) -> None:
         rec = self._make_record(metric=metric)
         self._publish(rec)
@@ -459,8 +469,8 @@ class InterfaceShared(InterfaceBase):
         record = self._make_record(run=run)
         return self._deliver_record(record)
 
-    def _deliver_sync(self, sync: pb.SyncRequest) -> MailboxHandle:
-        record = self._make_request(sync=sync)
+    def _deliver_finish_sync(self, sync_finish: pb.SyncFinishRequest) -> MailboxHandle:
+        record = self._make_request(sync_finish=sync_finish)
         return self._deliver_record(record)
 
     def _deliver_run_start(self, run_start: pb.RunStartRequest) -> MailboxHandle:
@@ -477,6 +487,12 @@ class InterfaceShared(InterfaceBase):
         record = self._make_request(get_system_metrics=get_system_metrics)
         return self._deliver_record(record)
 
+    def _deliver_get_system_metadata(
+        self, get_system_metadata: pb.GetSystemMetadataRequest
+    ) -> MailboxHandle:
+        record = self._make_request(get_system_metadata=get_system_metadata)
+        return self._deliver_record(record)
+
     def _deliver_exit(self, exit_data: pb.RunExitRecord) -> MailboxHandle:
         record = self._make_record(exit=exit_data)
         return self._deliver_record(record)

wandb/sdk/internal/handler.py

@@ -39,6 +39,7 @@ from wandb.proto.wandb_internal_pb2 import (
 
 from ..interface.interface_queue import InterfaceQueue
 from ..lib import handler_util, proto_util
+from ..wandb_metadata import Metadata
 from . import context, sample, tb_watcher
 from .settings_static import SettingsStatic
 from .system.system_monitor import SystemMonitor
@@ -119,6 +120,7 @@ class HandleManager:
 
         self._tb_watcher = None
         self._system_monitor = None
+        self._metadata: Optional[Metadata] = None
         self._step = 0
 
         self._track_time = None
@@ -176,6 +178,9 @@ class HandleManager:
     def handle_request_cancel(self, record: Record) -> None:
         self._dispatch_record(record)
 
+    def handle_request_metadata(self, record: Record) -> None:
+        logger.warning("Metadata updates are ignored when using the legacy service.")
+
     def handle_request_defer(self, record: Record) -> None:
         defer = record.request.defer
         state = defer.state
@@ -700,7 +705,10 @@ class HandleManager:
             not (self._settings.x_disable_meta or self._settings.x_disable_machine_info)
             and not run_start.run.resumed
         ):
-            self._system_monitor.probe(publish=True)
+            try:
+                self._metadata = Metadata(**self._system_monitor.probe(publish=True))
+            except Exception as e:
+                logger.error("Error probing system metadata: %s", e)
 
         self._tb_watcher = tb_watcher.TBWatcher(
             self._settings, interface=self._interface, run_proto=run_start.run
@@ -778,6 +786,16 @@ class HandleManager:
 
         self._respond_result(result)
 
+    def handle_request_get_system_metadata(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        if self._system_monitor is None or self._metadata is None:
+            return
+
+        result.response.get_system_metadata_response.metadata.CopyFrom(
+            self._metadata.to_proto()
+        )
+        self._respond_result(result)
+
     def handle_tbrecord(self, record: Record) -> None:
         logger.info("handling tbrecord: %s", record)
         if self._tb_watcher:

wandb/sdk/internal/internal.py

@@ -165,7 +165,7 @@ def wandb_internal(
         exc_info = thread.get_exception()
         if exc_info:
             logger.error(f"Thread {thread.name}:", exc_info=exc_info)
-            print(f"Thread {thread.name}:", file=sys.stderr)
+            print(f"Thread {thread.name}:", file=sys.stderr)  # noqa: T201
             traceback.print_exception(*exc_info)
             wandb._sentry.exception(exc_info)
             wandb.termerror("Internal wandb error: file data was not synced")

wandb/sdk/internal/internal_api.py

@@ -400,9 +400,6 @@ class Api:
                 wandb.termerror(f"Error while calling W&B API: {error} ({response})")
             raise
 
-    def disabled(self) -> Union[str, bool]:
-        return self._settings.get(Settings.DEFAULT_SECTION, "disabled", fallback=False)  # type: ignore
-
     def set_current_run_id(self, run_id: str) -> None:
         self._current_run_id = run_id
 
@@ -2321,7 +2318,9 @@ class Api:
             "commit": commit,
             "displayName": display_name,
             "notes": notes,
-            "host": None if self.settings().get("anonymous") == "true" else host,
+            "host": None
+            if self.settings().get("anonymous") in ["allow", "must"]
+            else host,
             "debug": env.is_debug(env=self._environ),
             "repo": repo,
             "program": program_path,
@@ -3468,7 +3467,7 @@ class Api:
                     else open(normal_name, "rb")
                 )
             except OSError:
-                print(f"{file_name} does not exist")
+                print(f"{file_name} does not exist")  # noqa: T201
                 continue
             if progress is False:
                 responses.append(

wandb/sdk/internal/sample.py

@@ -30,11 +30,11 @@ class UniformSampleAccumulator:
         self._log2 += [int(math.log(i, 2)) for i in range(1, 2**self._buckets + 1)]
 
     def _show(self):
-        print("=" * 20)
+        print("=" * 20)  # noqa: T201
         for b in range(self._buckets):
             b = (b + self._buckets_index) % self._buckets
             vals = [self._bucket[b][i] for i in range(self._index[b])]
-            print(f"{b}: {vals}")
+            print(f"{b}: {vals}")  # noqa: T201
 
     def add(self, val):
         self._count += 1

wandb/sdk/internal/sender.py

@@ -323,7 +323,6 @@ class SendManager:
 
         Exclusively used in `sync.py`.
         """
-        print(root_dir)
         files_dir = os.path.join(root_dir, "files")
         settings = wandb.Settings(
             x_files_dir=files_dir,
@@ -1339,7 +1338,7 @@ class SendManager:
         if not line.endswith("\n"):
             self._partial_output.setdefault(stream, "")
             if line.startswith("\r"):
-                # TODO: maybe we shouldnt just drop this, what if there was some \ns in the partial
+                # TODO: maybe we shouldn't just drop this, what if there was some \ns in the partial
                 # that should probably be the check instead of not line.endswith(\n")
                 # logger.info(f"Dropping data {self._partial_output[stream]}")
                 self._partial_output[stream] = ""

wandb/sdk/internal/settings_static.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Any, Iterable
 
 from wandb.proto import wandb_settings_pb2
@@ -78,7 +80,7 @@ class SettingsStatic(Settings):
     def __setitem__(self, key: str, val: object) -> None:
         raise AttributeError("Error: SettingsStatic is a readonly object")
 
-    def keys(self) -> "Iterable[str]":
+    def keys(self) -> Iterable[str]:
         return self.__dict__.keys()
 
     def __getitem__(self, key: str) -> Any:

wandb/sdk/internal/system/assets/disk.py

@@ -190,10 +190,10 @@ class Disk:
         disk_metrics = {}
         for disk_path in disk_paths:
             try:
-                # total disk space in GB:
-                total = psutil.disk_usage(disk_path).total / 1024 / 1024 / 1024
-                # total disk space used in GB:
-                used = psutil.disk_usage(disk_path).used / 1024 / 1024 / 1024
+                # total disk space in Bytes:
+                total = psutil.disk_usage(disk_path).total
+                # total disk space used in Bytes:
+                used = psutil.disk_usage(disk_path).used
                 disk_metrics[disk_path] = {
                     "total": total,
                     "used": used,

wandb/sdk/internal/system/assets/gpu.py

@@ -32,7 +32,7 @@ def gpu_in_use_by_this_process(gpu_handle: "GPUHandle", pid: int) -> bool:
     try:
         base_process = psutil.Process(pid=pid)
     except psutil.NoSuchProcess:
-        # do not report any gpu metrics if the base process cant be found
+        # do not report any gpu metrics if the base process can't be found
         return False
 
     our_processes = base_process.children(recursive=True)

wandb/sdk/internal/system/assets/memory.py

@@ -161,6 +161,6 @@ class Memory:
         # total available memory in gigabytes
         return {
             "memory": {
-                "total": psutil.virtual_memory().total / 1024 / 1024 / 1024,
+                "total": psutil.virtual_memory().total,
             }
         }

wandb/sdk/internal/system/system_info.py

@@ -190,7 +190,7 @@ class SystemInfo:
             # get the git repo info
             data = self._probe_git(data)
 
-        if self.settings.anonymous != "true":
+        if self.settings.anonymous not in ["allow", "must"]:
             data["host"] = self.settings.host
             data["username"] = self.settings.username
             data["executable"] = sys.executable

wandb/sdk/internal/system/system_monitor.py

@@ -203,7 +203,7 @@ class SystemMonitor:
             logger.error(f"Error joining system monitor process: {e}")
         self._process = None
 
-    def probe(self, publish: bool = True) -> None:
+    def probe(self, publish: bool = True) -> dict:
         logger.info("Collecting system info")
         # collect static info about the hardware from registered assets
         hardware_info: dict = {
@@ -220,3 +220,5 @@ class SystemMonitor:
             logger.info("Publishing system info")
             self.system_info.publish(system_info)
             logger.info("Finished publishing system info")
+
+        return system_info

wandb/sdk/internal/tb_watcher.py

@@ -492,7 +492,7 @@ class TBHistory:
                     self._step, len(dropped_keys)
                 )
             )
-            print("\t" + ("\n\t".join(dropped_keys)))
+            print("\t" + ("\n\t".join(dropped_keys)))  # noqa: T201
         self._data["_step"] = self._step
         self._added.append(self._data)
         self._step += 1

wandb/sdk/launch/_project_spec.py

@@ -45,9 +45,9 @@ class LaunchSource(enum.IntEnum):
         SCHEDULER: Source is a wandb sweep scheduler command.
     """
 
-    DOCKER: int = 1
-    JOB: int = 2
-    SCHEDULER: int = 3
+    DOCKER = 1
+    JOB = 2
+    SCHEDULER = 3
 
 
 class LaunchProject:

wandb/sdk/launch/builder/abstract.py

@@ -116,7 +116,7 @@ def registry_from_uri(uri: str) -> AbstractRegistry:
     it as an AWS Elastic Container Registry. If the uri contains
     `-docker.pkg.dev`, we classify it as a Google Artifact Registry.
 
-    This function will attempt to load the approriate cloud helpers for the
+    This function will attempt to load the appropriate cloud helpers for the
 
     `https://` prefix is optional for all of the above.
 

wandb/sdk/lib/apikey.py

@@ -250,7 +250,7 @@ def write_key(
         )
 
     if anonymous:
-        api.set_setting("anonymous", "true", globally=True, persist=True)
+        api.set_setting("anonymous", "must", globally=True, persist=True)
     else:
         api.clear_setting("anonymous", globally=True, persist=True)
 
@@ -259,8 +259,7 @@ def write_key(
 
 def api_key(settings: Optional["Settings"] = None) -> Optional[str]:
     if settings is None:
-        settings = wandb.setup().settings  # type: ignore
-        assert settings is not None
+        settings = wandb.setup().settings
     if settings.api_key:
         return settings.api_key
     auth = get_netrc_auth(settings.base_url)

wandb/sdk/lib/fsm.py

@@ -93,7 +93,7 @@ class FsmStateExit(Protocol[T_FsmInputs, T_FsmContext_cov]):
     def on_exit(self, inputs: T_FsmInputs) -> T_FsmContext_cov: ...  # pragma: no cover
 
 
-# It would be nice if python provided optional protocol members, but it doesnt as described here:
+# It would be nice if python provided optional protocol members, but it does not as described here:
 #   https://peps.python.org/pep-0544/#support-optional-protocol-members
 # Until then, we can only enforce that a state at least supports one protocol interface.  This
 # unfortunately will not check the signature of other potential protocols.

wandb/sdk/lib/gitlib.py

@@ -226,7 +226,7 @@ class GitRepo:
         try:
             return self.repo.create_tag(f"wandb/{name}", message=message, force=True)
         except GitCommandError:
-            print("Failed to tag repository.")
+            logger.debug("Failed to tag repository.")
             return None
 
     def push(self, name: str) -> Any:

wandb/sdk/lib/gql_request.py

@@ -1,7 +1,7 @@
 """A simple GraphQL client for sending queries and mutations.
 
 Note: This was originally wandb/vendor/gql-0.2.0/wandb_gql/transport/requests.py
-The only substantial change is to re-use a requests.Session object.
+The only substantial change is to reuse a requests.Session object.
 """
 
 from typing import Any, Callable, Dict, Optional, Tuple, Union

wandb/sdk/lib/interrupt.py

@@ -0,0 +1,37 @@
+"""Utility to send an interrupt (Ctrl+C) signal to the main thread.
+
+This is necessary because Windows and POSIX use different models for Ctrl+C
+interrupts.
+"""
+
+import platform
+import signal
+import threading
+
+
+def interrupt_main():
+    """Interrupt the main Python thread with a SIGINT signal.
+
+    In POSIX, signal.pthread_kill() is the most reliable way to send a signal
+    to the main thread.
+
+    os.kill() is often recommended, but it isn't guaranteed to deliver the
+    signal to the main OS thread. Likewise, signal.raise_signal() delivers
+    the signal to the current thread in POSIX. The issue is that if any other
+    thread receives the signal, Python will set an internal flag and process it
+    on the main thread at the next opportunity. If the main thread is executing
+    C code or is blocked on a syscall (e.g. time.sleep(999999)) the signal
+    handler won't execute until that's done---i.e. Python won't preempt the OS
+    thread on its own.
+
+    On Windows, pthread_kill is not available and os.kill() ignores its
+    second argument and always kills the process. However,
+    signal.raise_signal() does the right thing.
+    """
+    if platform.system() == "Windows":
+        signal.raise_signal(signal.SIGINT)
+    else:
+        signal.pthread_kill(
+            threading.main_thread().ident,
+            signal.SIGINT,
+        )

wandb/sdk/lib/lazyloader.py

@@ -38,7 +38,7 @@ class LazyLoader(types.ModuleType):
 
         # Emit a warning if one was specified
         if self._warning:
-            print(self._warning)
+            print(self._warning)  # noqa: T201
             # Make sure to only warn once.
             self._warning = None
 

wandb/sdk/lib/service_connection.py

@@ -41,7 +41,7 @@ def connect_to_service(
 
 
 def _try_connect_to_existing_service() -> ServiceConnection | None:
-    """Attemps to connect to an existing service process."""
+    """Attempts to connect to an existing service process."""
     token = service_token.get_service_token()
     if not token:
         return None

wandb/sdk/lib/telemetry.py

@@ -65,7 +65,7 @@ def _parse_label_lines(lines: List[str]) -> Dict[str, str]:
         label_str = line[idx + len(_LABEL_TOKEN) :]
 
         # match identifier (first token without key=value syntax (optional)
-        # Note: Parse is fairly permissive as it doesnt enforce strict syntax
+        # Note: Parse is fairly permissive as it does not enforce strict syntax
         r = MATCH_RE.match(label_str)
         if r:
             ret["code"] = r.group("code").replace("-", "_")

wandb/sdk/service/_startup_debug.py

@@ -19,4 +19,4 @@ def is_enabled() -> bool:
 
 def print_message(message: str) -> None:
     time_now = time.time()
-    print("WANDB_STARTUP_DEBUG", time_now, message)
+    print("WANDB_STARTUP_DEBUG", time_now, message)  # noqa: T201

wandb/sdk/service/server_sock.py

@@ -4,6 +4,7 @@ import threading
 import time
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
 
+import wandb
 from wandb.proto import wandb_server_pb2 as spb
 from wandb.sdk.internal.settings_static import SettingsStatic
 
@@ -225,7 +226,7 @@ class DebugThread(threading.Thread):
         while True:
             time.sleep(30)
             for thread in threading.enumerate():
-                print(f"DEBUG: {thread.name}")
+                wandb.termwarn(f"DEBUG: {thread.name}")
 
 
 class SocketServer:
@@ -266,7 +267,7 @@ class SocketServer:
                 # socket.shutdown() is a more heavy handed approach to interrupting socket.accept()
                 # in the future we might want to consider a more graceful shutdown which would involve setting
                 # a threading Event and then initiating one last connection just to close down the thread
-                # The advantage of the heavy handed approach is that it doesnt depend on the threads functioning
+                # The advantage of the heavy handed approach is that it does not depend on the threads functioning
                 # properly, that is, if something has gone wrong, we probably want to use this hammer to shut things down
                 self._sock.shutdown(socket.SHUT_RDWR)
             except OSError: