wandb 0.18.7__py3-none-macosx_11_0_arm64.whl → 0.19.0rc1__py3-none-macosx_11_0_arm64.whl

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:

wandb/sdk/internal/sender.py

@@ -6,7 +6,6 @@ import json
 import logging
 import os
 import queue
-import sys
 import threading
 import time
 import traceback
@@ -19,6 +18,7 @@ from typing import (
     Dict,
     Generator,
     List,
+    Literal,
     Optional,
     Tuple,
     Type,
@@ -57,11 +57,6 @@ from wandb.sdk.lib import (
 from wandb.sdk.lib.mailbox import ContextCancelledError
 from wandb.sdk.lib.proto_util import message_to_dict
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
 if TYPE_CHECKING:
     from wandb.proto.wandb_internal_pb2 import (
         ArtifactManifest,
@@ -326,18 +321,19 @@ class SendManager:
     ) -> "SendManager":
         """Set up a standalone SendManager.
 
-        Currently, we're using this primarily for `sync.py`.
+        Exclusively used in `sync.py`.
         """
+        print(root_dir)
         files_dir = os.path.join(root_dir, "files")
         settings = wandb.Settings(
-            files_dir=files_dir,
+            x_files_dir=files_dir,
             root_dir=root_dir,
             # _start_time=0,
             resume=resume,
             # ignore_globs=(),
-            _sync=True,
+            x_sync=True,
             disable_job_creation=False,
-            _file_stream_timeout_seconds=0,
+            x_file_stream_timeout_seconds=0,
         )
         record_q: Queue[Record] = queue.Queue()
         result_q: Queue[Result] = queue.Queue()
@@ -440,7 +436,7 @@ class SendManager:
         #     state machine
         #   - skipping the exit record in `wandb sync` mode so that
         #     it is always executed as the last record
-        if not self._settings._offline and not self._settings._sync:
+        if not self._settings._offline and not self._settings.x_sync:
             assert record_num == self._send_record_num + 1
         self._send_record_num = record_num
 
@@ -914,7 +910,7 @@ class SendManager:
         # update telemetry
         if run.telemetry:
             self._telemetry_obj.MergeFrom(run.telemetry)
-        if self._settings._sync:
+        if self._settings.x_sync:
             self._telemetry_obj.feature.sync = True
 
         # build config dict
@@ -1124,7 +1120,7 @@ class SendManager:
             self._api,
             self._run.run_id,
             self._run.start_time.ToMicroseconds() / 1e6,
-            timeout=self._settings._file_stream_timeout_seconds,
+            timeout=self._settings.x_file_stream_timeout_seconds or 0,
             settings=self._api_settings,
         )
         # Ensure the streaming polices have the proper offsets

wandb/sdk/internal/settings_static.py

@@ -1,12 +1,11 @@
-from dataclasses import fields
-from typing import Any, Iterable, Sequence, Tuple
+from typing import Any, Iterable
 
 from wandb.proto import wandb_settings_pb2
 from wandb.sdk.lib import RunMoment
-from wandb.sdk.wandb_settings import SettingsData
+from wandb.sdk.wandb_settings import Settings
 
 
-class SettingsStatic(SettingsData):
+class SettingsStatic(Settings):
     """A readonly object that wraps a protobuf Settings message.
 
     Implements the mapping protocol, so you can access settings as
@@ -19,8 +18,7 @@ class SettingsStatic(SettingsData):
 
     def _from_proto(self, proto: wandb_settings_pb2.Settings) -> None:
         forks_specified: list[str] = []
-        for field in fields(SettingsData):
-            key = field.name
+        for key in Settings.model_fields:  # type: ignore [attr-defined]
             value: Any = None
             if key == "_stats_open_metrics_filters":
                 # todo: it's an underscored field, refactor into
@@ -52,10 +50,6 @@ class SettingsStatic(SettingsData):
             else:
                 if proto.HasField(key):  # type: ignore [arg-type]
                     value = getattr(proto, key).value
-                    if field.type == Sequence[str]:
-                        value = list(value)
-                    elif field.type == Tuple[str]:
-                        value = tuple(value)
                 else:
                     value = None
             object.__setattr__(self, key, value)

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

@@ -117,9 +117,9 @@ class CPU:
     ) -> None:
         self.name: str = self.__class__.__name__.lower()
         self.metrics: List[Metric] = [
-            ProcessCpuPercent(settings._stats_pid),
+            ProcessCpuPercent(settings.x_stats_pid),
             CpuPercent(),
-            ProcessCpuThreads(settings._stats_pid),
+            ProcessCpuThreads(settings.x_stats_pid),
         ]
         self.metrics_monitor: MetricsMonitor = MetricsMonitor(
             self.name,

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

@@ -167,8 +167,8 @@ class Disk:
         self.name = self.__class__.__name__.lower()
         self.settings = settings
         self.metrics: List[Metric] = [
-            DiskUsagePercent(list(settings._stats_disk_paths or ["/"])),
-            DiskUsage(list(settings._stats_disk_paths or ["/"])),
+            DiskUsagePercent(list(settings.x_stats_disk_paths or ["/"])),
+            DiskUsage(list(settings.x_stats_disk_paths or ["/"])),
             DiskIn(),
             DiskOut(),
         ]
@@ -186,7 +186,7 @@ class Disk:
         return psutil is not None
 
     def probe(self) -> dict:
-        disk_paths = list(self.settings._stats_disk_paths or ["/"])
+        disk_paths = list(self.settings.x_stats_disk_paths or ["/"])
         disk_metrics = {}
         for disk_path in disk_paths:
             try:

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

@@ -354,13 +354,13 @@ class GPU:
     ) -> None:
         self.name = self.__class__.__name__.lower()
         self.metrics: List[Metric] = [
-            GPUMemoryAllocated(settings._stats_pid),
-            GPUMemoryAllocatedBytes(settings._stats_pid),
-            GPUMemoryUtilization(settings._stats_pid),
-            GPUUtilization(settings._stats_pid),
-            GPUTemperature(settings._stats_pid),
-            GPUPowerUsageWatts(settings._stats_pid),
-            GPUPowerUsagePercent(settings._stats_pid),
+            GPUMemoryAllocated(settings.x_stats_pid),
+            GPUMemoryAllocatedBytes(settings.x_stats_pid),
+            GPUMemoryUtilization(settings.x_stats_pid),
+            GPUUtilization(settings.x_stats_pid),
+            GPUTemperature(settings.x_stats_pid),
+            GPUPowerUsageWatts(settings.x_stats_pid),
+            GPUPowerUsagePercent(settings.x_stats_pid),
         ]
         self.metrics_monitor = MetricsMonitor(
             self.name,

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

@@ -2,15 +2,9 @@ import json
 import logging
 import shutil
 import subprocess
-import sys
 import threading
 from collections import deque
-from typing import TYPE_CHECKING, Any, Dict, List, Union
-
-if sys.version_info >= (3, 8):
-    from typing import Final, Literal
-else:
-    from typing_extensions import Final, Literal
+from typing import TYPE_CHECKING, Any, Dict, Final, List, Literal, Union
 
 from wandb.sdk.lib import telemetry
 

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

@@ -1,13 +1,15 @@
 import datetime
 import logging
-import sys
 import threading
-from typing import TYPE_CHECKING, Any, List, Optional, TypeVar
-
-if sys.version_info >= (3, 8):
-    from typing import Protocol, runtime_checkable
-else:
-    from typing_extensions import Protocol, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    List,
+    Optional,
+    Protocol,
+    TypeVar,
+    runtime_checkable,
+)
 
 if TYPE_CHECKING:
     from typing import Deque
@@ -118,14 +120,10 @@ class MetricsMonitor:
         self.sampling_interval: float = float(
             max(
                 0.1,
-                settings._stats_sample_rate_seconds,
+                settings.x_stats_sampling_interval,
             )
         )  # seconds
-        # The number of samples to aggregate (e.g. average or compute max/min etc.)
-        # before publishing; defaults to 15; valid range: [1:30]
-        self.samples_to_aggregate: int = min(
-            30, max(1, settings._stats_samples_to_average)
-        )
+        self.samples_to_aggregate = 1
 
     def monitor(self) -> None:
         """Poll the Asset metrics."""

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

@@ -134,7 +134,7 @@ class IPU:
     ) -> None:
         self.name = self.__class__.__name__.lower()
         self.metrics: List[Metric] = [
-            IPUStats(settings._stats_pid),
+            IPUStats(settings.x_stats_pid),
         ]
         self.metrics_monitor = MetricsMonitor(
             self.name,

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

@@ -134,8 +134,8 @@ class Memory:
         self.metrics: List[Metric] = [
             MemoryAvailable(),
             MemoryPercent(),
-            ProcessMemoryRSS(settings._stats_pid),
-            ProcessMemoryPercent(settings._stats_pid),
+            ProcessMemoryRSS(settings.x_stats_pid),
+            ProcessMemoryPercent(settings.x_stats_pid),
         ]
         self.metrics_monitor = MetricsMonitor(
             self.name,

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

@@ -1,16 +1,10 @@
 import logging
 import re
-import sys
 import threading
 from collections import defaultdict, deque
 from functools import lru_cache
 from types import ModuleType
-from typing import TYPE_CHECKING, Dict, List, Mapping, Sequence, Tuple, Union
-
-if sys.version_info >= (3, 8):
-    from typing import Final
-else:
-    from typing_extensions import Final
+from typing import TYPE_CHECKING, Dict, Final, List, Mapping, Sequence, Tuple, Union
 
 import requests
 import requests.adapters
@@ -235,7 +229,7 @@ class OpenMetrics:
         self.shutdown_event = shutdown_event
 
         self.metrics: List[Metric] = [
-            OpenMetricsMetric(name, url, settings._stats_open_metrics_filters)
+            OpenMetricsMetric(name, url, settings.x_stats_open_metrics_filters)
         ]
 
         self.metrics_monitor: MetricsMonitor = MetricsMonitor(

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

@@ -6,17 +6,11 @@ import os
 import pathlib
 import shutil
 import subprocess
-import sys
 import tempfile
 import threading
 import time
 from collections import deque
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
-
-if sys.version_info >= (3, 8):
-    from typing import Final
-else:
-    from typing_extensions import Final
+from typing import TYPE_CHECKING, Any, Dict, Final, List, Optional, Tuple, Union
 
 from wandb.sdk.lib import telemetry
 
@@ -315,8 +309,8 @@ class Trainium:
         self.name = self.__class__.__name__.lower()
         self.metrics: List[Metric] = [
             NeuronCoreStats(
-                settings._stats_pid,
-                settings._stats_neuron_monitor_config_path,
+                settings.x_stats_pid,
+                settings.x_stats_neuron_monitor_config_path,
             ),
         ]
         self.metrics_monitor = MetricsMonitor(

wandb/sdk/internal/system/system_info.py

@@ -126,7 +126,7 @@ class SystemInfo:
         logger.debug("Saving git patches done")
 
     def _probe_git(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        if self.settings.disable_git:
+        if self.settings.disable_git or self.settings.x_disable_machine_info:
             return data
 
         # in case of manually passing the git repo info, `enabled` would be False,
@@ -155,13 +155,14 @@ class SystemInfo:
         data["os"] = self.settings._os
         data["python"] = self.settings._python
         data["heartbeatAt"] = datetime.datetime.utcnow().isoformat()
-        data["startedAt"] = datetime.datetime.utcfromtimestamp(
-            self.settings._start_time
-        ).isoformat()
+        data["startedAt"] = (
+            datetime.datetime.utcfromtimestamp(self.settings.x_start_time).isoformat()
+            if self.settings.x_start_time
+            else None
+        )
 
         data["docker"] = self.settings.docker
 
-        data["cuda"] = self.settings._cuda
         data["args"] = tuple(self.settings._args or ())
         data["state"] = "running"
 
@@ -170,22 +171,22 @@ class SystemInfo:
             # Used during artifact-job creation, always points to the relpath
             # of code execution, even when in a git repo
             data["codePathLocal"] = self.settings._code_path_local
-        if not self.settings.disable_code:
+        if not (self.settings.disable_code or self.settings.x_disable_machine_info):
             if self.settings.program_relpath:
                 data["codePath"] = self.settings.program_relpath
             elif self.settings._jupyter:
                 if self.settings.notebook_name:
                     data["program"] = self.settings.notebook_name
-                elif self.settings._jupyter_path:
-                    if self.settings._jupyter_path.startswith("fileId="):
-                        unescaped = unquote(self.settings._jupyter_path)
+                elif self.settings.x_jupyter_path:
+                    if self.settings.x_jupyter_path.startswith("fileId="):
+                        unescaped = unquote(self.settings.x_jupyter_path)
                         data["colab"] = (
                             "https://colab.research.google.com/notebook#" + unescaped
                         )
-                        data["program"] = self.settings._jupyter_name
+                        data["program"] = self.settings.x_jupyter_name
                     else:
-                        data["program"] = self.settings._jupyter_path
-                        data["root"] = self.settings._jupyter_root
+                        data["program"] = self.settings.x_jupyter_path
+                        data["root"] = self.settings.x_jupyter_root
             # get the git repo info
             data = self._probe_git(data)
 
@@ -225,7 +226,7 @@ class SystemInfo:
 
     def publish(self, system_info: dict) -> None:
         # save pip, conda, code patches to disk
-        if self.settings._save_requirements:
+        if self.settings.x_save_requirements:
             self._save_conda()
         if self.settings.save_code:
             self._save_code()

wandb/sdk/internal/system/system_monitor.py

@@ -60,18 +60,11 @@ class SystemMonitor:
 
         # compute the global publishing interval if _stats_join_assets is requested
         sampling_interval: float = float(
-            max(
-                0.1,
-                self.settings._stats_sample_rate_seconds,
-            )
+            max(0.1, self.settings.x_stats_sampling_interval)
         )  # seconds
-        # The number of samples to aggregate (e.g. average or compute max/min etc.)
-        # before publishing; defaults to 15; valid range: [1:30]
-        samples_to_aggregate: int = min(
-            30, max(1, self.settings._stats_samples_to_average)
-        )
+        samples_to_aggregate: int = 1
         self.publishing_interval: float = sampling_interval * samples_to_aggregate
-        self.join_assets: bool = self.settings._stats_join_assets
+        self.join_assets: bool = False
 
         self.backend_interface = interface
         self.asset_interface: Optional[AssetInterface] = (
@@ -90,7 +83,7 @@ class SystemMonitor:
         )
 
         self.buffer: Dict[str, Deque[Tuple[float, float]]] = defaultdict(
-            lambda: deque([], maxlen=self.settings._stats_buffer_size)
+            lambda: deque([], maxlen=self.settings.x_stats_buffer_size)
         )
 
     def _get_assets(self) -> List["Asset"]:
@@ -104,7 +97,7 @@ class SystemMonitor:
         ]
 
     def _get_open_metrics_assets(self) -> List["Asset"]:
-        open_metrics_endpoints = self.settings._stats_open_metrics_endpoints
+        open_metrics_endpoints = self.settings.x_stats_open_metrics_endpoints
         if not open_metrics_endpoints:
             return []
 

wandb/sdk/internal/tb_watcher.py

@@ -231,7 +231,7 @@ class TBDirWatcher:
             return is_tfevents_file_created_by(path, None, None)
         else:
             return is_tfevents_file_created_by(
-                path, self._hostname, self._tbwatcher._settings._start_time
+                path, self._hostname, self._tbwatcher._settings.x_start_time
             )
 
     def _loader(

wandb/sdk/internal/writer.py

@@ -63,7 +63,7 @@ class WriteManager:
         self._telemetry_obj = tpb.TelemetryRecord()
         self._telemetry_overflow = False
         self._use_flow_control = not (
-            self._settings._flow_control_disabled or self._settings._offline
+            self._settings.x_flow_control_disabled or self._settings._offline
         )
 
     def open(self) -> None:

wandb/sdk/launch/agent/run_queue_item_file_saver.py

@@ -1,16 +1,10 @@
 """Implementation of the run queue item file saver class."""
 
 import os
-import sys
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 import wandb
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
 FileSubtypes = Literal["warning", "error"]
 
 

wandb/sdk/launch/create_job.py

@@ -168,7 +168,7 @@ def _create_job(
         return None, "", []
 
     job_builder = _configure_job_builder_for_partial(tempdir.name, job_source=job_type)
-    job_builder._settings.update(job_name=name)
+    job_builder._settings.job_name = name
     if job_type == "code":
         assert entrypoint is not None
         job_name = _make_code_artifact(
@@ -404,8 +404,7 @@ def _configure_job_builder_for_partial(tmpdir: str, job_source: str) -> JobBuild
     if job_source == "code":
         job_source = "artifact"
 
-    settings = wandb.Settings()
-    settings.update({"files_dir": tmpdir, "job_source": job_source})
+    settings = wandb.Settings(x_files_dir=tmpdir, job_source=job_source)
     job_builder = JobBuilder(
         settings=settings,  # type: ignore
         verbose=True,

wandb/sdk/launch/runner/abstract.py

@@ -9,7 +9,7 @@ import os
 import subprocess
 import sys
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from dockerpycreds.utils import find_executable  # type: ignore
 
@@ -22,11 +22,6 @@ from .._project_spec import LaunchProject
 _logger = logging.getLogger(__name__)
 
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
 State = Literal[
     "unknown",
     "starting",

wandb/sdk/launch/runner/kubernetes_monitor.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import logging
-import sys
 import traceback
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -74,8 +73,7 @@ _logger = logging.getLogger(__name__)
 def create_named_task(name: str, coro: Any, *args: Any, **kwargs: Any) -> asyncio.Task:
     """Create a named task."""
     task = asyncio.create_task(coro(*args, **kwargs))
-    if sys.version_info >= (3, 8):
-        task.set_name(name)
+    task.set_name(name)
     task.add_done_callback(_log_err_task_callback)
     return task
 
@@ -87,7 +85,7 @@ def _log_err_task_callback(task: asyncio.Task) -> None:
         if isinstance(exec, asyncio.CancelledError):
             wandb.termlog(f"Task {task.get_name()} was cancelled")
             return
-        name = str(task) if sys.version_info < (3, 8) else task.get_name()
+        name = task.get_name()
         wandb.termerror(f"Exception in task {name}")
         tb = exec.__traceback__
         tb_str = "".join(traceback.format_tb(tb))

wandb/sdk/lib/apikey.py

@@ -6,14 +6,10 @@ import stat
 import sys
 import textwrap
 from functools import partial
-from typing import TYPE_CHECKING, Callable, Dict, Optional, Union
-from urllib.parse import urlparse
 
 # import Literal
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
+from typing import TYPE_CHECKING, Callable, Dict, Literal, Optional, Union
+from urllib.parse import urlparse
 
 import click
 from requests.utils import NETRC_FILES, get_netrc_auth

wandb/sdk/lib/fsm.py

@@ -31,12 +31,18 @@ Usage:
 import sys
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Callable, Dict, Generic, Optional, Sequence, Type, TypeVar, Union
-
-if sys.version_info >= (3, 8):
-    from typing import Protocol, runtime_checkable
-else:
-    from typing_extensions import Protocol, runtime_checkable
+from typing import (
+    Callable,
+    Dict,
+    Generic,
+    Optional,
+    Protocol,
+    Sequence,
+    Type,
+    TypeVar,
+    Union,
+    runtime_checkable,
+)
 
 if sys.version_info >= (3, 10):
     from typing import TypeAlias