wandb 0.17.0rc2__py3-none-macosx_11_0_arm64.whl → 0.17.2__py3-none-macosx_11_0_arm64.whl

wandb/apis/public/projects.py

@@ -22,23 +22,22 @@ class Projects(Paginator):
 
     QUERY = gql(
         """
-        query Projects($entity: String, $cursor: String, $perPage: Int = 50) {
-            models(entityName: $entity, after: $cursor, first: $perPage) {
-                edges {
-                    node {
+        query Projects($entity: String, $cursor: String, $perPage: Int = 50) {{
+            models(entityName: $entity, after: $cursor, first: $perPage) {{
+                edges {{
+                    node {{
                         ...ProjectFragment
-                    }
+                    }}
                     cursor
-                }
-                pageInfo {
+                }}
+                pageInfo {{
                     endCursor
                     hasNextPage
-                }
-            }
-        }
-        %s
-        """
-        % PROJECT_FRAGMENT
+                }}
+            }}
+        }}
+        {}
+        """.format(PROJECT_FRAGMENT)
     )
 
     def __init__(self, client, entity, per_page=50):
@@ -118,26 +117,25 @@ class Project(Attrs):
     def sweeps(self):
         query = gql(
             """
-            query GetSweeps($project: String!, $entity: String!) {
-                project(name: $project, entityName: $entity) {
+            query GetSweeps($project: String!, $entity: String!) {{
+                project(name: $project, entityName: $entity) {{
                     totalSweeps
-                    sweeps {
-                        edges {
-                            node {
+                    sweeps {{
+                        edges {{
+                            node {{
                                 ...SweepFragment
-                            }
+                            }}
                             cursor
-                        }
-                        pageInfo {
+                        }}
+                        pageInfo {{
                             endCursor
                             hasNextPage
-                        }
-                    }
-                }
-            }
-            %s
-            """
-            % public.SWEEP_FRAGMENT
+                        }}
+                    }}
+                }}
+            }}
+            {}
+            """.format(public.SWEEP_FRAGMENT)
         )
         variable_values = {"project": self.name, "entity": self.entity}
         ret = self.client.execute(query, variable_values)

wandb/apis/public/query_generator.py

@@ -60,7 +60,7 @@ class QueryGenerator:
             return key["name"]
         elif key["section"] == "tags":
             return "tags." + key["name"]
-        raise ValueError("Invalid key: %s" % key)
+        raise ValueError("Invalid key: {}".format(key))
 
     def server_path_to_key(self, path):
         if path.startswith("config."):

wandb/apis/public/runs.py

@@ -2,10 +2,16 @@
 
 import json
 import os
+import sys
 import tempfile
 import time
 import urllib
-from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
 
 from wandb_gql import gql
 
@@ -60,27 +66,26 @@ class Runs(Paginator):
 
     QUERY = gql(
         """
-        query Runs($project: String!, $entity: String!, $cursor: String, $perPage: Int = 50, $order: String, $filters: JSONString) {
-            project(name: $project, entityName: $entity) {
+        query Runs($project: String!, $entity: String!, $cursor: String, $perPage: Int = 50, $order: String, $filters: JSONString) {{
+            project(name: $project, entityName: $entity) {{
                 runCount(filters: $filters)
                 readOnly
-                runs(filters: $filters, after: $cursor, first: $perPage, order: $order) {
-                    edges {
-                        node {
+                runs(filters: $filters, after: $cursor, first: $perPage, order: $order) {{
+                    edges {{
+                        node {{
                             ...RunFragment
-                        }
+                        }}
                         cursor
-                    }
-                    pageInfo {
+                    }}
+                    pageInfo {{
                         endCursor
                         hasNextPage
-                    }
-                }
-            }
-        }
-        %s
-        """
-        % RUN_FRAGMENT
+                    }}
+                }}
+            }}
+        }}
+        {}
+        """.format(RUN_FRAGMENT)
     )
 
     def __init__(
@@ -131,7 +136,7 @@ class Runs(Paginator):
     def convert_objects(self):
         objs = []
         if self.last_response is None or self.last_response.get("project") is None:
-            raise ValueError("Could not find project %s" % self.project)
+            raise ValueError("Could not find project {}".format(self.project))
         for run_response in self.last_response["project"]["runs"]["edges"]:
             run = Run(
                 self.client,
@@ -162,6 +167,104 @@ class Runs(Paginator):
 
         return objs
 
+    @normalize_exceptions
+    def histories(
+        self,
+        samples: int = 500,
+        keys: Optional[List[str]] = None,
+        x_axis: str = "_step",
+        format: Literal["default", "pandas", "polars"] = "default",
+        stream: Literal["default", "system"] = "default",
+    ):
+        """Return sampled history metrics for all runs that fit the filters conditions.
+
+        Arguments:
+            samples : (int, optional) The number of samples to return per run
+            keys : (list[str], optional) Only return metrics for specific keys
+            x_axis : (str, optional) Use this metric as the xAxis defaults to _step
+            format : (Literal, optional) Format to return data in, options are "default", "pandas", "polars"
+            stream : (Literal, optional) "default" for metrics, "system" for machine metrics
+        Returns:
+            pandas.DataFrame: If format="pandas", returns a `pandas.DataFrame` of history metrics.
+            polars.DataFrame: If format="polars", returns a `polars.DataFrame` of history metrics.
+            list of dicts: If format="default", returns a list of dicts containing history metrics with a run_id key.
+        """
+        if format not in ("default", "pandas", "polars"):
+            raise ValueError(
+                f"Invalid format: {format}. Must be one of 'default', 'pandas', 'polars'"
+            )
+
+        histories = []
+
+        if format == "default":
+            for run in self:
+                history_data = run.history(
+                    samples=samples,
+                    keys=keys,
+                    x_axis=x_axis,
+                    pandas=False,
+                    stream=stream,
+                )
+                if not history_data:
+                    continue
+                for entry in history_data:
+                    entry["run_id"] = run.id
+                histories.extend(history_data)
+
+            return histories
+
+        if format == "pandas":
+            pd = util.get_module(
+                "pandas", required="Exporting pandas DataFrame requires pandas"
+            )
+            for run in self:
+                history_data = run.history(
+                    samples=samples,
+                    keys=keys,
+                    x_axis=x_axis,
+                    pandas=False,
+                    stream=stream,
+                )
+                if not history_data:
+                    continue
+                df = pd.DataFrame.from_records(history_data)
+                df["run_id"] = run.id
+                histories.append(df)
+            if not histories:
+                return pd.DataFrame()
+            combined_df = pd.concat(histories)
+            combined_df.sort_values("run_id", inplace=True)
+            combined_df.reset_index(drop=True, inplace=True)
+            # sort columns for consistency
+            combined_df = combined_df[(sorted(combined_df.columns))]
+
+            return combined_df
+
+        if format == "polars":
+            pl = util.get_module(
+                "polars", required="Exporting polars DataFrame requires polars"
+            )
+            for run in self:
+                history_data = run.history(
+                    samples=samples,
+                    keys=keys,
+                    x_axis=x_axis,
+                    pandas=False,
+                    stream=stream,
+                )
+                if not history_data:
+                    continue
+                df = pl.from_records(history_data)
+                df = df.with_columns(pl.lit(run.id).alias("run_id"))
+                histories.append(df)
+            if not histories:
+                return pl.DataFrame()
+            combined_df = pl.concat(histories, how="align")
+            # sort columns for consistency
+            combined_df = combined_df.select(sorted(combined_df.columns)).sort("run_id")
+
+            return combined_df
+
     def __repr__(self):
         return f"<Runs {self.entity}/{self.project}>"
 
@@ -310,16 +413,15 @@ class Run(Attrs):
     def load(self, force=False):
         query = gql(
             """
