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

wandb/sdk/wandb_settings.py

@@ -298,7 +298,6 @@ class SettingsData:
 
     _args: Sequence[str]
     _aws_lambda: bool
-    _async_upload_concurrency_limit: int
     _cli_only_mode: bool  # Avoid running any code specific for runs
     _code_path_local: str
     _colab: bool
@@ -310,9 +309,9 @@ class SettingsData:
     )
     _disable_setproctitle: bool  # Do not use setproctitle on internal process
     _disable_stats: bool  # Do not collect system metrics
+    _disable_update_check: bool  # Disable version check
     _disable_viewer: bool  # Prevent early viewer query
     _disable_machine_info: bool  # Disable automatic machine info collection
-    _except_exit: bool
     _executable: str
     _extra_http_headers: Mapping[str, str]
     # file stream retry client configuration
@@ -424,7 +423,6 @@ class SettingsData:
     # magic: Union[str, bool, dict]  # never used in code, deprecated
     mode: str
     notebook_name: str
-    problem: str
     program: str
     program_abspath: str
     program_relpath: str
@@ -620,10 +618,6 @@ class Settings(SettingsData):
         Note that key names must be the same as the class attribute names.
         """
         props: Dict[str, Dict[str, Any]] = dict(
-            _async_upload_concurrency_limit={
-                "preprocessor": int,
-                "validator": self._validate__async_upload_concurrency_limit,
-            },
             _aws_lambda={
                 "hook": lambda _: is_aws_lambda(),
                 "auto_hook": True,
@@ -656,6 +650,7 @@ class Settings(SettingsData):
                 "preprocessor": _str_as_bool,
                 "hook": lambda x: self._disable_machine_info or x,
             },
+            _disable_update_check={"preprocessor": _str_as_bool},
             _disable_viewer={"preprocessor": _str_as_bool},
             _extra_http_headers={"preprocessor": _str_as_json},
             # Retry filestream requests for 2 hours before dropping chunk (how do we recover?)
@@ -860,7 +855,6 @@ class Settings(SettingsData):
             },
             login_timeout={"preprocessor": lambda x: float(x)},
             mode={"value": "online", "validator": self._validate_mode},
-            problem={"value": "fatal", "validator": self._validate_problem},
             program={
                 "hook": lambda x: self._get_program(x),
             },
@@ -1023,13 +1017,6 @@ class Settings(SettingsData):
             raise UsageError(f"Settings field `console`: {value!r} not in {choices}")
         return True
 
-    @staticmethod
-    def _validate_problem(value: str) -> bool:
-        choices: Set[str] = {"fatal", "warn", "silent"}
-        if value not in choices:
-            raise UsageError(f"Settings field `problem`: {value!r} not in {choices}")
-        return True
-
     @staticmethod
     def _validate_anonymous(value: str) -> bool:
         choices: Set[str] = {"allow", "must", "never", "false", "true"}
@@ -1177,35 +1164,6 @@ class Settings(SettingsData):
             raise UsageError("_stats_samples_to_average must be between 1 and 30")
         return True
 
-    @staticmethod
-    def _validate__async_upload_concurrency_limit(value: int) -> bool:
-        if value <= 0:
-            raise UsageError("_async_upload_concurrency_limit must be positive")
-
-        try:
-            import resource  # not always available on Windows
-
-            file_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
-        except Exception:
-            # Couldn't get the open-file-limit for some reason,
-            # probably very platform-specific. Not a problem,
-            # we just won't use it to cap the concurrency.
-            pass
-        else:
-            if value > file_limit:
-                wandb.termwarn(
-                    (
-                        "_async_upload_concurrency_limit setting of"
-                        f" {value} exceeds this process's limit"
-                        f" on open files ({file_limit}); may cause file-upload failures."
-                        " Try decreasing _async_upload_concurrency_limit,"
-                        " or increasing your file limit with `ulimit -n`."
-                    ),
-                    repeat=False,
-                )
-
-        return True
-
     @staticmethod
     def _validate_job_source(value: str) -> bool:
         valid_sources = ["repo", "artifact", "image"]
@@ -1673,7 +1631,6 @@ class Settings(SettingsData):
             "WANDB_TRACELOG": "_tracelog",
             "WANDB_DISABLE_SERVICE": "_disable_service",
             "WANDB_SERVICE_TRANSPORT": "_service_transport",
-            "WANDB_REQUIRE_CORE": "_require_core",
             "WANDB_DIR": "root_dir",
             "WANDB_NAME": "run_name",
             "WANDB_NOTES": "run_notes",
@@ -1782,9 +1739,6 @@ class Settings(SettingsData):
             settings["_args"] = sys.argv[1:]
         settings["_os"] = platform.platform(aliased=True)
         settings["_python"] = platform.python_version()
-        # hack to make sure we don't hang on windows
-        if self._windows and self._except_exit is None:
-            settings["_except_exit"] = True  # type: ignore
 
         if _logger is not None:
             _logger.info(

wandb/sdk/wandb_setup.py

@@ -1,7 +1,7 @@
 #
 """Setup wandb session.
 
