wandb 0.19.0__py3-none-win32.whl → 0.19.1__py3-none-win32.whl

wandb/apis/public/files.py

@@ -49,6 +49,7 @@ class Files(Paginator):
         query RunFiles($project: String!, $entity: String!, $name: String!, $fileCursor: String,
             $fileLimit: Int = 50, $fileNames: [String] = [], $upload: Boolean = false) {{
             project(name: $project, entityName: $entity) {{
+                internalId
                 run(name: $name) {{
                     fileCount
                     ...RunFilesFragment
@@ -98,7 +99,7 @@ class Files(Paginator):
 
     def convert_objects(self):
         return [
-            File(self.client, r["node"])
+            File(self.client, r["node"], self.run)
             for r in self.last_response["project"]["run"]["files"]["edges"]
         ]
 
@@ -120,9 +121,11 @@ class File(Attrs):
         path_uri (str): path to file in the bucket, currently only available for files stored in S3
     """
 
-    def __init__(self, client, attrs):
+    def __init__(self, client, attrs, run=None):
         self.client = client
         self._attrs = attrs
+        self.run = run
+        self.server_supports_delete_file_with_project_id: Optional[bool] = None
         super().__init__(dict(attrs))
 
     @property
@@ -189,18 +192,35 @@ class File(Attrs):
 
     @normalize_exceptions
     def delete(self):
-        mutation = gql(
-            """
-        mutation deleteFiles($files: [ID!]!) {
-            deleteFiles(input: {
-                files: $files
-            }) {
-                success
-            }
+        project_id_mutation_fragment = ""
+        project_id_variable_fragment = ""
+        variable_values = {
+            "files": [self.id],
         }
-        """
+
+        # Add projectId to mutation and variables if the server supports it.
+        # Otherwise, do not include projectId in mutation for older server versions which do not support it.
+        if self._server_accepts_project_id_for_delete_file():
+            variable_values["projectId"] = self.run._project_internal_id
+            project_id_variable_fragment = ", $projectId: Int"
+            project_id_mutation_fragment = "projectId: $projectId"
+
+        mutation_string = """
+            mutation deleteFiles($files: [ID!]!{}) {{
+                deleteFiles(input: {{
+                    files: $files
+                    {}
+                }}) {{
+                    success
+                }}
+            }}
+            """.format(project_id_variable_fragment, project_id_mutation_fragment)
+        mutation = gql(mutation_string)
+
+        self.client.execute(
+            mutation,
+            variable_values=variable_values,
         )
-        self.client.execute(mutation, variable_values={"files": [self.id]})
 
     def __repr__(self):
         return "<File {} ({}) {}>".format(
@@ -208,3 +228,36 @@ class File(Attrs):
             self.mimetype,
             util.to_human_size(self.size, units=util.POW_2_BYTES),
         )
+
+    @normalize_exceptions
+    def _server_accepts_project_id_for_delete_file(self) -> bool:
+        """Returns True if the server supports deleting files with a projectId.
+
+        This check is done by utilizing GraphQL introspection in the avaiable fields on the DeleteFiles API.
+        """
+        query_string = """
+           query ProbeDeleteFilesProjectIdInput {
+                DeleteFilesProjectIdInputType: __type(name:"DeleteFilesInput") {
+                    inputFields{
+                        name
+                    }
+                }
+            }
+        """
+
+        # Only perform the query once to avoid extra network calls
+        if self.server_supports_delete_file_with_project_id is None:
+            query = gql(query_string)
+            res = self.client.execute(query)
+
+            # If projectId is in the inputFields, the server supports deleting files with a projectId
+            self.server_supports_delete_file_with_project_id = "projectId" in [
+                x["name"]
+                for x in (
+                    res.get("DeleteFilesProjectIdInputType", {}).get(
+                        "inputFields", [{}]
+                    )
+                )
+            ]
+
+        return self.server_supports_delete_file_with_project_id

wandb/apis/public/runs.py

@@ -71,6 +71,7 @@ class Runs(Paginator):
         """
         query Runs($project: String!, $entity: String!, $cursor: String, $perPage: Int = 50, $order: String, $filters: JSONString) {{
             project(name: $project, entityName: $entity) {{
+                internalId
                 runCount(filters: $filters)
                 readOnly
                 runs(filters: $filters, after: $cursor, first: $perPage, order: $order) {{
@@ -103,6 +104,7 @@ class Runs(Paginator):
     ):
         self.entity = entity
         self.project = project
+        self._project_internal_id = None
         self.filters = filters or {}
         self.order = order
         self._sweeps = {}
@@ -287,6 +289,7 @@ class Run(Attrs):
                     Calling update will persist any changes.
         project (str): the project associated with the run
         entity (str): the name of the entity associated with the run
+        project_internal_id (int): the internal id of the project
         user (str): the name of the user who created the run
         path (str): Unique identifier [entity]/[project]/[run_id]
         notes (str): Notes about the run
@@ -328,6 +331,7 @@ class Run(Attrs):
         self._summary = None
         self._metadata: Optional[Dict[str, Any]] = None
         self._state = _attrs.get("state", "not found")
+        self.server_provides_internal_id_field: Optional[bool] = None
 
         self.load(force=not _attrs)
 
@@ -417,13 +421,18 @@ class Run(Attrs):
             """
         query Run($project: String!, $entity: String!, $name: String!) {{
             project(name: $project, entityName: $entity) {{
+                {}
                 run(name: $name) {{
                     ...RunFragment
                 }}
             }}
         }}
         {}
-        """.format(RUN_FRAGMENT)
+        """.format(
+                # Only query internalId if the server supports it
+                "internalId" if self._server_provides_internal_id_for_project() else "",
+                RUN_FRAGMENT,
+            )
         )
         if force or not self._attrs:
             response = self._exec(query)
@@ -435,7 +444,7 @@ class Run(Attrs):
                 raise ValueError("Could not find run {}".format(self))
             self._attrs = response["project"]["run"]
             self._state = self._attrs["state"]
-
+            self._project_internal_id = response["project"].get("internalId", None)
             if self._include_sweeps and self.sweep_name and not self.sweep:
                 # There may be a lot of runs. Don't bother pulling them all
                 # just for the sake of this one.
@@ -495,7 +504,6 @@ class Run(Attrs):
             res = self._exec(query)
             state = res["project"]["run"]["state"]
             if state in ["finished", "crashed", "failed"]:
-                print(f"Run finished with status: {state}")
                 self._attrs["state"] = state
                 self._state = state
                 return
@@ -506,8 +514,8 @@ 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}}) {{
+        mutation UpsertBucket($id: String!, $description: String, $display_name: String, $notes: String, $tags: [String!], $config: JSONString!, $groupName: String, $jobType: String) {{
+            upsertBucket(input: {{id: $id, description: $description, displayName: $display_name, notes: $notes, tags: $tags, config: $config, groupName: $groupName, jobType: $jobType}}) {{
                 bucket {{
                     ...RunFragment
                 }}
@@ -525,6 +533,7 @@ class Run(Attrs):
             display_name=self.display_name,
             config=self.json_config,
             groupName=self.group,
+            jobType=self.job_type,
         )
         self.summary.update()
 
@@ -770,7 +779,9 @@ class Run(Attrs):
         Example:
             >>> import wandb
             >>> import tempfile
-            >>> with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as tmp:
+            >>> with tempfile.NamedTemporaryFile(
+            ...     mode="w", delete=False, suffix=".txt"
+            ... ) as tmp:
             ...     tmp.write("This is a test artifact")
             ...     tmp_path = tmp.name
             >>> run = wandb.init(project="artifact-example")
@@ -893,6 +904,37 @@ class Run(Attrs):
         )
         return artifact
 
+    @normalize_exceptions
+    def _server_provides_internal_id_for_project(self) -> bool:
+        """Returns True if the server allows us to query the internalId field for a project.
+
+        This check is done by utilizing GraphQL introspection in the avaiable fields on the Project type.
+        """
+        query_string = """
+           query ProbeProjectInput {
+                ProjectType: __type(name:"Project") {
+                    fields {
+                        name
+                    }
+                }
+            }
+        """
+
+        # Only perform the query once to avoid extra network calls
+        if self.server_provides_internal_id_field is None:
+            query = gql(query_string)
+            res = self.client.execute(query)
+            print(
+                "internalId"
+                in [x["name"] for x in (res.get("ProjectType", {}).get("fields", [{}]))]
+            )
+
+            self.server_provides_internal_id_field = "internalId" in [
+                x["name"] for x in (res.get("ProjectType", {}).get("fields", [{}]))
+            ]
+
+        return self.server_provides_internal_id_field
+
     @property
     def summary(self):
         if self._summary is None:
@@ -921,7 +963,10 @@ class Run(Attrs):
         if self._metadata is None:
             try:
                 f = self.file("wandb-metadata.json")
-                contents = util.download_file_into_memory(f.url, wandb.Api().api_key)
+                session = self.client._client.transport.session
+                response = session.get(f.url, timeout=5)
+                response.raise_for_status()
+                contents = response.content
                 self._metadata = json_util.loads(contents)
             except:  # noqa: E722
                 # file doesn't exist, or can't be downloaded, or can't be parsed

wandb/apis/public/sweeps.py

@@ -34,7 +34,7 @@ class Sweep(Attrs):
         Instantiate with:
         ```
         api = wandb.Api()
-        sweep = api.sweep(path/to/sweep)
+        sweep = api.sweep(path / to / sweep)
         ```
 
     Attributes:

wandb/cli/cli.py

@@ -33,6 +33,7 @@ from wandb.apis.public import RunQueue
 from wandb.errors.links import url_registry
 from wandb.sdk.artifacts._validators import is_artifact_registry_project
 from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
+from wandb.sdk.internal.internal_api import Api as SDKInternalApi
 from wandb.sdk.launch import utils as launch_utils
 from wandb.sdk.launch._launch_add import _launch_add
 from wandb.sdk.launch.errors import ExecutionError, LaunchError
@@ -2399,7 +2400,7 @@ def get(path, root, type):
             settings_entity = public_api.settings["entity"] or public_api.default_entity
             # Registry artifacts are under the org entity. Because we offer a shorthand and alias for this path,
             # we need to fetch the org entity to for the user behind the scenes.
-            entity = InternalApi()._resolve_org_entity_name(
+            entity = SDKInternalApi()._resolve_org_entity_name(
                 entity=settings_entity, organization=organization
             )
         full_path = f"{entity}/{project}/{artifact_name}:{version}"

wandb/env.py

@@ -169,7 +169,7 @@ def error_reporting_enabled() -> bool:
 
 
 def core_debug(default: str | None = None) -> bool:
-    return _env_as_bool(CORE_DEBUG, default=default)
+    return _env_as_bool(CORE_DEBUG, default=default) or is_debug()
 
 
 def ssl_disabled() -> bool:

wandb/errors/term.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import contextlib
 import logging
 import os
+import re
+import shutil
 import sys
 import threading
 from typing import TYPE_CHECKING, Iterator, Protocol
@@ -271,10 +273,67 @@ class DynamicBlock:
         The lock must be held.
         """
         if self._lines_to_print:
-            click.echo("\n".join(self._lines_to_print), file=sys.stderr)
+            # Trim lines before printing. This is crucial because the \x1b[Am
+            # (cursor up) sequence used when clearing the text moves up by one
+            # visual line, and the terminal may be wrapping long lines onto
+            # multiple visual lines.
+            #
+            # There is no ANSI escape sequence that moves the cursor up by one
+            # "physical" line instead. Note that the user may resize their
+            # terminal.
+            term_width = _shutil_get_terminal_width()
+            click.echo(
+                "\n".join(
+                    _ansi_shorten(line, term_width)  #
+                    for line in self._lines_to_print
+                ),
+                file=sys.stderr,
+            )
+
         self._num_lines_printed += len(self._lines_to_print)
 
 
+def _shutil_get_terminal_width() -> int:
+    """Returns the width of the terminal.
+
+    Defined here for patching in tests.
+    """
+    columns, _ = shutil.get_terminal_size()
+    return columns
+
+
+_ANSI_RE = re.compile("\x1b\\[(K|.*?m)")
+
+
+def _ansi_shorten(text: str, width: int) -> str:
+    """Shorten text potentially containing ANSI sequences to fit a width."""
+    first_ansi = _ANSI_RE.search(text)
+
+    if not first_ansi:
+        return _raw_shorten(text, width)
+
+    if first_ansi.start() > width - 3:
+        return _raw_shorten(text[: first_ansi.start()], width)
+
+    return text[: first_ansi.end()] + _ansi_shorten(
+        text[first_ansi.end() :],
+        # Key part: the ANSI sequence doesn't reduce the remaining width.
+        width - first_ansi.start(),
+    )
+
+
+def _raw_shorten(text: str, width: int) -> str:
+    """Shorten text to fit a width, replacing the end with "...".
+
+    Unlike textwrap.shorten(), this does not drop whitespace or do anything
+    smart.
+    """
+    if len(text) <= width:
+        return text
+
+    return text[: width - 3] + "..."
+
+
 def _log(
     string="",
     newline=True,

wandb/integration/keras/callbacks/tables_builder.py

@@ -145,7 +145,9 @@ class WandbEvalCallback(Callback, abc.ABC):
             for idx, data in enumerate(dataloader):
                 preds = model.predict(data)
                 self.pred_table.add_data(
-                    self.data_table_ref.data[idx][0], self.data_table_ref.data[idx][1], preds
+                    self.data_table_ref.data[idx][0],
+                    self.data_table_ref.data[idx][1],
+                    preds,
                 )
             ```
         This method is called `on_epoch_end` or equivalent hook.

wandb/integration/kfp/kfp_patch.py

@@ -208,23 +208,24 @@ def create_component_from_func(
                 """Return sum of two arguments"""
                 return a + b
 
+
             # add_op is a task factory function that creates a task object when given arguments
             add_op = create_component_from_func(
                 func=add,
-                base_image='python:3.7', # Optional
-                output_component_file='add.component.yaml', # Optional
-                packages_to_install=['pandas==0.24'], # Optional
+                base_image="python:3.7",  # Optional
+                output_component_file="add.component.yaml",  # Optional
+                packages_to_install=["pandas==0.24"],  # Optional
             )
 
             # The component spec can be accessed through the .component_spec attribute:
-            add_op.component_spec.save('add.component.yaml')
+            add_op.component_spec.save("add.component.yaml")
 
             # The component function can be called with arguments to create a task:
             add_task = add_op(1, 3)
 
             # The resulting task has output references, corresponding to the component outputs.
             # When the function only has a single anonymous return value, the output name is "Output":
-            sum_output_ref = add_task.outputs['Output']
+            sum_output_ref = add_task.outputs["Output"]
 
             # These task output references can be passed to other component functions, constructing a computation graph:
             task2 = add_op(sum_output_ref, 5)
@@ -241,17 +242,21 @@ def create_component_from_func(
 
             from typing import NamedTuple
 
-            def add_multiply_two_numbers(a: float, b: float) -> NamedTuple('Outputs', [('sum', float), ('product', float)]):
+
+            def add_multiply_two_numbers(a: float, b: float) -> NamedTuple(
+                "Outputs", [("sum", float), ("product", float)]
+            ):
                 """Return sum and product of two arguments"""
                 return (a + b, a * b)
 
+
             add_multiply_op = create_component_from_func(add_multiply_two_numbers)
 
             # The component function can be called with arguments to create a task:
             add_multiply_task = add_multiply_op(1, 3)
 
             # The resulting task has output references, corresponding to the component outputs:
-            sum_output_ref = add_multiply_task.outputs['sum']
+            sum_output_ref = add_multiply_task.outputs["sum"]
 
             # These task output references can be passed to other component functions, constructing a computation graph:
             task2 = add_multiply_op(sum_output_ref, 5)
@@ -266,14 +271,19 @@ def create_component_from_func(
         Example of a component function declaring file input and output::
 
             def catboost_train_classifier(
-                training_data_path: InputPath('CSV'),            # Path to input data file of type "CSV"
-                trained_model_path: OutputPath('CatBoostModel'), # Path to output data file of type "CatBoostModel"
-                number_of_trees: int = 100,                      # Small output of type "Integer"
-            ) -> NamedTuple('Outputs', [
-                ('Accuracy', float),  # Small output of type "Float"
-                ('Precision', float), # Small output of type "Float"
-                ('JobUri', 'URI'),    # Small output of type "URI"
-            ]):
+                training_data_path: InputPath("CSV"),  # Path to input data file of type "CSV"
+                trained_model_path: OutputPath(
+                    "CatBoostModel"
+                ),  # Path to output data file of type "CatBoostModel"
+                number_of_trees: int = 100,  # Small output of type "Integer"
+            ) -> NamedTuple(
+                "Outputs",
+                [
+                    ("Accuracy", float),  # Small output of type "Float"
+                    ("Precision", float),  # Small output of type "Float"
+                    ("JobUri", "URI"),  # Small output of type "URI"
+                ],
+            ):
                 """Train CatBoost classification model"""
                 ...
 

wandb/integration/lightning/fabric/logger.py

@@ -192,7 +192,9 @@ class WandbLogger(Logger):
         wandb_logger.log_image(key="samples", images=[img1, img2])
 
         # adding captions
-        wandb_logger.log_image(key="samples", images=[img1, img2], caption=["tree", "person"])
+        wandb_logger.log_image(
+            key="samples", images=[img1, img2], caption=["tree", "person"]
+        )
 
         # using file path
         wandb_logger.log_image(key="samples", images=["img_1.jpg", "img_2.jpg"])

wandb/integration/tensorboard/monkeypatch.py

@@ -30,8 +30,9 @@ def patch(
 ) -> None:
     if len(wandb.patched["tensorboard"]) > 0:
         raise ValueError(
-            "Tensorboard already patched, remove `sync_tensorboard=True` "
-            "from `wandb.init` or only call `wandb.tensorboard.patch` once."
+            "Tensorboard already patched. Call `wandb.tensorboard.unpatch()` first; "
+            "remove `sync_tensorboard=True` from `wandb.init`; "
+            "or only call `wandb.tensorboard.patch` once."
         )
 
     # TODO: Some older versions of tensorflow don't require tensorboard to be present.

wandb/jupyter.py

@@ -15,10 +15,9 @@ import wandb.util
 from wandb.sdk.lib import filesystem
 
 try:
-    from IPython.core.getipython import get_ipython
+    import IPython
     from IPython.core.magic import Magics, line_cell_magic, magics_class
     from IPython.core.magic_arguments import argument, magic_arguments, parse_argstring
-    from IPython.display import display
 except ImportError:
     wandb.termwarn("ipython is not supported in python 2.7, upgrade to 3.x")
 
@@ -66,7 +65,7 @@ class IFrame:
 
     def maybe_display(self) -> bool:
         if not self.displayed and (self.path or wandb.run):
-            display(self)
+            IPython.display.display(self)
         return self.displayed
 
     def _repr_html_(self):
@@ -155,7 +154,7 @@ class WandBMagics(Magics):
                     + cell
                     + "\nwandb.jupyter.__IFrame = None"
                 )
-            get_ipython().run_cell(cell)
+            IPython.get_ipython().run_cell(cell)
 
 
 def notebook_metadata_from_jupyter_servers_and_kernel_id():
@@ -343,7 +342,7 @@ class Notebook:
     def __init__(self, settings):
         self.outputs = {}
         self.settings = settings
-        self.shell = get_ipython()
+        self.shell = IPython.get_ipython()
 
     def save_display(self, exc_count, data_with_metadata):
         self.outputs[exc_count] = self.outputs.get(exc_count, [])

wandb/plot/bar.py

@@ -38,10 +38,10 @@ def bar(
 
         # Generate random data for the table
         data = [
-            ['car', random.uniform(0, 1)],
-            ['bus', random.uniform(0, 1)],
-            ['road', random.uniform(0, 1)],
-            ['person', random.uniform(0, 1)],
+            ["car", random.uniform(0, 1)],
+            ["bus", random.uniform(0, 1)],
+            ["road", random.uniform(0, 1)],
+            ["person", random.uniform(0, 1)],
         ]
 
         # Create a table with the data
@@ -49,7 +49,6 @@ def bar(
 
         # Initialize a W&B run and log the bar plot
         with wandb.init(project="bar_chart") as run:
-
             # Create a bar plot from the table
             bar_plot = wandb.plot.bar(
                 table=table,
@@ -59,7 +58,7 @@ def bar(
             )
 
             # Log the bar chart to W&B
-            run.log({'bar_plot': bar_plot})
+            run.log({"bar_plot": bar_plot})
         ```
     """
     return plot_table(

wandb/plot/histogram.py

@@ -53,7 +53,7 @@ def histogram(
 
         # Log the histogram plot to W&B
         with wandb.init(...) as run:
-            run.log({'histogram-plot1': histogram})
+            run.log({"histogram-plot1": histogram})
         ```
     """
     return plot_table(

wandb/plot/line_series.py

@@ -53,9 +53,9 @@ def line_series(
 
             # Multiple y series to plot
             ys = [
-                [i for i in range(10)],       # y = x
-                [i**2 for i in range(10)],    # y = x^2
-                [i**3 for i in range(10)],     # y = x^3
+                [i for i in range(10)],  # y = x
+                [i**2 for i in range(10)],  # y = x^2
+                [i**3 for i in range(10)],  # y = x^3
             ]
 
             # Generate and log the line series chart

wandb/plot/pr_curve.py

@@ -74,10 +74,10 @@ def pr_curve(
             [0.2, 0.8],  # Second sample (spam), and so on
             [0.1, 0.9],
             [0.8, 0.2],
-            [0.3, 0.7]
+            [0.3, 0.7],
         ]
 
-        labels = ['not spam', 'spam']  # Optional class names for readability
+        labels = ["not spam", "spam"]  # Optional class names for readability
 
         with wandb.init(project="spam-detection") as run:
             pr_curve = wandb.plot.pr_curve(
@@ -176,6 +176,10 @@ def pr_curve(
             "y": "precision",
             "class": "class",
         },
-        string_fields={"title": title},
+        string_fields={
+            "title": title,
+            "x-axis-title": "Recall",
+            "y-axis-title": "Precision",
+        },
         split_table=split_table,
     )

wandb/plot/scatter.py

@@ -38,7 +38,8 @@ def scatter(
 
         # Simulate temperature variations at different altitudes over time
         data = [
-            [i, random.uniform(-10, 20) - 0.005 * i + 5 * math.sin(i / 50)] for i in range(300)
+            [i, random.uniform(-10, 20) - 0.005 * i + 5 * math.sin(i / 50)]
+            for i in range(300)
         ]
 
         # Create W&B table with altitude (m) and temperature (°C) columns