wandb 0.18.6__py3-none-win_amd64.whl → 0.19.0__py3-none-win_amd64.whl

wandb/sdk/data_types/base_types/wb_value.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Type, Union
 
+import wandb
 from wandb import util
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -13,16 +14,25 @@ if TYPE_CHECKING:  # pragma: no cover
 def _server_accepts_client_ids() -> bool:
     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
-    # until we are sure that all local versions are > "0.11.0" max_cli_version.
-    # The practical implication is that tables logged in offline mode
-    # will not show up in the workspace (but will still show up in artifacts). This
-    # means we never lose data, and we can still view using weave. If we decided
-    # to use client ids in offline mode, then the manifests and artifact data
-    # would never be resolvable and would lead to failed uploads. Our position
-    # is to never lose data - and instead take the tradeoff in the UI.
-    if util._is_offline():
+    # There are versions of W&B Server that cannot accept client IDs. Those versions of
+    # the backend have a max_cli_version of less than "0.11.0." If the backend cannot
+    # accept client IDs, manifests and artifact data would never be resolvable and lead
+    # to failed uploads. Our position in 2021/06/29 was to never lose data - and instead take the
+    # tradeoff in the UI. The results in tables not displaying media correctly, but
+    # the table can still be accessed via the .artifact op.
+    #
+    # The latest SDK version that is < "0.11.0" was released on 2021/06/29.
+    # AS OF NOW, 2024/11/06, we assume that all customer's server deployments accept
+    # client IDs.
+    #
+    # If there are any users with issues on an older backend, customers can disable the
+    # setting `allow_offline_artifacts` to revert the SDK's behavior back to not
+    # using client IDs in offline mode.
+    if (
+        util._is_offline()
+        and wandb.run
+        and not wandb.run.settings.allow_offline_artifacts
+    ):
         return False
 
     # If the script is online, request the max_cli_version and ensure the server

wandb/sdk/data_types/histogram.py

@@ -78,9 +78,7 @@ class Histogram(WBValue):
             self.histogram = self.histogram.tolist()
             self.bins = self.bins.tolist()
         if len(self.histogram) > self.MAX_LENGTH:
-            raise ValueError(
-                "The maximum length of a histogram is %i" % self.MAX_LENGTH
-            )
+            raise ValueError(f"The maximum length of a histogram is {self.MAX_LENGTH}")
         if len(self.histogram) + 1 != len(self.bins):
             raise ValueError("len(bins) must be len(histogram) + 1")
 

wandb/sdk/data_types/object_3d.py

@@ -2,24 +2,20 @@ import codecs
 import itertools
 import json
 import os
-import sys
 from typing import (
     TYPE_CHECKING,
     ClassVar,
+    Literal,
     Optional,
     Sequence,
     Set,
     TextIO,
     Tuple,
     Type,
+    TypedDict,
     Union,
 )
 
-if sys.version_info >= (3, 8):
-    from typing import Literal, TypedDict
-else:
-    from typing_extensions import Literal, TypedDict
-
 import wandb
 from wandb import util
 from wandb.sdk.lib import runid

wandb/sdk/data_types/table.py

@@ -490,7 +490,7 @@ class Table(Media):
                     f"the limit with `wandb.Table.MAX_ARTIFACT_ROWS = X` and try again. Note: "
                     f"this may cause slower queries in the W&B UI."
                 )
-            logging.warning("Truncating wandb.Table object to %i rows." % max_rows)
+            logging.warning(f"Truncating wandb.Table object to {max_rows} rows.")
         return {"columns": self.columns, "data": self.data[:max_rows]}
 
     def bind_to_run(self, *args, **kwargs):

wandb/sdk/data_types/utils.py

