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

wandb/env.py

@@ -13,7 +13,6 @@ these values in many cases.
 import json
 import os
 import sys
-from distutils.util import strtobool
 from pathlib import Path
 from typing import List, MutableMapping, Optional, Union
 
@@ -61,6 +60,8 @@ 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"
 AGENT_KILL_DELAY = "WANDB_AGENT_KILL_DELAY"
@@ -87,6 +88,7 @@ _EXECUTABLE = "WANDB_EXECUTABLE"
 LAUNCH_QUEUE_NAME = "WANDB_LAUNCH_QUEUE_NAME"
 LAUNCH_QUEUE_ENTITY = "WANDB_LAUNCH_QUEUE_ENTITY"
 LAUNCH_TRACE_ID = "WANDB_LAUNCH_TRACE_ID"
+_REQUIRE_CORE = "WANDB__REQUIRE_CORE"
 
 # For testing, to be removed in future version
 USE_V1_ARTIFACTS = "_WANDB_USE_V1_ARTIFACTS"
@@ -139,11 +141,16 @@ def _env_as_bool(
     if env is None:
         env = os.environ
     val = env.get(var, default)
+    if not isinstance(val, str):
+        return False
     try:
-        val = bool(strtobool(val))  # type: ignore
-    except (AttributeError, ValueError):
-        pass
-    return val if isinstance(val, bool) else False
+        return strtobool(val)
+    except ValueError:
+        return False
+
+
+def is_require_core(env: Optional[Env] = None) -> bool:
+    return _env_as_bool(_REQUIRE_CORE, default="False", env=env)
 
 
 def is_debug(default: Optional[str] = None, env: Optional[Env] = None) -> bool:
@@ -154,6 +161,14 @@ 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)
+
+
 def ssl_disabled() -> bool:
     return _env_as_bool(DISABLE_SSL, default="False")
 
@@ -464,3 +479,18 @@ def get_launch_trace_id(env: Optional[Env] = None) -> Optional[str]:
         env = os.environ
     val = env.get(LAUNCH_TRACE_ID, None)
     return val
+
+
+def strtobool(val: str) -> bool:
+    """Convert a string representation of truth to true or false.
+
+    Copied from distutils. distutils was removed in Python 3.12.
+    """
+    val = val.lower()
+
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return True
+    elif val in ("n", "no", "f", "false", "off", "0"):
+        return False
+    else:
+        raise ValueError(f"invalid truth value {val!r}")

wandb/errors/__init__.py

@@ -4,6 +4,7 @@ __all__ = [
     "AuthenticationError",
     "UsageError",
     "UnsupportedError",
+    "WandbCoreNotAvailableError",
 ]
 
 from typing import Optional
@@ -39,3 +40,7 @@ class UsageError(Error):
 
 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/integration/catboost/catboost.py