-        query Run($project: String!, $entity: String!, $name: String!) {
-            project(name: $project, entityName: $entity) {
-                run(name: $name) {
+        query Run($project: String!, $entity: String!, $name: String!) {{
+            project(name: $project, entityName: $entity) {{
+                run(name: $name) {{
                     ...RunFragment
-                }
-            }
-        }
-        %s
-        """
-            % RUN_FRAGMENT
+                }}
+            }}
+        }}
+        {}
+        """.format(RUN_FRAGMENT)
         )
         if force or not self._attrs:
             response = self._exec(query)
@@ -328,7 +430,7 @@ class Run(Attrs):
                 or response.get("project") is None
                 or response["project"].get("run") is None
             ):
-                raise ValueError("Could not find run %s" % self)
+                raise ValueError("Could not find run {}".format(self))
             self._attrs = response["project"]["run"]
             self._state = self._attrs["state"]
 
@@ -402,16 +504,15 @@ class Run(Attrs):
         """Persist changes to the run object to the wandb backend."""
         mutation = gql(
             """
-        mutation UpsertBucket($id: String!, $description: String, $display_name: String, $notes: String, $tags: [String!], $config: JSONString!, $groupName: String) {
-            upsertBucket(input: {id: $id, description: $description, displayName: $display_name, notes: $notes, tags: $tags, config: $config, groupName: $groupName}) {
-                bucket {
+        mutation UpsertBucket($id: String!, $description: String, $display_name: String, $notes: String, $tags: [String!], $config: JSONString!, $groupName: String) {{
+            upsertBucket(input: {{id: $id, description: $description, displayName: $display_name, notes: $notes, tags: $tags, config: $config, groupName: $groupName}}) {{
+                bucket {{
                     ...RunFragment
-                }
-            }
-        }
-        %s
-        """
-            % RUN_FRAGMENT
+                }}
+            }}
+        }}
+        {}
+        """.format(RUN_FRAGMENT)
         )
         _ = self._exec(
             mutation,
@@ -491,13 +592,12 @@ class Run(Attrs):
         node = "history" if stream == "default" else "events"
         query = gql(
             """