@@ -175,8 +175,7 @@ def _prune_max_seq(seq: Sequence["BatchableMedia"]) -> Sequence["BatchableMedia"
     items = seq
     if hasattr(seq[0], "MAX_ITEMS") and seq[0].MAX_ITEMS < len(seq):
         logging.warning(
-            "Only %i %s will be uploaded."
-            % (seq[0].MAX_ITEMS, seq[0].__class__.__name__)
+            f"Only {seq[0].MAX_ITEMS} {seq[0].__class__.__name__} will be uploaded."
         )
         items = seq[: seq[0].MAX_ITEMS]
     return items

wandb/sdk/data_types/video.py

@@ -138,10 +138,21 @@ class Video(BatchableMedia):
             self.encode(fps=fps)
 
     def encode(self, fps: int = 4) -> None:
-        mpy = util.get_module(
-            "moviepy.editor",
-            required='wandb.Video requires moviepy when passing raw data.  Install with "pip install wandb[media]"',
-        )
+        # Try to import ImageSequenceClip from the appropriate MoviePy module
+        mpy = None
+        try:
+            # Attempt to load moviepy.editor for MoviePy < 2.0
+            mpy = util.get_module(
+                "moviepy.editor",
+                required='wandb.Video requires moviepy when passing raw data. Install with "pip install wandb[media]"',
+            )
+        except wandb.Error:
+            # Fallback to moviepy for MoviePy >= 2.0
+            mpy = util.get_module(
+                "moviepy",
+                required='wandb.Video requires moviepy when passing raw data. Install with "pip install wandb[media]"',
+            )
+
         tensor = self._prepare_video(self.data)
         _, self._height, self._width, self._channels = tensor.shape  # type: ignore
 

wandb/sdk/integration_utils/auto_logging.py

@@ -2,20 +2,13 @@ import asyncio
 import functools
 import inspect
 import logging
-import sys
-from typing import Any, Dict, Optional, Sequence, TypeVar
+from typing import Any, Dict, Optional, Protocol, Sequence, TypeVar
 
 import wandb.sdk
 import wandb.util
 from wandb.sdk.lib import telemetry as wb_telemetry
 from wandb.sdk.lib.timer import Timer
 
-if sys.version_info >= (3, 8):
-    from typing import Protocol
-else:
-    from typing_extensions import Protocol
-
-
 logger = logging.getLogger(__name__)
 
 

wandb/sdk/interface/interface.py

@@ -11,7 +11,6 @@ InterfaceRelay: Responses are routed to a relay queue (not matching uuids)
 import gzip
 import logging
 import os
-import sys
 import time
 from abc import abstractmethod
 from pathlib import Path
@@ -22,9 +21,11 @@ from typing import (
     Dict,
     Iterable,
     List,
+    Literal,
     NewType,
     Optional,
     Tuple,
+    TypedDict,
     Union,
 )
 
@@ -54,10 +55,6 @@ MANIFEST_FILE_SIZE_THRESHOLD = 100_000
 
 GlobStr = NewType("GlobStr", str)
 
-if sys.version_info >= (3, 8):
-    from typing import Literal, TypedDict
-else:
-    from typing_extensions import Literal, TypedDict
 
 PolicyName = Literal["now", "live", "end"]
 
@@ -953,6 +950,16 @@ class InterfaceBase:
     def _deliver_poll_exit(self, poll_exit: pb.PollExitRequest) -> MailboxHandle:
         raise NotImplementedError
 
+    def deliver_finish_without_exit(self) -> MailboxHandle:
+        run_finish_without_exit = pb.RunFinishWithoutExitRequest()
+        return self._deliver_finish_without_exit(run_finish_without_exit)
+
+    @abstractmethod
+    def _deliver_finish_without_exit(
+        self, run_finish_without_exit: pb.RunFinishWithoutExitRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
     def deliver_request_sampled_history(self) -> MailboxHandle:
         sampled_history = pb.SampledHistoryRequest()
         return self._deliver_request_sampled_history(sampled_history)

wandb/sdk/interface/interface_queue.py

@@ -8,7 +8,6 @@ import logging
 from multiprocessing.process import BaseProcess
 from typing import TYPE_CHECKING, Optional
 
-from ..lib import tracelog
 from ..lib.mailbox import Mailbox
 from .interface_shared import InterfaceShared
 from .router_queue import MessageQueueRouter
@@ -37,10 +36,6 @@ class InterfaceQueue(InterfaceShared):
     ) -> None:
         self.record_q = record_q
         self.result_q = result_q
-        if self.record_q:
-            tracelog.annotate_queue(self.record_q, "record_q")
-        if self.result_q:
-            tracelog.annotate_queue(self.result_q, "result_q")
         super().__init__(process=process, process_check=process_check, mailbox=mailbox)
 
     def _init_router(self) -> None:
@@ -55,5 +50,4 @@ class InterfaceQueue(InterfaceShared):
         if local:
             record.control.local = local
         if self.record_q:
-            tracelog.log_message_queue(record, self.record_q)
             self.record_q.put(record)

wandb/sdk/interface/interface_shared.py

@@ -153,6 +153,7 @@ class InterfaceShared(InterfaceBase):
         get_system_metrics: Optional[pb.GetSystemMetricsRequest] = None,
         python_packages: Optional[pb.PythonPackagesRequest] = None,
         job_input: Optional[pb.JobInputRequest] = None,
+        run_finish_without_exit: Optional[pb.RunFinishWithoutExitRequest] = None,
     ) -> pb.Record:
         request = pb.Request()
         if login:
@@ -217,6 +218,8 @@ class InterfaceShared(InterfaceBase):
             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)
         else:
             raise Exception("Invalid request")
         record = self._make_record(request=request)
@@ -482,6 +485,12 @@ class InterfaceShared(InterfaceBase):
         record = self._make_request(poll_exit=poll_exit)
         return self._deliver_record(record)
 
+    def _deliver_finish_without_exit(
+        self, run_finish_without_exit: pb.RunFinishWithoutExitRequest
+    ) -> MailboxHandle:
+        record = self._make_request(run_finish_without_exit=run_finish_without_exit)
+        return self._deliver_record(record)
+
     def _deliver_stop_status(self, stop_status: pb.StopStatusRequest) -> MailboxHandle:
         record = self._make_request(stop_status=stop_status)
         return self._deliver_record(record)

wandb/sdk/interface/router.py

@@ -10,7 +10,7 @@ import uuid
 from abc import abstractmethod
 from typing import TYPE_CHECKING, Dict, Optional
 
-from ..lib import mailbox, tracelog
+from ..lib import mailbox
 from .message_future import MessageFuture
 
 if TYPE_CHECKING:
@@ -108,7 +108,6 @@ class MessageRouter:
             # TODO (cvp): saw this in tests, seemed benign enough to ignore, but
             # could point to other issues.
             if msg.uuid != "":
-                tracelog.log_message_assert(msg)
                 logger.warning(
                     "No listener found for msg with uuid %s (%s)", msg.uuid, msg
                 )

wandb/sdk/interface/router_queue.py

@@ -7,7 +7,6 @@ Router to manage responses from a queue.
 import queue
 from typing import TYPE_CHECKING, Optional
 
-from ..lib import tracelog
 from ..lib.mailbox import Mailbox
 from .router import MessageRouter
 
@@ -36,9 +35,7 @@ class MessageQueueRouter(MessageRouter):
             msg = self._response_queue.get(timeout=1)
         except queue.Empty:
             return None
-        tracelog.log_message_dequeue(msg, self._response_queue)
         return msg
 
     def _send_message(self, record: "pb.Record") -> None:
-        tracelog.log_message_queue(record, self._request_queue)
         self._request_queue.put(record)

wandb/sdk/interface/router_relay.py

@@ -6,7 +6,6 @@ Router to manage responses from a queue with relay.
 
 from typing import TYPE_CHECKING
 
-from ..lib import tracelog
 from ..lib.mailbox import Mailbox
 from .router_queue import MessageQueueRouter
 
@@ -33,7 +32,6 @@ class MessageRelayRouter(MessageQueueRouter):
 
     def _handle_msg_rcv(self, msg: "pb.Result") -> None:
         if msg.control.relay_id:
-            tracelog.log_message_queue(msg, self._relay_queue)
             self._relay_queue.put(msg)
             return
         super()._handle_msg_rcv(msg)

wandb/sdk/internal/file_stream.py

@@ -24,10 +24,7 @@ from typing import (
 )
 
 if TYPE_CHECKING:
-    if sys.version_info >= (3, 8):
-        from typing import TypedDict
-    else:
-        from typing_extensions import TypedDict
+    from typing import TypedDict
 
     class ProcessedChunk(TypedDict):
         offset: int

wandb/sdk/internal/flow_control.py

@@ -88,7 +88,7 @@ class FlowControl:
             or _threshold_bytes_mid == 0
             or _threshold_bytes_low == 0
         ):
-            threshold = settings._network_buffer or DEFAULT_THRESHOLD
+            threshold = settings.x_network_buffer or DEFAULT_THRESHOLD
             _threshold_bytes_high = threshold
             _threshold_bytes_mid = threshold // 2
             _threshold_bytes_low = threshold // 4

wandb/sdk/internal/handler.py

@@ -38,7 +38,7 @@ from wandb.proto.wandb_internal_pb2 import (
 )
 
 from ..interface.interface_queue import InterfaceQueue
