wandb 0.16.4__py3-none-any.whl → 0.16.6__py3-none-any.whl

wandb/__init__.py

@@ -11,8 +11,8 @@ For scripts and interactive notebooks, see https://github.com/wandb/examples.
 
 For reference documentation, see https://docs.wandb.com/ref/python.
 """
-__version__ = "0.16.4"
-_minimum_core_version = "0.17.0b9"
+__version__ = "0.16.6"
+_minimum_core_version = "0.17.0b10"
 
 # Used with pypi checks and other messages related to pip
 _wandb_module = "wandb"

wandb/agents/pyagent.py

@@ -347,7 +347,7 @@ def pyagent(sweep_id, function, entity=None, project=None, count=None):
         count (int, optional): the number of trials to run.
     """
     if not callable(function):
-        raise Exception("function paramter must be callable!")
+        raise Exception("function parameter must be callable!")
     agent = Agent(
         sweep_id,
         function=function,

wandb/apis/public/api.py

@@ -313,15 +313,15 @@ class Api:
             entity: (str) Optional name of the entity to create the queue. If None, will use the configured or default entity.
             prioritization_mode: (str) Optional version of prioritization to use. Either "V0" or None
             config: (dict) Optional default resource configuration to be used for the queue. Use handlebars (eg. "{{var}}") to specify template variables.
-            template_variables (dict): A dictionary of template variable schemas to be used with the config. Expected format of:
+            template_variables: (dict) A dictionary of template variable schemas to be used with the config. Expected format of:
                 {
                     "var-name": {
                         "schema": {
-                            "type": "<string | number | integer>",
-                            "default": <optional value>,
-                            "minimum": <optional minimum>,
-                            "maximum": <optional maximum>,
-                            "enum": [..."<options>"]
+                            "type": ("string", "number", or "integer"),
+                            "default": (optional value),
+                            "minimum": (optional minimum),
+                            "maximum": (optional maximum),
+                            "enum": [..."(options)"]
                         }
                     }
                 }

wandb/apis/reports/v2/interface.py

@@ -4,6 +4,8 @@ from datetime import datetime
 from typing import Dict, Iterable, Optional, Tuple, Union
 from typing import List as LList
 
+from annotated_types import Annotated, Ge, Le
+
 try:
     from typing import Literal
 except ImportError:
@@ -758,14 +760,8 @@ block_mapping = {
 
 @dataclass(config=dataclass_config)
 class GradientPoint(Base):
-    color: str
-    offset: float = Field(0, ge=0, le=100)
-
-    @validator("color")
-    def validate_color(cls, v):  # noqa: N805
-        if not internal.is_valid_color(v):
-            raise ValueError("invalid color, value should be hex, rgb, or rgba")
-        return v
+    color: Annotated[str, internal.ColorStrConstraints]
+    offset: Annotated[float, Ge(0), Le(100)] = 0
 
     def to_model(self):
         return internal.GradientPoint(color=self.color, offset=self.offset)

wandb/apis/reports/v2/internal.py

@@ -1,18 +1,19 @@
 """JSONSchema for internal types.  Hopefully this is auto-generated one day!"""
 import json
 import random
-import re
 from copy import deepcopy
 from datetime import datetime
 from typing import Any, Dict, Optional, Tuple, Union
 from typing import List as LList
 
+from annotated_types import Annotated, Ge, Le
+
 try:
     from typing import Literal
 except ImportError:
     from typing_extensions import Literal
 
-from pydantic import BaseModel, ConfigDict, Field, validator
+from pydantic import BaseModel, ConfigDict, Field, StringConstraints, validator
 from pydantic.alias_generators import to_camel
 
 
@@ -48,6 +49,13 @@ def _generate_name(length: int = 12) -> str:
     return rand36.lower()[:length]
 
 
+hex_pattern = r"^#(?:[0-9a-fA-F]{3}){1,2}$"
+rgb_pattern = r"^rgb\(\s*(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\s*,\s*(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\s*,\s*(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\s*\)$"
+rgba_pattern = r"^rgba\(\s*(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\s*,\s*(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\s*,\s*(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\s*,\s*(1|0|0?\.\d+)\s*\)$"
+ColorStrConstraints = StringConstraints(
+    pattern=f"{hex_pattern}|{rgb_pattern}|{rgba_pattern}"
+)
+
 LinePlotStyle = Literal["line", "stacked-area", "pct-area"]
 BarPlotStyle = Literal["bar", "boxplot", "violin"]
 FontSize = Literal["small", "medium", "large", "auto"]
@@ -609,14 +617,8 @@ class LinePlot(Panel):
 
 
 class GradientPoint(ReportAPIBaseModel):
-    color: str
-    offset: float = Field(0, ge=0, le=100)
-
-    @validator("color")
-    def validate_color(cls, v):  # noqa: N805
-        if not is_valid_color(v):
-            raise ValueError("invalid color, value should be hex, rgb, or rgba")
-        return v
+    color: Annotated[str, ColorStrConstraints]
+    offset: Annotated[float, Ge(0), Le(100)] = 0
 
 
 class ScatterPlotConfig(ReportAPIBaseModel):
@@ -866,38 +868,3 @@ block_type_mapping = {
     "table-of-contents": TableOfContents,
     "block-quote": BlockQuote,
 }
-
-
-def is_valid_color(color_str: str) -> bool:
-    # Regular expression for hex color validation
-    hex_color_pattern = r"^#(?:[0-9a-fA-F]{3}){1,2}$"
-
-    # Check if it's a valid hex color
-    if re.match(hex_color_pattern, color_str):
-        return True
-
-    # Try parsing it as an RGB or RGBA tuple
-    try:
-        # Strip 'rgb(' or 'rgba(' and the closing ')'
-        if color_str.startswith("rgb(") and color_str.endswith(")"):
-            parts = color_str[4:-1].split(",")
-        elif color_str.startswith("rgba(") and color_str.endswith(")"):
-            parts = color_str[5:-1].split(",")
-        else:
-            return False
-
-        # Convert parts to integers and validate ranges
-        parts = [int(p.strip()) for p in parts]
-        if len(parts) == 3 and all(0 <= p <= 255 for p in parts):
-            return True  # Valid RGB
-        if (
-            len(parts) == 4
-            and all(0 <= p <= 255 for p in parts[:-1])
-            and 0 <= parts[-1] <= 1
-        ):
-            return True  # Valid RGBA
-
-    except ValueError:
-        pass
-
-    return False

wandb/cli/cli.py

@@ -1680,6 +1680,7 @@ def launch(
     hidden=True,
     help="a wandb client registration URL, this is generated in the UI",
 )
+@click.option("--verbose", "-v", count=True, help="Display verbose output")
 @display_error
 def launch_agent(
     ctx,
@@ -1690,6 +1691,7 @@ def launch_agent(
     config=None,
     url=None,
     log_file=None,
+    verbose=0,
 ):
     logger.info(
         f"=== Launch-agent called with kwargs {locals()}  CLI Version: {wandb.__version__} ==="
@@ -1707,7 +1709,7 @@ def launch_agent(
     api = _get_cling_api()
     wandb._sentry.configure_scope(process_context="launch_agent")
     agent_config, api = _launch.resolve_agent_config(
-        entity, project, max_jobs, queues, config
+        entity, project, max_jobs, queues, config, verbose
     )
 
     if len(agent_config.get("queues")) == 0:
@@ -1905,7 +1907,7 @@ def describe(job):
     "--entry-point",
     "-E",
     "entrypoint",
-    help="Codepath to the main script, required for repo jobs",
+    help="Entrypoint to the script, including an executable and an entrypoint file. Required for code or repo jobs",
 )
 @click.option(
     "--git-hash",
@@ -2345,8 +2347,30 @@ def artifact():
     default=None,
     help="Resume the last run from your current directory.",
 )
+@click.option(
+    "--skip_cache",
+    is_flag=True,
+    default=False,
+    help="Skip caching while uploading artifact files.",
+)
+@click.option(
+    "--policy",
+    default="mutable",
+    type=click.Choice(["mutable", "immutable"]),
+    help="Set the storage policy while uploading artifact files.",
+)
 @display_error
-def put(path, name, description, type, alias, run_id, resume):
+def put(
+    path,
+    name,
+    description,
+    type,
+    alias,
+    run_id,
+    resume,
+    skip_cache,
+    policy,
+):
     if name is None:
         name = os.path.basename(path)
     public_api = PublicApi()
@@ -2361,10 +2385,10 @@ def put(path, name, description, type, alias, run_id, resume):
     artifact_path = f"{entity}/{project}/{artifact_name}:{alias[0]}"
     if os.path.isdir(path):
         wandb.termlog(f'Uploading directory {path} to: "{artifact_path}" ({type})')
-        artifact.add_dir(path)
+        artifact.add_dir(path, skip_cache=skip_cache, policy=policy)
     elif os.path.isfile(path):
         wandb.termlog(f'Uploading file {path} to: "{artifact_path}" ({type})')
-        artifact.add_file(path)
+        artifact.add_file(path, skip_cache=skip_cache, policy=policy)
     elif "://" in path:
         wandb.termlog(
             f'Logging reference artifact from {path} to: "{artifact_path}" ({type})'

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
@@ -314,21 +319,44 @@ class WandbLogger:
 
         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/integration/ultralytics/callback.py

@@ -321,7 +321,6 @@ class WandBUltralyticsCallback:
                     )
             if self.enable_model_checkpointing:
                 self._save_model(trainer)
-            self.model.to("cpu")
             trainer.model.to(self.device)
 
     def on_train_end(self, trainer: TRAINER_TYPE):