-        query RunFullHistory($project: String!, $entity: String!, $name: String!, $samples: Int) {
-            project(name: $project, entityName: $entity) {
-                run(name: $name) { %s(samples: $samples) }
-            }
-        }
-        """
-            % node
+        query RunFullHistory($project: String!, $entity: String!, $name: String!, $samples: Int) {{
+            project(name: $project, entityName: $entity) {{
+                run(name: $name) {{ {}(samples: $samples) }}
+            }}
+        }}
+        """.format(node)
         )
 
         response = self._exec(query, samples=samples)
@@ -587,9 +687,9 @@ class Run(Attrs):
         else:
             lines = self._full_history(samples=samples, stream=stream)
         if pandas:
-            pandas = util.get_module("pandas")
-            if pandas:
-                lines = pandas.DataFrame.from_records(lines)
+            pd = util.get_module("pandas")
+            if pd:
+                lines = pd.DataFrame.from_records(lines)
             else:
                 print("Unable to load pandas, call history with pandas=False")
         return lines
@@ -607,10 +707,11 @@ class Run(Attrs):
             losses = [row["Loss"] for row in history]
             ```
 
-
         Arguments:
             keys ([str], optional): only fetch these keys, and only fetch rows that have all of keys defined.
-            page_size (int, optional): size of pages to fetch from the api
+            page_size (int, optional): size of pages to fetch from the api.
+            min_step (int, optional): the minimum number of pages to scan at a time.
+            max_step (int, optional): the maximum number of pages to scan at a time.
 
         Returns:
             An iterable collection over history records (dict).
@@ -707,27 +808,24 @@ class Run(Attrs):
         )
         api.set_current_run_id(self.id)
 
-        if isinstance(artifact, wandb.Artifact) and not artifact.is_draft():
-            if (
-                self.entity != artifact.source_entity
-                or self.project != artifact.source_project
-            ):
-                raise ValueError("A run can't log an artifact to a different project.")
-            artifact_collection_name = artifact.source_name.split(":")[0]
-            api.create_artifact(
-                artifact.type,
-                artifact_collection_name,
-                artifact.digest,
-                aliases=aliases,
-            )
-            return artifact
-        elif isinstance(artifact, wandb.Artifact) and artifact.is_draft():
+        if not isinstance(artifact, wandb.Artifact):
+            raise ValueError("You must pass a wandb.Api().artifact() to use_artifact")
+        if artifact.is_draft():
             raise ValueError(
                 "Only existing artifacts are accepted by this api. "
                 "Manually create one with `wandb artifact put`"
             )
-        else:
-            raise ValueError("You must pass a wandb.Api().artifact() to use_artifact")
+        if (
+            self.entity != artifact.source_entity
+            or self.project != artifact.source_project
+        ):
+            raise ValueError("A run can't log an artifact to a different project.")
+
+        artifact_collection_name = artifact.source_name.split(":")[0]
+        api.create_artifact(
+            artifact.type, artifact_collection_name, artifact.digest, aliases=aliases
+        )
+        return artifact
 
     @property
     def summary(self):

wandb/apis/public/sweeps.py

@@ -107,7 +107,7 @@ class Sweep(Attrs):
         if force or not self._attrs:
             sweep = self.get(self.client, self.entity, self.project, self.id)
             if sweep is None:
-                raise ValueError("Could not find sweep %s" % self)
+                raise ValueError("Could not find sweep {}".format(self))
             self._attrs = sweep._attrs
             self.runs = sweep.runs
 
@@ -133,7 +133,7 @@ class Sweep(Attrs):
                 "No order specified and couldn't find metric in sweep config, returning most recent run"
             )
         else:
-            wandb.termlog("Sorting runs by %s" % order)
+            wandb.termlog("Sorting runs by {}".format(order))
         filters = {"$and": [{"sweep": self.id}]}
         try:
             return public.Runs(

wandb/apis/reports/__init__.py

@@ -1,7 +1 @@
-# flake8: noqa
-import os
-
-if os.getenv("WANDB_REPORT_API_ENABLE_V2"):
-    from wandb.apis.reports.v2 import *
-else:
-    from wandb.apis.reports.v1 import *
+from .v2 import *  # noqa: F403

wandb/apis/reports/v1/__init__.py

@@ -1,30 +1,8 @@
-import os
-from inspect import cleandoc
-
 import wandb
 
-from . import blocks, helpers, panels, templates
-from .blocks import *  # noqa: F403
-from .helpers import LineKey, PCColumn
-from .panels import *  # noqa: F403
-from .report import Report
-from .runset import Runset
-from .templates import *  # noqa: F403
-from .util import InlineCode, InlineLaTeX, Link
-
-
-def show_welcome_message():
-    if os.getenv("WANDB_REPORT_API_DISABLE_MESSAGE"):
-        return
-
-    wandb.termwarn(
-        cleandoc(
-            """
-            The v1 API is deprecated and will be removed in a future release.  Please move to v2 by setting the env var WANDB_REPORT_API_ENABLE_V2=True.  This will be on by default in a future release.
-            You can disable this message by setting the env var WANDB_REPORT_API_DISABLE_MESSAGE=True
-            """
-        )
+try:
+    from wandb_workspaces.reports.v1 import *  # noqa: F403
+except ImportError:
+    wandb.termerror(
+        "Failed to import wandb_workspaces.  To edit reports programatically, please install it using `pip install wandb[workspaces]`."
     )
-
-
-show_welcome_message()

wandb/apis/reports/v2/__init__.py

@@ -1,20 +1,8 @@
-import os
-from inspect import cleandoc
+import wandb
 
-from .... import termlog
-from . import blocks, panels
-from .blocks import *  # noqa
-from .interface import (
-    GradientPoint,
-    InlineCode,
-    InlineLatex,
-    Layout,
-    Link,
-    ParallelCoordinatesPlotColumn,
-    Report,
-    Runset,
-    RunsetGroup,
-    RunsetGroupKey,
-)
-from .metrics import *  # noqa
-from .panels import *  # noqa
+try:
+    from wandb_workspaces.reports.v2 import *  # noqa: F403
+except ImportError:
+    wandb.termerror(
+        "Failed to import wandb_workspaces.  To edit reports programatically, please install it using `pip install wandb[workspaces]`."
+    )

wandb/apis/workspaces/__init__.py

@@ -0,0 +1,8 @@
+import wandb
+
+try:
+    from wandb_workspaces.workspaces import *  # noqa: F403
+except ImportError:
+    wandb.termerror(
+        "Failed to import wandb_workspaces. To edit workspaces programatically, please install it using `pip install wandb[workspaces]`."
+    )

wandb/beta/workflows.py

@@ -183,7 +183,7 @@ def log_model(
     return model
 
 
-def use_model(aliased_path: str) -> "_SavedModel":
+def use_model(aliased_path: str, unsafe: bool = False) -> "_SavedModel":
     """Fetch a saved model from an alias.
 
     Under the hood, we use the alias to fetch the model artifact containing the
@@ -193,17 +193,22 @@ def use_model(aliased_path: str) -> "_SavedModel":
     Args:
         aliased_path: `str` - the following forms are valid: "name:version",
             "name:alias". May be prefixed with "entity/project".
+        unsafe: `bool` - must be True to indicate the user understands the risks
+            associated with loading external models.
 
     Returns:
         _SavedModel instance
 
     Example:
         ```python
-        # Assuming you have previously logged a model with the name "my-simple-model":
-        sm = use_model("my-simple-model:latest")
+        # Assuming the model with the name "my-simple-model" is trusted:
+        sm = use_model("my-simple-model:latest", unsafe=True)
         model = sm.model_obj()
         ```
     """
+    if not unsafe:
+        raise ValueError("The 'unsafe' parameter must be set to True to load a model.")
+
     if ":" not in aliased_path:
         raise ValueError(
             "aliased_path must be of the form 'name:alias' or 'name:version'."