wandb 0.18.0rc1__py3-none-any.whl → 0.18.2__py3-none-any.whl

wandb/env.py

@@ -62,7 +62,6 @@ SAVE_CODE = "WANDB_SAVE_CODE"
 TAGS = "WANDB_TAGS"
 IGNORE = "WANDB_IGNORE_GLOBS"
 ERROR_REPORTING = "WANDB_ERROR_REPORTING"
-CORE_ERROR_REPORTING = "WANDB_CORE_ERROR_REPORTING"
 CORE_DEBUG = "WANDB_CORE_DEBUG"
 DOCKER = "WANDB_DOCKER"
 AGENT_REPORT_INTERVAL = "WANDB_AGENT_REPORT_INTERVAL"
@@ -172,10 +171,6 @@ def error_reporting_enabled() -> bool:
     return _env_as_bool(ERROR_REPORTING, default="True")
 
 
-def core_error_reporting_enabled(default: Optional[str] = None) -> bool:
-    return _env_as_bool(CORE_ERROR_REPORTING, default=default)
-
-
 def core_debug(default: Optional[str] = None) -> bool:
     return _env_as_bool(CORE_DEBUG, default=default)
 

wandb/errors/__init__.py

@@ -1,46 +1,17 @@
-__all__ = [
+__all__ = (
     "Error",
     "CommError",
     "AuthenticationError",
     "UsageError",
     "UnsupportedError",
     "WandbCoreNotAvailableError",
-]
-
-from typing import Optional
-
-
-class Error(Exception):
-    """Base W&B Error."""
-
-    def __init__(self, message, context: Optional[dict] = None) -> None:
-        super().__init__(message)
-        self.message = message
-        # sentry context capture
-        if context:
-            self.context = context
-
-
-class CommError(Error):
-    """Error communicating with W&B servers."""
-
-    def __init__(self, msg, exc=None) -> None:
-        self.exc = exc
-        self.message = msg
-        super().__init__(self.message)
-
-
-class AuthenticationError(CommError):
-    """Raised when authentication fails."""
-
-
-class UsageError(Error):
-    """Raised when an invalid usage of the SDK API is detected."""
-
-
-class UnsupportedError(UsageError):
-    """Raised when trying to use a feature that is not supported."""
-
-
-class WandbCoreNotAvailableError(Error):
-    """Raised when wandb core is not available."""
+)
+
+from .errors import (
+    AuthenticationError,
+    CommError,
+    Error,
+    UnsupportedError,
+    UsageError,
+    WandbCoreNotAvailableError,
+)

wandb/errors/errors.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+
+class Error(Exception):
+    """Base W&B Error."""
+
+    def __init__(self, message, context: Optional[dict] = None) -> None:
+        super().__init__(message)
+        self.message = message
+        # sentry context capture
+        if context:
+            self.context = context
+
+
+class CommError(Error):
+    """Error communicating with W&B servers."""
+
+    def __init__(self, msg, exc=None) -> None:
+        self.exc = exc
+        self.message = msg
+        super().__init__(self.message)
+
+
+class AuthenticationError(CommError):
+    """Raised when authentication fails."""
+
+
+class UsageError(Error):
+    """Raised when an invalid usage of the SDK API is detected."""
+
+
+class UnsupportedError(UsageError):
+    """Raised when trying to use a feature that is not supported."""
+
+
+class WandbCoreNotAvailableError(Error):
+    """Raised when wandb core is not available."""

wandb/errors/warnings.py

@@ -0,0 +1,2 @@
+class WandbWarning(Warning):
+    """Base W&B Warning."""

wandb/{sklearn → integration/sklearn}/calculate/calibration_curves.py

@@ -7,18 +7,18 @@ from sklearn.calibration import CalibratedClassifierCV
 from sklearn.linear_model import LogisticRegression
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def calibration_curves(clf, X, y, clf_name):
+def calibration_curves(clf, X, y, clf_name):  # noqa: N803
     # ComplementNB (introduced in 0.20.0) requires non-negative features
     if int(sklearn.__version__.split(".")[1]) >= 20 and isinstance(
         clf, naive_bayes.ComplementNB
     ):
-        X = X - X.min()
+        X = X - X.min()  # noqa:N806
 
     # Calibrated with isotonic calibration
     isotonic = CalibratedClassifierCV(clf, cv=2, method="isotonic")
@@ -48,7 +48,7 @@ def calibration_curves(clf, X, y, clf_name):
     frac_positives_column.append(1)
     mean_pred_value_column.append(1)
 
