wandb 0.19.12rc1__py3-none-win32.whl → 0.20.1__py3-none-win32.whl

wandb/integration/keras/callbacks/model_checkpoint.py

@@ -175,10 +175,10 @@ class WandbModelCheckpoint(callbacks.ModelCheckpoint):
     @property
     def is_old_tf_keras_version(self) -> Optional[bool]:
         if self._is_old_tf_keras_version is None:
-            from wandb.util import parse_version
+            from packaging.version import parse
 
             try:
-                if parse_version(tf.keras.__version__) < parse_version("2.6.0"):
+                if parse(tf.keras.__version__) < parse("2.6.0"):
                     self._is_old_tf_keras_version = True
                 else:
                     self._is_old_tf_keras_version = False

wandb/integration/keras/keras.py

@@ -20,10 +20,9 @@ from wandb.util import add_import_hook
 
 def _check_keras_version():
     from keras import __version__ as keras_version
+    from packaging.version import parse
 
-    from wandb.util import parse_version
-
-    if parse_version(keras_version) < parse_version("2.4.0"):
+    if parse(keras_version) < parse("2.4.0"):
         wandb.termwarn(
             f"Keras version {keras_version} is not fully supported. Required keras >= 2.4.0"
         )
@@ -31,9 +30,9 @@ def _check_keras_version():
 
 def _can_compute_flops() -> bool:
     """FLOPS computation is restricted to TF 2.x as it requires tf.compat.v1."""
-    from wandb.util import parse_version
+    from packaging.version import parse
 
-    if parse_version(tf.__version__) >= parse_version("2.0.0"):
+    if parse(tf.__version__) >= parse("2.0.0"):
         return True
 
     return False
@@ -75,15 +74,10 @@ def is_generator_like(data):
 
 
 def patch_tf_keras():  # noqa: C901
+    from packaging.version import parse
     from tensorflow.python.eager import context
 
-    from wandb.util import parse_version
-
-    if (
-        parse_version("2.6.0")
-        <= parse_version(tf.__version__)
-        < parse_version("2.13.0")
-    ):
+    if parse("2.6.0") <= parse(tf.__version__) < parse("2.13.0"):
         keras_engine = "keras.engine"
         try:
             from keras.engine import training
@@ -238,9 +232,9 @@ patch_tf_keras()
 
 
 def _get_custom_optimizer_parent_class():
-    from wandb.util import parse_version
+    from packaging.version import parse
 
-    if parse_version(tf.__version__) >= parse_version("2.9.0"):
+    if parse(tf.__version__) >= parse("2.9.0"):
         custom_optimizer_parent_class = tf.keras.optimizers.legacy.Optimizer
     else:
         custom_optimizer_parent_class = tf.keras.optimizers.Optimizer
@@ -734,9 +728,9 @@ class WandbCallback(tf.keras.callbacks.Callback):
         if self.compute_flops and _can_compute_flops():
             try:
                 wandb.summary["GFLOPs"] = self.get_flops()
-            except Exception as e:
+            except Exception:
+                logger.exception("Error computing FLOPs")
                 wandb.termwarn("Unable to compute FLOPs for this model.")
-                logger.exception(e)
 
     def on_train_end(self, logs=None):
         if self._model_trained_since_last_eval:
@@ -1018,12 +1012,12 @@ class WandbCallback(tf.keras.callbacks.Callback):
                 self.model.save(self.filepath, overwrite=True)
         # Was getting `RuntimeError: Unable to create link` in TF 1.13.1
         # also saw `TypeError: can't pickle _thread.RLock objects`
-        except (ImportError, RuntimeError, TypeError, AttributeError) as e:
+        except (ImportError, RuntimeError, TypeError, AttributeError):
+            logger.exception("Error saving model in the h5py format")
             wandb.termerror(
                 "Can't save model in the h5py format. The model will be saved as "
                 "as an W&B Artifact in the 'tf' format."
             )
-            logger.exception(e)
 
     def _save_model_as_artifact(self, epoch):
         if wandb.run.disabled:
@@ -1054,7 +1048,7 @@ class WandbCallback(tf.keras.callbacks.Callback):
         if not isinstance(
             self.model, (tf.keras.models.Sequential, tf.keras.models.Model)
         ):