@@ -81,7 +81,7 @@ def _checkpoint_artifact(
 
 
 def _log_feature_importance(
-    model: Union[CatBoostClassifier, CatBoostRegressor]
+    model: Union[CatBoostClassifier, CatBoostRegressor],
 ) -> None:
     """Log feature importance with default settings."""
     if wandb.run is None:

wandb/integration/fastai/__init__.py

@@ -35,6 +35,7 @@ Examples:
         learn.fit(..., callbacks=WandbCallback(learn, ...))
     ```
 """
+
 import random
 import sys
 from pathlib import Path

wandb/integration/keras/__init__.py

@@ -2,6 +2,7 @@
 
 Keras is a deep learning API for [`TensorFlow`](https://www.tensorflow.org/).
 """
+
 __all__ = (
     "WandbCallback",
     "WandbMetricsLogger",

wandb/integration/keras/keras.py

@@ -616,9 +616,9 @@ class WandbCallback(tf.keras.callbacks.Callback):
         self.current = logs.get(self.monitor)
         if self.current and self.monitor_op(self.current, self.best):
             if self.log_best_prefix:
-                wandb.run.summary[
-                    f"{self.log_best_prefix}{self.monitor}"
-                ] = self.current
+                wandb.run.summary[f"{self.log_best_prefix}{self.monitor}"] = (
+                    self.current
+                )
                 wandb.run.summary["{}{}".format(self.log_best_prefix, "epoch")] = epoch
                 if self.verbose and not self.save_model:
                     print(
@@ -937,9 +937,9 @@ class WandbCallback(tf.keras.callbacks.Callback):
         grads = self._grad_accumulator_callback.grads
         metrics = {}
         for weight, grad in zip(weights, grads):
-            metrics[
-                "gradients/" + weight.name.split(":")[0] + ".gradient"
-            ] = wandb.Histogram(grad)
+            metrics["gradients/" + weight.name.split(":")[0] + ".gradient"] = (
+                wandb.Histogram(grad)
+            )
         return metrics
 
     def _log_dataframe(self):

wandb/integration/langchain/wandb_tracer.py

@@ -14,6 +14,7 @@ integration will not break user code. The one exception to the rule is at import
 LangChain is not installed, or the symbols are not in the same place, the appropriate error
 will be raised when importing this module.
 """
+
 from packaging import version
 
 import wandb.util

wandb/integration/lightning/fabric/logger.py

@@ -401,9 +401,7 @@ class WandbLogger(Logger):
                         "*", step_metric="trainer/global_step", step_sync=True
                     )
 
-        self._experiment._label(
-            repo="lightning_fabric_logger"
-        )  # pylint: disable=protected-access
+        self._experiment._label(repo="lightning_fabric_logger")  # pylint: disable=protected-access
         with telemetry.context(run=self._experiment) as tel:
             tel.feature.lightning_fabric_logger = True
         return self._experiment

wandb/integration/metaflow/metaflow.py

@@ -36,7 +36,15 @@ try:
     import pandas as pd
 
     @typedispatch  # noqa: F811
-    def _wandb_use(name: str, data: pd.DataFrame, datasets=False, run=None, testing=False, *args, **kwargs):  # type: ignore
+    def _wandb_use(
+        name: str,
+        data: pd.DataFrame,
+        datasets=False,
+        run=None,
+        testing=False,
+        *args,
+        **kwargs,
+    ):  # type: ignore
         if testing:
             return "datasets" if datasets else None
 
@@ -74,7 +82,15 @@ try:
     import torch.nn as nn
 
     @typedispatch  # noqa: F811
-    def _wandb_use(name: str, data: nn.Module, models=False, run=None, testing=False, *args, **kwargs):  # type: ignore
+    def _wandb_use(
+        name: str,
+        data: nn.Module,
+        models=False,
+        run=None,
+        testing=False,
+        *args,
+        **kwargs,
+    ):  # type: ignore
         if testing:
             return "models" if models else None
 
@@ -111,7 +127,15 @@ try:
     from sklearn.base import BaseEstimator
 
     @typedispatch  # noqa: F811
-    def _wandb_use(name: str, data: BaseEstimator, models=False, run=None, testing=False, *args, **kwargs):  # type: ignore
+    def _wandb_use(
+        name: str,
+        data: BaseEstimator,
+        models=False,
+        run=None,
+        testing=False,
+        *args,
+        **kwargs,
+    ):  # type: ignore
         if testing:
             return "models" if models else None
 
@@ -169,7 +193,14 @@ class ArtifactProxy:
 
 
 @typedispatch  # noqa: F811
-def wandb_track(name: str, data: (dict, list, set, str, int, float, bool), run=None, testing=False, *args, **kwargs):  # type: ignore
+def wandb_track(
+    name: str,
+    data: (dict, list, set, str, int, float, bool),
+    run=None,
+    testing=False,
+    *args,
+    **kwargs,
+):  # type: ignore
     if testing:
         return "scalar"
 
@@ -222,12 +253,16 @@ def wandb_use(name: str, data, *args, **kwargs):
 
 
 @typedispatch  # noqa: F811
-def wandb_use(name: str, data: (dict, list, set, str, int, float, bool), *args, **kwargs):  # type: ignore
+def wandb_use(
+    name: str, data: (dict, list, set, str, int, float, bool), *args, **kwargs
+):  # type: ignore
     pass  # do nothing for these types
 
 
 @typedispatch  # noqa: F811
-def _wandb_use(name: str, data: Path, datasets=False, run=None, testing=False, *args, **kwargs):  # type: ignore
+def _wandb_use(
+    name: str, data: Path, datasets=False, run=None, testing=False, *args, **kwargs
+):  # type: ignore
     if testing:
         return "datasets" if datasets else None
 

wandb/integration/openai/fine_tuning.py

@@ -1,9 +1,11 @@
 import datetime
 import io
 import json
+import os
 import re
+import tempfile
 import time
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import wandb
 from wandb import util
@@ -26,7 +28,10 @@ if parse_version(openai.__version__) < parse_version("1.0.1"):
 
 from openai import OpenAI  # noqa: E402
 from openai.types.fine_tuning import FineTuningJob  # noqa: E402
-from openai.types.fine_tuning.fine_tuning_job import Hyperparameters  # noqa: E402
+from openai.types.fine_tuning.fine_tuning_job import (  # noqa: E402
+    Error,
+    Hyperparameters,
+)
 
 np = util.get_module(
     name="numpy",
@@ -59,6 +64,7 @@ class WandbLogger:
         entity: Optional[str] = None,
         overwrite: bool = False,
         wait_for_job_success: bool = True,
+        log_datasets: bool = True,
         **kwargs_wandb_init: Dict[str, Any],
     ) -> str:
         """Sync fine-tunes to Weights & Biases.
@@ -150,6 +156,7 @@ class WandbLogger:
                 entity,
                 overwrite,
                 show_individual_warnings,
+                log_datasets,
                 **kwargs_wandb_init,
             )
 
@@ -160,11 +167,14 @@ class WandbLogger:
 
     @classmethod
     def _wait_for_job_success(cls, fine_tune: FineTuningJob) -> FineTuningJob:
-        wandb.termlog("Waiting for the OpenAI fine-tuning job to be finished...")
+        wandb.termlog("Waiting for the OpenAI fine-tuning job to finish training...")
+        wandb.termlog(
+            "To avoid blocking, you can call `WandbLogger.sync` with `wait_for_job_success=False` after OpenAI training completes."
+        )
         while True:
             if fine_tune.status == "succeeded":
                 wandb.termlog(
-                    "Fine-tuning finished, logging metrics, model metadata, and more to W&B"
+                    "Fine-tuning finished, logging metrics, model metadata, and run metadata to Weights & Biases"
                 )
                 return fine_tune
             if fine_tune.status == "failed":
@@ -190,6 +200,7 @@ class WandbLogger:
         entity: Optional[str],
         overwrite: bool,
         show_individual_warnings: bool,
+        log_datasets: bool,
         **kwargs_wandb_init: Dict[str, Any],
     ):
         fine_tune_id = fine_tune.id
@@ -209,7 +220,7 @@ class WandbLogger:
         # check results are present
         try:
             results_id = fine_tune.result_files[0]
-            results = cls.openai_client.files.retrieve_content(file_id=results_id)
+            results = cls.openai_client.files.content(file_id=results_id).text
         except openai.NotFoundError:
             if show_individual_warnings:
                 wandb.termwarn(
@@ -233,7 +244,7 @@ class WandbLogger:
             cls._run.summary["fine_tuned_model"] = fine_tuned_model
 
         # training/validation files and fine-tune details
-        cls._log_artifacts(fine_tune, project, entity)
+        cls._log_artifacts(fine_tune, project, entity, log_datasets, overwrite)
 
         # mark run as complete
         cls._run.summary["status"] = "succeeded"
@@ -249,7 +260,7 @@ class WandbLogger:
             else:
                 raise Exception(
                     "It appears you are not currently logged in to Weights & Biases. "
-                    "Please run `wandb login` in your terminal. "
+                    "Please run `wandb login` in your terminal or `wandb.login()` in a notebook."
                     "When prompted, you can obtain your API key by visiting wandb.ai/authorize."
                 )
 
@@ -286,15 +297,9 @@ class WandbLogger:
                 config["finished_at"]
             ).strftime("%Y-%m-%d %H:%M:%S")
         if config.get("hyperparameters"):
-            hyperparameters = config.pop("hyperparameters")
-            hyperparams = cls._unpack_hyperparameters(hyperparameters)
-            if hyperparams is None:
-                # If unpacking fails, log the object which will render as string
-                config["hyperparameters"] = hyperparameters
-            else:
-                # nested rendering on hyperparameters
-                config["hyperparameters"] = hyperparams
-
+            config["hyperparameters"] = cls.sanitize(config["hyperparameters"])
+        if config.get("error"):
+            config["error"] = cls.sanitize(config["error"])
         return config
 
     @classmethod
@@ -305,30 +310,53 @@ class WandbLogger:
         try:
             hyperparams["n_epochs"] = hyperparameters.n_epochs
             hyperparams["batch_size"] = hyperparameters.batch_size
-            hyperparams[
-                "learning_rate_multiplier"
-            ] = hyperparameters.learning_rate_multiplier
+            hyperparams["learning_rate_multiplier"] = (
+                hyperparameters.learning_rate_multiplier
+            )
         except Exception:
             # If unpacking fails, return the object to be logged as config
             return None
 
         return hyperparams
 
+    @staticmethod
+    def sanitize(input: Any) -> Union[Dict, List, str]:
+        valid_types = [bool, int, float, str]
+        if isinstance(input, (Hyperparameters, Error)):
+            return dict(input)
+        if isinstance(input, dict):
+            return {
+                k: v if type(v) in valid_types else str(v) for k, v in input.items()
+            }
+        elif isinstance(input, list):
+            return [v if type(v) in valid_types else str(v) for v in input]
+        else:
+            return str(input)
+
     @classmethod
     def _log_artifacts(
-        cls, fine_tune: FineTuningJob, project: str, entity: Optional[str]
+        cls,
+        fine_tune: FineTuningJob,
+        project: str,
+        entity: Optional[str],
+        log_datasets: bool,
+        overwrite: bool,
     ) -> None:
-        # training/validation files
-        training_file = fine_tune.training_file if fine_tune.training_file else None
-        validation_file = (
-            fine_tune.validation_file if fine_tune.validation_file else None
-        )
-        for file, prefix, artifact_type in (
-            (training_file, "train", "training_files"),
-            (validation_file, "valid", "validation_files"),
-        ):
-            if file is not None:
-                cls._log_artifact_inputs(file, prefix, artifact_type, project, entity)
+        if log_datasets:
+            wandb.termlog("Logging training/validation files...")
+            # training/validation files
+            training_file = fine_tune.training_file if fine_tune.training_file else None
+            validation_file = (
+                fine_tune.validation_file if fine_tune.validation_file else None
+            )
+            for file, prefix, artifact_type in (
+                (training_file, "train", "training_files"),
+                (validation_file, "valid", "validation_files"),
+            ):
+                if file is not None:
+                    cls._log_artifact_inputs(
+                        file, prefix, artifact_type, project, entity, overwrite
+                    )
 
         # fine-tune details
         fine_tune_id = fine_tune.id
@@ -337,9 +365,14 @@ class WandbLogger:
             type="model",
             metadata=dict(fine_tune),
         )
+
         with artifact.new_file("model_metadata.json", mode="w", encoding="utf-8") as f:
             dict_fine_tune = dict(fine_tune)
-            dict_fine_tune["hyperparameters"] = dict(dict_fine_tune["hyperparameters"])
+            dict_fine_tune["hyperparameters"] = cls.sanitize(
+                dict_fine_tune["hyperparameters"]
+            )
+            dict_fine_tune["error"] = cls.sanitize(dict_fine_tune["error"])
+            dict_fine_tune = cls.sanitize(dict_fine_tune)
             json.dump(dict_fine_tune, f, indent=2)
         cls._run.log_artifact(
             artifact,
@@ -354,6 +387,7 @@ class WandbLogger:
         artifact_type: str,
         project: str,
         entity: Optional[str],
+        overwrite: bool,
     ) -> None:
         # get input artifact
         artifact_name = f"{prefix}-{file_id}"
@@ -366,23 +400,26 @@ class WandbLogger:
         artifact = cls._get_wandb_artifact(artifact_path)
 
         # create artifact if file not already logged previously
-        if artifact is None:
+        if artifact is None or overwrite:
             # get file content
             try:
-                file_content = cls.openai_client.files.retrieve_content(file_id=file_id)
+                file_content = cls.openai_client.files.content(file_id=file_id)
             except openai.NotFoundError:
                 wandb.termerror(
-                    f"File {file_id} could not be retrieved. Make sure you are allowed to download training/validation files"
+                    f"File {file_id} could not be retrieved. Make sure you have OpenAI permissions to download training/validation files"
                 )
                 return
 
             artifact = wandb.Artifact(artifact_name, type=artifact_type)
-            with artifact.new_file(file_id, mode="w", encoding="utf-8") as f:
-                f.write(file_content)
+            with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
+                tmp_file.write(file_content.content)
+                tmp_file_path = tmp_file.name
+            artifact.add_file(tmp_file_path, file_id)
+            os.unlink(tmp_file_path)
 
             # create a Table
             try:
-                table, n_items = cls._make_table(file_content)
+                table, n_items = cls._make_table(file_content.text)
                 # Add table to the artifact.
                 artifact.add(table, file_id)
                 # Add the same table to the workspace.
@@ -390,9 +427,9 @@ class WandbLogger:
                 # Update the run config and artifact metadata
                 cls._run.config.update({f"n_{prefix}": n_items})
                 artifact.metadata["items"] = n_items
-            except Exception:
+            except Exception as e:
                 wandb.termerror(
-                    f"File {file_id} could not be read as a valid JSON file"
+                    f"Issue saving {file_id} as a Table to Artifacts, exception:\n  '{e}'"
                 )
         else:
             # log number of items

wandb/keras/__init__.py

@@ -3,6 +3,7 @@
 In the future use e.g.:
     from wandb.integration.keras import WandbCallback
 """
+
 __all__ = (
     "WandbCallback",
     "WandbMetricsLogger",