-This module configures a wandb session which can extend to mutiple wandb runs.
+This module configures a wandb session which can extend to multiple wandb runs.
 
 Functions:
     setup(): Configure wandb session.

wandb/sklearn/__init__.py

@@ -1,4 +1,5 @@
 """Create informative charts for scikit-learn models and log them to W&B."""
+
 from .plot import (
     plot_calibration_curve,
     plot_class_proportions,

wandb/sklearn/plot/__init__.py

@@ -1,4 +1,5 @@
 """Create and logs charts introspecting models built with scikit-learn to W&B."""
+
 from .classifier import calibration_curve as plot_calibration_curve
 from .classifier import class_proportions as plot_class_proportions
 from .classifier import classifier as plot_classifier

wandb/sklearn/plot/classifier.py

@@ -1,11 +1,12 @@
 """Define plots for classification models built with scikit-learn."""
+
 from warnings import simplefilter
 
 import numpy as np
 from sklearn import naive_bayes
 
 import wandb
-import wandb.plots
+import wandb.plot
 from wandb.sklearn import calculate, utils
 
 from . import shared
@@ -32,9 +33,9 @@ def classifier(
 
     The following plots are generated:
         feature importances, confusion matrix, summary metrics,
-        class propotions, calibration curve, roc curve, precision-recall curve.
+        class proportions, calibration curve, roc curve, precision-recall curve.
 
-    Should only be called with a fitted classifer (otherwise an error is thrown).
+    Should only be called with a fitted classifier (otherwise an error is thrown).
 
     Arguments:
         model: (classifier) Takes in a fitted classifier.
@@ -44,7 +45,7 @@ def classifier(
         y_test: (arr) Test set labels.
         y_pred: (arr) Test set predictions by the model passed.
         y_probas: (arr) Test set predicted probabilities by the model passed.
-        labels: (list) Named labels for target varible (y). Makes plots easier to
+        labels: (list) Named labels for target variable (y). Makes plots easier to
                         read by replacing target values with corresponding index.
                         For example if `labels=['dog', 'cat', 'owl']` all 0s are
                         replaced by dog, 1s by cat.
@@ -133,9 +134,7 @@ def roc(
     wandb.sklearn.plot_roc(y_true, y_probas, labels)
     ```
     """
-    roc_chart = wandb.plots.roc.roc(
-        y_true, y_probas, labels, plot_micro, plot_macro, classes_to_plot
-    )
+    roc_chart = wandb.plot.roc_curve(y_true, y_probas, labels, classes_to_plot)
     wandb.log({"roc": roc_chart})
 
 
@@ -212,8 +211,8 @@ def precision_recall(
     wandb.sklearn.plot_precision_recall(y_true, y_probas, labels)
     ```
     """
-    precision_recall_chart = wandb.plots.precision_recall(
-        y_true, y_probas, labels, plot_micro, classes_to_plot
+    precision_recall_chart = wandb.plot.pr_curve(
+        y_true, y_probas, labels, classes_to_plot
     )
 
     wandb.log({"precision_recall": precision_recall_chart})
@@ -224,7 +223,7 @@ def feature_importances(
 ):
     """Log a plot depicting the relative importance of each feature for a classifier's decisions.
 
-    Should only be called with a fitted classifer (otherwise an error is thrown).
+    Should only be called with a fitted classifier (otherwise an error is thrown).
     Only works with classifiers that have a feature_importances_ attribute, like trees.
 
     Arguments:
@@ -251,7 +250,7 @@ def feature_importances(
 
 
 def class_proportions(y_train=None, y_test=None, labels=None):
-    """Plot the distribution of target classses in training and test sets.
+    """Plot the distribution of target classes in training and test sets.
 
     Useful for detecting imbalanced classes.
 
@@ -295,7 +294,7 @@ def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):
     if so which calibration (sigmoid or isotonic) might help fix this.
     For more details, see https://scikit-learn.org/stable/auto_examples/calibration/plot_calibration_curve.html.
 
-    Should only be called with a fitted classifer (otherwise an error is thrown).
+    Should only be called with a fitted classifier (otherwise an error is thrown).
 
     Please note this function fits variations of the model on the training set when called.
 

wandb/sklearn/plot/clusterer.py

@@ -1,4 +1,5 @@
 """Define plots for clustering models built with scikit-learn."""
+
 from warnings import simplefilter
 
 import pandas as pd
@@ -24,7 +25,7 @@ def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer
         X_train: (arr) Training set features.
         cluster_labels: (list) Names for cluster labels. Makes plots easier to read
                             by replacing cluster indexes with corresponding names.
-        labels: (list) Named labels for target varible (y). Makes plots easier to
+        labels: (list) Named labels for target variable (y). Makes plots easier to
                         read by replacing target values with corresponding index.
                         For example if `labels=['dog', 'cat', 'owl']` all 0s are
                         replaced by dog, 1s by cat.

wandb/sklearn/plot/regressor.py

@@ -1,4 +1,5 @@
 """Define plots for regression models built with scikit-learn."""
+
 from warnings import simplefilter
 
 import numpy as np

wandb/sklearn/plot/shared.py

@@ -1,4 +1,5 @@
 """Define plots used by multiple sklearn model classes."""
+
 from warnings import simplefilter
 
 import numpy as np

wandb/sklearn/utils.py

@@ -1,4 +1,5 @@
 """Shared utilities for the modules in wandb.sklearn."""
+
 from collections.abc import Iterable, Sequence
 
 import numpy as np

wandb/testing/relay.py

@@ -586,11 +586,11 @@ class InjectedResponse:
 
 
 class RelayControlProtocol(Protocol):
-    def process(self, request: "flask.Request") -> None:
-        ...  # pragma: no cover
+    def process(self, request: "flask.Request") -> None: ...  # pragma: no cover
 
-    def control(self, request: "flask.Request") -> Mapping[str, str]:
-        ...  # pragma: no cover
+    def control(
+        self, request: "flask.Request"
+    ) -> Mapping[str, str]: ...  # pragma: no cover
 
 
 class RelayServer:

wandb/trigger.py

@@ -6,6 +6,7 @@ Usage:
     trigger.call('on_something', *args, **kwargs)
     trigger.unregister('on_something', func)
 """
+
 from typing import Any, Callable
 
 _triggers = {}

wandb/util.py

@@ -11,6 +11,7 @@ import logging
 import math
 import numbers
 import os
+import pathlib
 import platform
 import queue
 import random
@@ -43,7 +44,6 @@ from typing import (
     Mapping,
     Optional,
     Sequence,
-    Set,
     TextIO,
     Tuple,
     TypeVar,
@@ -55,7 +55,13 @@ import yaml
 
 import wandb
 import wandb.env
-from wandb.errors import AuthenticationError, CommError, UsageError, term
+from wandb.errors import (
+    AuthenticationError,
+    CommError,
+    UsageError,
+    WandbCoreNotAvailableError,
+    term,
+)
 from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
 from wandb.sdk.lib import filesystem, runid
 from wandb.sdk.lib.json_util import dump, dumps
@@ -537,50 +543,41 @@ def _numpy_generic_convert(obj: Any) -> Any:
     return obj
 
 
-def _find_all_matching_keys(
+def _sanitize_numpy_keys(
     d: Dict,
-    match_fn: Callable[[Any], bool],
-    visited: Optional[Set[int]] = None,
-    key_path: Tuple[Any, ...] = (),
-) -> Generator[Tuple[Tuple[Any, ...], Any], None, None]:
-    """Recursively find all keys that satisfies a match function.
+    visited: Optional[Dict[int, Dict]] = None,
+) -> Tuple[Dict, bool]:
+    """Returns a dictionary where all NumPy keys are converted.
 
     Args:
-       d: The dict to search.
-       match_fn: The function to determine if the key is a match.
-       visited: Keep track of visited nodes so we dont recurse forever.
-       key_path: Keep track of all the keys to get to the current node.
+        d: The dictionary to sanitize.
 
-    Yields:
-       (key_path, key): The location where the key was found, and the key
+    Returns:
+        A sanitized dictionary, and a boolean indicating whether anything was
+        changed.
     """
+    out: Dict[Any, Any] = dict()
+    converted = False
+
+    # Work with recursive dictionaries: if a dictionary has already been
+    # converted, reuse its converted value to retain the recursive structure
+    # of the input.
     if visited is None:
-        visited = set()
-    me = id(d)
-    if me not in visited:
-        visited.add(me)
-        for key, value in d.items():
-            if match_fn(key):
-                yield key_path, key
-            if isinstance(value, dict):
-                yield from _find_all_matching_keys(
-                    value,
-                    match_fn,
-                    visited=visited,
-                    key_path=tuple(list(key_path) + [key]),
-                )
+        visited = {id(d): out}
+    elif id(d) in visited:
+        return visited[id(d)], False
+    visited[id(d)] = out
 
+    for key, value in d.items():
+        if isinstance(value, dict):
+            value, converted_value = _sanitize_numpy_keys(value, visited)
+            converted |= converted_value
+        if isinstance(key, np.generic):
+            key = _numpy_generic_convert(key)
+            converted = True
+        out[key] = value
 
-def _sanitize_numpy_keys(d: Dict) -> Tuple[Dict, bool]:
-    np_keys = list(_find_all_matching_keys(d, lambda k: isinstance(k, np.generic)))
-    if not np_keys:
-        return d, False
-    for key_path, key in np_keys:
-        ptr = d
-        for k in key_path:
-            ptr = ptr[k]
-        ptr[_numpy_generic_convert(key)] = ptr.pop(key)
-    return d, True
+    return out, converted
 
 
 def json_friendly(  # noqa: C901
@@ -1842,15 +1839,6 @@ def sample_with_exponential_decay_weights(
     return sampled_xs, sampled_ys, sampled_keys
 
 
-def get_core_path() -> str:
-    core_path: str = os.environ.get("_WANDB_CORE_PATH", "")
-    wandb_core = get_module("wandb_core")
-    if not core_path and wandb_core:
-        _check_wandb_core_version_compatibility(wandb_core.__version__)
-        core_path = wandb_core.get_core_path()
-    return core_path
-
-
 @dataclasses.dataclass(frozen=True)
 class InstalledDistribution:
     """An installed distribution.
@@ -1888,15 +1876,40 @@ def parse_version(version: str) -> "packaging.version.Version":
     try:
         from packaging.version import parse as parse_version  # type: ignore
     except ImportError:
-        from pkg_resources import parse_version
+        from pkg_resources import parse_version  # type: ignore[assignment]
 
     return parse_version(version)
 
 
-def _check_wandb_core_version_compatibility(core_version: str) -> None:
-    """Checks if the installed wandb-core version is compatible with the wandb version."""
-    if parse_version(core_version) < parse_version(wandb._minimum_core_version):
-        raise ImportError(
-            f"Requires wandb-core version {wandb._minimum_core_version} or later, "
-            f"but you have {core_version}. Run `pip install --upgrade wandb-core` to upgrade."
+def get_core_path() -> str:
+    """Returns the path to the wandb-core binary.
+
+    The path can be set explicitly via the _WANDB_CORE_PATH environment
+    variable. Otherwise, the path to the binary in the current package
+    is returned.
+
+    Returns:
+        str: The path to the wandb-core package.
+
+    Raises:
+        WandbCoreNotAvailableError: If wandb-core was not built for the current system.
+    """
+    # NOTE: Environment variable _WANDB_CORE_PATH is a temporary development feature
+    #       to assist in running the core service from a live development directory.
+    path_from_env: str = os.environ.get("_WANDB_CORE_PATH", "")
+    if path_from_env:
+        wandb.termwarn(
+            f"Using wandb-core from path `_WANDB_CORE_PATH={path_from_env}`. "
+            "This is a development feature and may not work as expected."
         )
+        return path_from_env
+
+    bin_path = pathlib.Path(__file__).parent / "bin" / "wandb-core"
+    if not bin_path.exists():
+        raise WandbCoreNotAvailableError(
+            f"Looks like wandb-core is not compiled for your system ({platform.platform()}):"
+            " Please contact support at support@wandb.com to request `wandb-core`"
+            " support for your system."
+        )
+
+    return str(bin_path)

wandb/wandb_controller.py

@@ -20,7 +20,7 @@ Example:
     tuner = wandb.controller()
     tuner.configure(sweep_config)
     tuner.create()
-    # (3) create by constructing progamatic sweep configuration
+    # (3) create by constructing programmatic sweep configuration
     tuner = wandb.controller()
     tuner.configure_search('random')
     tuner.configure_program('train-dummy.py')
@@ -47,7 +47,6 @@ Example:
             tuner.stop_runs(runs)
 """
 
-
 import json
 import os
 import random
@@ -128,7 +127,7 @@ class _WandbController:
     """
 
     def __init__(self, sweep_id_or_config=None, entity=None, project=None):
-        # sweep id configured in constuctor
+        # sweep id configured in constructor
         self._sweep_id: Optional[str] = None
 
         # configured parameters

wandb/wandb_torch.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 
-"""PyTorch-specific functionality
-"""
+"""PyTorch-specific functionality"""
 
 import itertools
 from functools import reduce