-    X_train, X_test, y_train, y_test = model_selection.train_test_split(
+    x_train, x_test, y_train, y_test = model_selection.train_test_split(
         X, y, test_size=0.9, random_state=42
     )
 
@@ -58,11 +58,11 @@ def calibration_curves(clf, X, y, clf_name):
     names = ["Logistic", f"{clf_name} Isotonic", f"{clf_name} Sigmoid"]
 
     for model, name in zip(models, names):
-        model.fit(X_train, y_train)
+        model.fit(x_train, y_train)
         if hasattr(model, "predict_proba"):
-            prob_pos = model.predict_proba(X_test)[:, 1]
+            prob_pos = model.predict_proba(x_test)[:, 1]
         else:  # use decision function
-            prob_pos = model.decision_function(X_test)
+            prob_pos = model.decision_function(x_test)
             prob_pos = (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())
 
         hist, edges = np.histogram(prob_pos, bins=10, density=False)

wandb/{sklearn → integration/sklearn}/calculate/class_proportions.py

@@ -4,7 +4,7 @@ import numpy as np
 from sklearn.utils.multiclass import unique_labels
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)

wandb/{sklearn → integration/sklearn}/calculate/confusion_matrix.py

@@ -6,14 +6,15 @@ from sklearn import metrics
 from sklearn.utils.multiclass import unique_labels
 
 import wandb
-from wandb.sklearn import utils
+
+from .. import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
 def validate_labels(*args, **kwargs):  # FIXME
-    assert False
+    raise AssertionError()
 
 
 def confusion_matrix(

wandb/{sklearn → integration/sklearn}/calculate/elbow_curve.py

@@ -11,7 +11,7 @@ import wandb
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def elbow_curve(clusterer, X, cluster_ranges, n_jobs, show_cluster_time):
+def elbow_curve(clusterer, X, cluster_ranges, n_jobs, show_cluster_time):  # noqa: N803
     if cluster_ranges is None:
         cluster_ranges = range(1, 10, 2)
     else:
@@ -37,19 +37,19 @@ def make_table(cluster_ranges, clfs, times):
     return table
 
 
-def _compute_results_parallel(n_jobs, clusterer, X, cluster_ranges):
+def _compute_results_parallel(n_jobs, clusterer, x, cluster_ranges):
     parallel_runner = Parallel(n_jobs=n_jobs)
     _cluster_scorer = delayed(_clone_and_score_clusterer)
-    results = parallel_runner(_cluster_scorer(clusterer, X, i) for i in cluster_ranges)
+    results = parallel_runner(_cluster_scorer(clusterer, x, i) for i in cluster_ranges)
 
     clfs, times = zip(*results)
 
     return clfs, times
 
 
-def _clone_and_score_clusterer(clusterer, X, n_clusters):
+def _clone_and_score_clusterer(clusterer, x, n_clusters):
     start = time.time()
     clusterer = clone(clusterer)
-    setattr(clusterer, "n_clusters", n_clusters)
+    clusterer.n_clusters = n_clusters
 
-    return clusterer.fit(X).score(X), time.time() - start
+    return clusterer.fit(x).score(x), time.time() - start

wandb/{sklearn → integration/sklearn}/calculate/learning_curve.py

@@ -4,7 +4,7 @@ import numpy as np
 from sklearn import model_selection
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
@@ -12,7 +12,7 @@ simplefilter(action="ignore", category=FutureWarning)
 
 def learning_curve(
     model,
-    X,
+    X,  # noqa: N803
     y,
     cv=None,
     shuffle=False,

wandb/{sklearn → integration/sklearn}/calculate/outlier_candidates.py

@@ -3,13 +3,13 @@ from warnings import simplefilter
 import numpy as np
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def outlier_candidates(regressor, X, y):
+def outlier_candidates(regressor, X, y):  # noqa: N803
     # Fit a linear model to X and y to compute MSE
     regressor.fit(X, y)
 

wandb/{sklearn → integration/sklearn}/calculate/residuals.py

@@ -3,27 +3,27 @@ from warnings import simplefilter
 from sklearn import model_selection
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def residuals(regressor, X, y):
+def residuals(regressor, X, y):  # noqa: N803
     # Create the train and test splits
-    X_train, X_test, y_train, y_test = model_selection.train_test_split(
+    x_train, x_test, y_train, y_test = model_selection.train_test_split(
         X, y, test_size=0.2
     )
 
     # Store labels and colors for the legend ordered by call
-    regressor.fit(X_train, y_train)
-    train_score_ = regressor.score(X_train, y_train)
-    test_score_ = regressor.score(X_test, y_test)
+    regressor.fit(x_train, y_train)
+    train_score_ = regressor.score(x_train, y_train)
+    test_score_ = regressor.score(x_test, y_test)
 
-    y_pred_train = regressor.predict(X_train)
+    y_pred_train = regressor.predict(x_train)
     residuals_train = y_pred_train - y_train
 
-    y_pred_test = regressor.predict(X_test)
+    y_pred_test = regressor.predict(x_test)
     residuals_test = y_pred_test - y_test
 
     table = make_table(

wandb/{sklearn → integration/sklearn}/calculate/silhouette.py

@@ -5,13 +5,13 @@ from sklearn.metrics import silhouette_samples, silhouette_score
 from sklearn.preprocessing import LabelEncoder
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def silhouette(clusterer, X, cluster_labels, labels, metric, kmeans):
+def silhouette(clusterer, X, cluster_labels, labels, metric, kmeans):  # noqa: N803
     # Run clusterer for n_clusters in range(len(cluster_ranges), get cluster labels
     # TODO - keep/delete once we decide if we should train clusterers
     # or ask for trained models

wandb/{sklearn → integration/sklearn}/calculate/summary_metrics.py

@@ -4,13 +4,13 @@ import numpy as np
 import sklearn
 
 import wandb
-from wandb.sklearn import utils
+from wandb.integration.sklearn import utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
+def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):  # noqa: N803
     """Calculate summary metrics for both regressors and classifiers.
 
     Called by plot_summary_metrics to visualize metrics. Please use the function

wandb/{sklearn → integration/sklearn}/plot/classifier.py

@@ -7,7 +7,7 @@ from sklearn import naive_bayes
 
 import wandb
 import wandb.plot
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 from . import shared
 
@@ -17,8 +17,8 @@ simplefilter(action="ignore", category=FutureWarning)
 
 def classifier(
     model,
-    X_train,
-    X_test,
+    X_train,  # noqa: N803
+    X_test,  # noqa: N803
     y_train,
     y_test,
     y_pred,
@@ -77,7 +77,7 @@ def classifier(
     )
     ```
     """
-    wandb.termlog("\nPlotting %s." % model_name)
+    wandb.termlog(f"\nPlotting {model_name}.")
 
     if not isinstance(model, naive_bayes.MultinomialNB):
         feature_importances(model, feature_names)
@@ -280,7 +280,7 @@ def class_proportions(y_train=None, y_test=None, labels=None):
         wandb.log({"class_proportions": class_proportions_chart})
 
 
-def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):
+def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):  # noqa: N803
     """Log a plot depicting how well-calibrated the predicted probabilities of a classifier are.
 
     Also suggests how to calibrate an uncalibrated classifier. Compares estimated predicted

wandb/{sklearn → integration/sklearn}/plot/clusterer.py

@@ -6,13 +6,13 @@ import pandas as pd
 import sklearn
 
 import wandb
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer"):
+def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer"):  # noqa: N803
     """Generates all sklearn clusterer plots supported by W&B.
 
     The following plots are generated:
@@ -40,7 +40,7 @@ def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer
     wandb.sklearn.plot_clusterer(kmeans, X, cluster_labels, labels, "KMeans")
     ```
     """
-    wandb.termlog("\nPlotting %s." % model_name)
+    wandb.termlog(f"\nPlotting {model_name}.")
     if isinstance(model, sklearn.cluster.KMeans):
         elbow_curve(model, X_train)
         wandb.termlog("Logged elbow curve.")
@@ -54,7 +54,11 @@ def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer
 
 
 def elbow_curve(
-    clusterer=None, X=None, cluster_ranges=None, n_jobs=1, show_cluster_time=True
+    clusterer=None,
+    X=None,  # noqa: N803
+    cluster_ranges=None,
+    n_jobs=1,
+    show_cluster_time=True,
 ):
     """Measures and plots variance explained as a function of the number of clusters.
 
@@ -97,7 +101,7 @@ def elbow_curve(
 
 def silhouette(
     clusterer=None,
-    X=None,
+    X=None,  # noqa: N803
     cluster_labels=None,
     labels=None,
     metric="euclidean",
@@ -135,7 +139,7 @@ def silhouette(
 
     if not_missing and correct_types and is_fitted:
         if isinstance(X, (pd.DataFrame)):
-            X = X.values
+            X = X.values  # noqa: N806
         silhouette_chart = calculate.silhouette(
             clusterer, X, cluster_labels, labels, metric, kmeans
         )

wandb/{sklearn → integration/sklearn}/plot/regressor.py

@@ -5,7 +5,7 @@ from warnings import simplefilter
 import numpy as np
 
 import wandb
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 from . import shared
 
@@ -13,7 +13,7 @@ from . import shared
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
+def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):  # noqa: N803
     """Generates all sklearn regressor plots supported by W&B.
 
     The following plots are generated:
@@ -38,7 +38,7 @@ def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
     wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, "Ridge")
     ```
     """
-    wandb.termlog("\nPlotting %s." % model_name)
+    wandb.termlog(f"\nPlotting {model_name}.")
 
     shared.summary_metrics(model, X_train, y_train, X_test, y_test)
     wandb.termlog("Logged summary metrics.")
@@ -53,7 +53,7 @@ def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
     wandb.termlog("Logged residuals.")
 
 
-def outlier_candidates(regressor=None, X=None, y=None):
+def outlier_candidates(regressor=None, X=None, y=None):  # noqa: N803
     """Measures a datapoint's influence on regression model via cook's distance.
 
     Instances with high influences could potentially be outliers.
@@ -87,7 +87,7 @@ def outlier_candidates(regressor=None, X=None, y=None):
         wandb.log({"outlier_candidates": outliers_chart})
 
 
-def residuals(regressor=None, X=None, y=None):
+def residuals(regressor=None, X=None, y=None):  # noqa: N803
     """Measures and plots the regressor's predicted value against the residual.
 
     The marginal distribution of residuals is also calculated and plotted.

wandb/{sklearn → integration/sklearn}/plot/shared.py

@@ -5,13 +5,13 @@ from warnings import simplefilter
 import numpy as np
 
 import wandb
-from wandb.sklearn import calculate, utils
+from wandb.integration.sklearn import calculate, utils
 
 # ignore all future warnings
 simplefilter(action="ignore", category=FutureWarning)
 
 
-def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
+def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):  # noqa: N803
     """Logs a chart depicting summary metrics for a model.
 
     Should only be called with a fitted model (otherwise an error is thrown).
@@ -47,7 +47,7 @@ def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
 
 def learning_curve(
     model=None,
-    X=None,
+    X=None,  # noqa: N803
     y=None,
     cv=None,
     shuffle=False,

wandb/{sklearn → integration/sklearn}/utils.py

@@ -61,7 +61,7 @@ def test_types(**kwargs):
                     list,
                 ),
             ):
-                wandb.termerror("%s is not an array. Please try again." % (k))
+                wandb.termerror(f"{k} is not an array. Please try again.")
                 test_passed = False
         # check for classifier types
         if k == "model":
@@ -69,20 +69,20 @@ def test_types(**kwargs):
                 not sklearn.base.is_regressor(v)
             ):
                 wandb.termerror(
-                    "%s is not a classifier or regressor. Please try again." % (k)
+                    f"{k} is not a classifier or regressor. Please try again."
                 )
                 test_passed = False
         elif k == "clf" or k == "binary_clf":
             if not (sklearn.base.is_classifier(v)):
-                wandb.termerror("%s is not a classifier. Please try again." % (k))
+                wandb.termerror(f"{k} is not a classifier. Please try again.")
                 test_passed = False
         elif k == "regressor":
             if not sklearn.base.is_regressor(v):
-                wandb.termerror("%s is not a regressor. Please try again." % (k))
+                wandb.termerror(f"{k} is not a regressor. Please try again.")
                 test_passed = False
         elif k == "clusterer":
             if not (getattr(v, "_estimator_type", None) == "clusterer"):
-                wandb.termerror("%s is not a clusterer. Please try again." % (k))
+                wandb.termerror(f"{k} is not a clusterer. Please try again.")
                 test_passed = False
     return test_passed
 
@@ -129,7 +129,7 @@ def test_missing(**kwargs):
     for k, v in kwargs.items():
         # Missing/empty params/datapoint arrays
         if v is None:
-            wandb.termerror("%s is None. Please try again." % (k))
+            wandb.termerror(f"{k} is None. Please try again.")
             test_passed = False
         if (k == "X") or (k == "X_test"):
             if isinstance(v, scipy.sparse.csr.csr_matrix):
@@ -168,8 +168,8 @@ def test_missing(**kwargs):
                 )
             if non_nums > 0:
                 wandb.termerror(
-                    "%s contains values that are not numbers. Please vectorize, label encode or one hot encode %s and call the plotting function again."
-                    % (k, k)
+                    f"{k} contains values that are not numbers. Please vectorize, label encode or one hot encode {k} "
+                    "and call the plotting function again."
                 )
                 test_passed = False
     return test_passed

wandb/integration/tensorboard/log.py

@@ -5,8 +5,8 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import wandb
 import wandb.util
+from wandb.plot.viz import custom_chart
 from wandb.sdk.lib import telemetry
-from wandb.sdk.lib.viz import custom_chart
 
 if TYPE_CHECKING:
     import numpy as np