-            raise ValueError(
+            raise TypeError(
                 "Calculating FLOPS is only supported for "
                 "`tf.keras.Model` and `tf.keras.Sequential` instances."
             )

wandb/integration/kfp/kfp_patch.py

@@ -10,12 +10,11 @@ try:
     from kfp.components import structures
     from kfp.components._components import _create_task_factory_from_component_spec
     from kfp.components._python_op import _func_to_component_spec
-
-    from wandb.util import parse_version
+    from packaging.version import parse
 
     MIN_KFP_VERSION = "1.6.1"
 
-    if parse_version(kfp_version) < parse_version(MIN_KFP_VERSION):
+    if parse(kfp_version) < parse(MIN_KFP_VERSION):
         wandb.termwarn(
             f"Your version of kfp {kfp_version} may not work.  This integration requires kfp>={MIN_KFP_VERSION}"
         )

wandb/integration/langchain/wandb_tracer.py

@@ -34,7 +34,7 @@ if version.parse(langchain.__version__) < version.parse("0.0.188"):
     )
 
 # isort: off
-from langchain.callbacks.tracers import WandbTracer  # noqa: E402, I001
+from langchain.callbacks.tracers import WandbTracer  # noqa: E402
 
 
 class WandbTracer(WandbTracer):

wandb/integration/metaflow/metaflow.py

@@ -37,7 +37,7 @@ except ImportError as e:
 try:
     import pandas as pd
 
-    @dispatch  # noqa: F811
+    @dispatch
     def _wandb_use(
         name: str,
         data: pd.DataFrame,
@@ -54,7 +54,7 @@ try:
             run.use_artifact(f"{name}:latest")
             wandb.termlog(f"Using artifact: {name} ({type(data)})")
 
-    @dispatch  # noqa: F811
+    @dispatch
     def wandb_track(
         name: str,
         data: pd.DataFrame,
@@ -83,7 +83,7 @@ try:
     import torch
     import torch.nn as nn
 
-    @dispatch  # noqa: F811
+    @dispatch
     def _wandb_use(
         name: str,
         data: nn.Module,
@@ -100,7 +100,7 @@ try:
             run.use_artifact(f"{name}:latest")
             wandb.termlog(f"Using artifact: {name} ({type(data)})")
 
-    @dispatch  # noqa: F811
+    @dispatch
     def wandb_track(
         name: str,
         data: nn.Module,
@@ -128,7 +128,7 @@ except ImportError:
 try:
     from sklearn.base import BaseEstimator
 
-    @dispatch  # noqa: F811
+    @dispatch
     def _wandb_use(
         name: str,
         data: BaseEstimator,
@@ -145,7 +145,7 @@ try:
             run.use_artifact(f"{name}:latest")
             wandb.termlog(f"Using artifact: {name} ({type(data)})")
 
-    @dispatch  # noqa: F811
+    @dispatch
     def wandb_track(
         name: str,
         data: BaseEstimator,
@@ -194,7 +194,7 @@ class ArtifactProxy:
         return getattr(self.flow, key)
 
 
-@dispatch  # noqa: F811
+@dispatch
 def wandb_track(
     name: str,
     data: Union[dict, list, set, str, int, float, bool],
@@ -209,7 +209,7 @@ def wandb_track(
     run.log({name: data})
 
 
-@dispatch  # noqa: F811
+@dispatch
 def wandb_track(
     name: str, data: Path, datasets=False, run=None, testing=False, *args, **kwargs
 ):
@@ -227,7 +227,7 @@ def wandb_track(
 
 
 # this is the base case
-@dispatch  # noqa: F811
+@dispatch
 def wandb_track(
     name: str, data, others=False, run=None, testing=False, *args, **kwargs
 ):
@@ -242,7 +242,7 @@ def wandb_track(
         wandb.termlog(f"Logging artifact: {name} ({type(data)})")
 
 
-@dispatch  # noqa: F811
+@dispatch
 def wandb_use(name: str, data, *args, **kwargs):
     try:
         return _wandb_use(name, data, *args, **kwargs)
@@ -254,14 +254,14 @@ def wandb_use(name: str, data, *args, **kwargs):
         )
 
 
-@dispatch  # noqa: F811
+@dispatch
 def wandb_use(
     name: str, data: Union[dict, list, set, str, int, float, bool], *args, **kwargs
 ):  # type: ignore
     pass  # do nothing for these types
 
 
-@dispatch  # noqa: F811
+@dispatch
 def _wandb_use(
     name: str, data: Path, datasets=False, run=None, testing=False, *args, **kwargs
 ):  # type: ignore
@@ -273,7 +273,7 @@ def _wandb_use(
         wandb.termlog(f"Using artifact: {name} ({type(data)})")
 
 
-@dispatch  # noqa: F811
+@dispatch
 def _wandb_use(name: str, data, others=False, run=None, testing=False, *args, **kwargs):  # type: ignore
     if testing:
         return "others" if others else None

wandb/integration/openai/fine_tuning.py

@@ -8,12 +8,13 @@ import tempfile
 import time
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+from packaging.version import parse
+
 import wandb
 from wandb import util
 from wandb.data_types import Table
 from wandb.sdk.lib import telemetry
 from wandb.sdk.wandb_run import Run
-from wandb.util import parse_version
 
 openai = util.get_module(
     name="openai",
@@ -21,7 +22,7 @@ openai = util.get_module(
     lazy=False,
 )
 
-if parse_version(openai.__version__) < parse_version("1.12.0"):
+if parse(openai.__version__) < parse("1.12.0"):
     raise wandb.Error(
         f"This integration requires openai version 1.12.0 and above. Your current version is {openai.__version__} "
         "To fix, please `pip install -U openai`"

wandb/integration/sagemaker/auth.py

@@ -2,6 +2,7 @@ import os
 
 import wandb
 from wandb import env
+from wandb.sdk import wandb_setup
 
 
 def sagemaker_auth(overrides=None, path=".", api_key=None):
@@ -12,7 +13,7 @@ def sagemaker_auth(overrides=None, path=".", api_key=None):
                                     to secrets.env
         path (str, optional): The path to write the secrets file.
     """
-    settings = wandb.setup().settings
+    settings = wandb_setup.singleton().settings
     current_api_key = wandb.wandb_lib.apikey.api_key(settings=settings)
 
     overrides = overrides or dict()

wandb/integration/sklearn/utils.py

@@ -114,10 +114,11 @@ def test_fitted(model):
                 ],
                 all_or_any=any,
             )
-            return True
         except sklearn.exceptions.NotFittedError:
             wandb.termerror("Please fit the model before passing it in.")
             return False
+        else:
+            return True
     except Exception:
         # Assume it's fitted, since ``NotFittedError`` wasn't raised
         return True

wandb/integration/tensorboard/__init__.py

@@ -1,6 +1,6 @@
 """wandb integration tensorboard module."""
 
-from .log import _log, log, reset_state, tf_summary_to_dict  # noqa: F401
+from .log import _log, log, reset_state, tf_summary_to_dict
 from .monkeypatch import patch, unpatch
 
 __all__ = [

wandb/integration/tensorboard/log.py

@@ -167,11 +167,8 @@ def tf_summary_to_dict(  # noqa: C901
                         )
                     except ValueError:
                         wandb.termwarn(
-                            'Not logging key "{}". '
-                            "Histograms must have fewer than {} bins".format(
-                                namespaced_tag(value.tag, namespace),
-                                wandb.Histogram.MAX_LENGTH,
-                            ),
+                            f'Not logging key "{namespaced_tag(value.tag, namespace)}". '
+                            f"Histograms must have fewer than {wandb.Histogram.MAX_LENGTH} bins",
                             repeat=False,
                         )
             elif plugin_name == "pr_curves":

wandb/integration/tensorflow/__init__.py

@@ -1,5 +1,5 @@
 """api."""
 
-from wandb.integration.tensorboard import log  # noqa: F401
+from wandb.integration.tensorboard import log
 
-from .estimator_hook import WandbHook  # noqa: F401
+from .estimator_hook import WandbHook

wandb/jupyter.py

@@ -148,7 +148,7 @@ class WandBMagics(Magics):
         if path:
             _display_by_wandb_path(path, height=height)
             displayed = True
-        elif run := wandb_setup._setup(start_service=False).most_recent_active_run:
+        elif run := wandb_setup.singleton().most_recent_active_run:
             _display_wandb_run(run, height=height)
             displayed = True
         else:
@@ -246,12 +246,11 @@ def notebook_metadata(silent: bool) -> dict[str, str]:
 
         if jupyter_metadata:
             return jupyter_metadata
-        wandb.termerror(error_message)
-        return {}
     except Exception:
-        wandb.termerror(error_message)
         logger.exception(error_message)
-        return {}
+
+    wandb.termerror(error_message)
+    return {}
 
 
 def jupyter_servers_and_kernel_id():
@@ -273,10 +272,11 @@ def jupyter_servers_and_kernel_id():
             servers.extend(list(serverapp.list_running_servers()))
         if notebookapp is not None:
             servers.extend(list(notebookapp.list_running_servers()))
-        return servers, kernel_id
     except (AttributeError, ValueError, ImportError):
         return [], None
 
+    return servers, kernel_id
+
 
 def attempt_colab_load_ipynb():
     colab = wandb.util.get_module("google.colab")
@@ -289,17 +289,20 @@ def attempt_colab_load_ipynb():
 
 def attempt_kaggle_load_ipynb():
     kaggle = wandb.util.get_module("kaggle_session")
-    if kaggle:
-        try:
-            client = kaggle.UserSessionClient()
-            parsed = json.loads(client.get_exportable_ipynb()["source"])
-            # TODO: couldn't find a way to get the name of the notebook...
-            parsed["metadata"]["name"] = "kaggle.ipynb"
-            return parsed
-        except Exception:
-            wandb.termerror("Unable to load kaggle notebook.")
-            logger.exception("Unable to load kaggle notebook.")
-            return None
+    if not kaggle:
+        return None
+
+    try:
+        client = kaggle.UserSessionClient()
+        parsed = json.loads(client.get_exportable_ipynb()["source"])
+        # TODO: couldn't find a way to get the name of the notebook...
+        parsed["metadata"]["name"] = "kaggle.ipynb"
+    except Exception:
+        wandb.termerror("Unable to load kaggle notebook.")
+        logger.exception("Unable to load kaggle notebook.")
+        return None
+
+    return parsed
 
 
 def attempt_colab_login(

wandb/plot/confusion_matrix.py

@@ -150,7 +150,7 @@ def confusion_matrix(
     else:
         class_idx = set(preds).union(set(y_true))
         n_classes = len(class_idx)
-        class_names = [f"Class_{i+1}" for i in range(n_classes)]
+        class_names = [f"Class_{i + 1}" for i in range(n_classes)]
 
     # Create a mapping from class name to index
     class_mapping = {val: i for i, val in enumerate(sorted(list(class_idx)))}

wandb/plot/utils.py

@@ -13,7 +13,7 @@ def test_missing(**kwargs):
     for k, v in kwargs.items():
         # Missing/empty params/datapoint arrays
         if v is None:
-            wandb.termerror("{} is None. Please try again.".format(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):
@@ -98,10 +98,11 @@ def test_fitted(model):
                 ],
                 all_or_any=any,
             )
-            return True
         except scikit_exceptions.NotFittedError:
             wandb.termerror("Please fit the model before passing it in.")
             return False
+        else:
+            return True
     except Exception:
         # Assume it's fitted, since ``NotFittedError`` wasn't raised
         return True
@@ -159,25 +160,25 @@ def test_types(**kwargs):
                     list,
                 ),
             ):
-                wandb.termerror("{} is not an array. Please try again.".format(k))
+                wandb.termerror(f"{k} is not an array. Please try again.")
                 test_passed = False
         # check for classifier types
         if k == "model":
             if (not base.is_classifier(v)) and (not base.is_regressor(v)):
                 wandb.termerror(
-                    "{} is not a classifier or regressor. Please try again.".format(k)
+                    f"{k} is not a classifier or regressor. Please try again."
                 )
                 test_passed = False
         elif k == "clf" or k == "binary_clf":
             if not (base.is_classifier(v)):
-                wandb.termerror("{} is not a classifier. Please try again.".format(k))
+                wandb.termerror(f"{k} is not a classifier. Please try again.")
                 test_passed = False
         elif k == "regressor":
             if not base.is_regressor(v):
-                wandb.termerror("{} is not a regressor. Please try again.".format(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("{} is not a clusterer. Please try again.".format(k))
+                wandb.termerror(f"{k} is not a clusterer. Please try again.")
                 test_passed = False
     return test_passed