-from ..lib import handler_util, proto_util, tracelog
+from ..lib import handler_util, proto_util
 from . import context, sample, tb_watcher
 from .settings_static import SettingsStatic
 from .system.system_monitor import SystemMonitor
@@ -163,11 +163,9 @@ class HandleManager:
     def _dispatch_record(self, record: Record, always_send: bool = False) -> None:
         if always_send:
             record.control.always_send = True
-        tracelog.log_message_queue(record, self._writer_q)
         self._writer_q.put(record)
 
     def _respond_result(self, result: Result) -> None:
-        tracelog.log_message_queue(result, self._result_q)
         context_id = context.context_id_from_result(result)
         self._context_keeper.release(context_id)
         self._result_q.put(result)
@@ -694,9 +692,14 @@ class HandleManager:
             self._settings,
             self._interface,
         )
-        if not self._settings._disable_stats:
+        if not (
+            self._settings.x_disable_stats or self._settings.x_disable_machine_info
+        ):
             self._system_monitor.start()
-        if not self._settings._disable_meta and not run_start.run.resumed:
+        if (
+            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)
 
         self._tb_watcher = tb_watcher.TBWatcher(

wandb/sdk/internal/internal.py

@@ -28,7 +28,6 @@ import psutil
 import wandb
 
 from ..interface.interface_queue import InterfaceQueue
-from ..lib import tracelog
 from . import context, handler, internal_util, sender, writer
 
 if TYPE_CHECKING:
@@ -63,7 +62,6 @@ def wandb_internal(
     """
     # mark this process as internal
     wandb._set_internal_process()  # type: ignore
-    _setup_tracelog()
     started = time.time()
 
     # any sentry events in the internal process will be tagged as such
@@ -77,7 +75,7 @@ def wandb_internal(
     # Let's make sure we don't modify settings so use a static object
     _settings = settings
     if _settings.log_internal:
-        configure_logging(_settings.log_internal, _settings._log_level)
+        configure_logging(_settings.log_internal, _settings.x_log_level)
 
     user_pid = user_pid or os.getppid()
     pid = os.getpid()
@@ -88,8 +86,6 @@ def wandb_internal(
         datetime.fromtimestamp(started),
     )
 
-    tracelog.annotate_queue(record_q, "record_q")
-    tracelog.annotate_queue(result_q, "result_q")
     publish_interface = InterfaceQueue(record_q=record_q)
 
     stopped = threading.Event()
@@ -98,10 +94,8 @@ def wandb_internal(
     context_keeper = context.ContextKeeper()
 
     send_record_q: Queue[Record] = queue.Queue()
-    tracelog.annotate_queue(send_record_q, "send_q")
 
     write_record_q: Queue[Record] = queue.Queue()
-    tracelog.annotate_queue(write_record_q, "write_q")
 
     record_sender_thread = SenderThread(
         settings=_settings,
@@ -175,7 +169,7 @@ def wandb_internal(
             traceback.print_exception(*exc_info)
             wandb._sentry.exception(exc_info)
             wandb.termerror("Internal wandb error: file data was not synced")
-            if not settings._disable_service:
+            if not settings.x_disable_service:
                 # TODO: We can make this more graceful by returning an error to streams.py
                 # and potentially just fail the one stream.
                 os._exit(-1)
@@ -184,14 +178,6 @@ def wandb_internal(
     close_internal_log()
 
 
-def _setup_tracelog() -> None:
-    # TODO: remove this temporary hack, need to find a better way to pass settings
-    # to the server.  for now lets just look at the environment variable we need
-    tracelog_mode = os.environ.get("WANDB_TRACELOG")
-    if tracelog_mode:
-        tracelog.enable(tracelog_mode)
-
-
 def configure_logging(
     log_fname: str, log_level: int, run_id: Optional[str] = None
 ) -> None:
@@ -394,7 +380,7 @@ class ProcessCheck:
         self.settings = settings
         self.pid = user_pid
         self.check_process_last = None
-        self.check_process_interval = settings._internal_check_process
+        self.check_process_interval = settings.x_internal_check_process
 
     def is_dead(self) -> bool:
         if not self.check_process_interval or not self.pid:

wandb/sdk/internal/internal_api.py

@@ -20,6 +20,7 @@ from typing import (
     Dict,
     Iterable,
     List,
+    Literal,
     Mapping,
     MutableMapping,
     NamedTuple,
@@ -30,11 +31,6 @@ from typing import (
     Union,
 )
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
 import click
 import requests
 import yaml
@@ -63,10 +59,7 @@ logger = logging.getLogger(__name__)
 LAUNCH_DEFAULT_PROJECT = "model-registry"
 
 if TYPE_CHECKING:
-    if sys.version_info >= (3, 8):
-        from typing import Literal, TypedDict
-    else:
-        from typing_extensions import Literal, TypedDict
+    from typing import Literal, TypedDict
 
     from .progress import ProgressFn
 
@@ -4557,7 +4550,7 @@ class Api:
         check_httpclient_logger_handler()
         return requests.put(
             url=url,
-            headers={"Content-Length": "0", "Content-Range": "bytes */%i" % length},
+            headers={"Content-Length": "0", "Content-Range": f"bytes */{length}"},
         )
 
     def _flatten_edges(self, response: "_Response") -> List[Dict]:

wandb/sdk/internal/internal_util.py

@@ -11,8 +11,6 @@ import threading
 import time
 from typing import TYPE_CHECKING, Optional, Tuple, Type, Union
 
-from ..lib import tracelog
-
 if TYPE_CHECKING:
     from queue import Queue
     from threading import Event
@@ -95,6 +93,5 @@ class RecordLoopThread(ExceptionThread):
                 record = self._input_record_q.get(timeout=1)
             except queue.Empty:
                 continue
-            tracelog.log_message_dequeue(record, self._input_record_q)
             self._process(record)
         self._finish()

wandb/sdk/internal/job_builder.py

@@ -5,7 +5,18 @@ import logging
 import os
 import re
 import sys
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypedDict,
+    Union,
+)
 
 import wandb
 from wandb.sdk.artifacts.artifact import Artifact
@@ -16,11 +27,6 @@ from wandb.util import make_artifact_name_safe
 
 from .settings_static import SettingsStatic
 
-if sys.version_info >= (3, 8):
-    from typing import Literal, TypedDict
-else:
-    from typing_extensions import Literal, TypedDict
-
 _logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
@@ -152,7 +158,7 @@ class JobBuilder:
         self._logged_code_artifact = None
         self._job_seq_id = None
         self._job_version_alias = None
-        self._disable = settings.disable_job_creation
+        self._disable = settings.disable_job_creation or settings.x_disable_machine_info
         self._partial_source_id = None
         self._aliases = []
         self._source_type: Optional[Literal["repo", "artifact", "image"]] = (
@@ -228,16 +234,16 @@ class JobBuilder:
             ):
                 return None, None
 
-            if root is None or self._settings._jupyter_root is None:
+            if root is None or self._settings.x_jupyter_root is None:
                 _logger.info("target path does not exist, exiting")
                 return None, None
-            assert self._settings._jupyter_root is not None
+            assert self._settings.x_jupyter_root is not None
             # git notebooks set the root to the git root,
             # jupyter_root contains the path where the jupyter notebook was started
             # program_relpath contains the path from jupyter_root to the file
             # full program path here is actually the relpath from the program to the git root
             full_program_path = os.path.join(
-                os.path.relpath(str(self._settings._jupyter_root), root),
+                os.path.relpath(str(self._settings.x_jupyter_root), root),
                 program_relpath,
             )
             full_program_path = os.path.normpath(full_program_path)
@@ -476,7 +482,8 @@ class JobBuilder:
         # can't build a job without a python version
         if runtime is None:
             self._log_if_verbose(
-                "No python version found in metadata, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "No python version found in metadata, not creating job artifact. "
+                "See https://docs.wandb.ai/guides/launch/create-job",
                 "warn",
             )
             return None
@@ -505,7 +512,8 @@ class JobBuilder:
         program_relpath = self._get_program_relpath(source_type, metadata)
         if not self._partial and source_type != "image" and not program_relpath:
             self._log_if_verbose(
-                "No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "No program path found, not creating job artifact. "
+                "See https://docs.wandb.ai/guides/launch/create-job",
                 "warn",
             )
             return None

wandb/sdk/internal/progress.py

@@ -1,16 +1,12 @@
 """progress."""
 
 import os
-import sys
 from typing import IO, TYPE_CHECKING, Optional
 
 from wandb.errors import CommError
 
 if TYPE_CHECKING:
-    if sys.version_info >= (3, 8):
-        from typing import Protocol
-    else:
-        from typing_extensions import Protocol
+    from typing import Protocol
 
     class ProgressFn(Protocol):
         def __call__(self, new_bytes: int, total_bytes: int) -> None: