wandb 0.22.1__py3-none-musllinux_1_2_aarch64.whl → 0.22.3__py3-none-musllinux_1_2_aarch64.whl

wandb/sdk/internal/job_builder.py

@@ -132,6 +132,7 @@ def get_min_supported_for_source_dict(
 
 class JobBuilder:
     _settings: SettingsStatic
+    _files_dir: str
     _metadatafile_path: Optional[str]
     _requirements_path: Optional[str]
     _config: Optional[Dict[str, Any]]
@@ -146,8 +147,26 @@ class JobBuilder:
     _verbose: bool
     _services: Dict[str, str]
 
-    def __init__(self, settings: SettingsStatic, verbose: bool = False):
+    def __init__(
+        self,
+        settings: SettingsStatic,
+        verbose: bool = False,
+        *,
+        files_dir: str,
+    ):
+        """Instantiate a JobBuilder.
+
+        Args:
+            settings: Parameters for the job builder.
+                In a run, this is the run's settings.
+                Otherwise, this is a set of undocumented parameters,
+                all of which should be made explicit like files_dir.
+            files_dir: The directory where to write files.
+                In a run, this should be the run's files directory.
+        """
         self._settings = settings
+        self._files_dir = files_dir
+
         self._metadatafile_path = None
         self._requirements_path = None
         self._config = None
@@ -460,9 +479,7 @@ class JobBuilder:
             )
             return None
 
-        if not os.path.exists(
-            os.path.join(self._settings.files_dir, REQUIREMENTS_FNAME)
-        ):
+        if not os.path.exists(os.path.join(self._files_dir, REQUIREMENTS_FNAME)):
             self._log_if_verbose(
                 "No requirements.txt found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
                 "warn",
@@ -471,7 +488,7 @@ class JobBuilder:
         metadata = self._handle_metadata_file()
         if metadata is None:
             self._log_if_verbose(
-                f"Ensure read and write access to run files dir: {self._settings.files_dir}, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables",
+                f"Ensure read and write access to run files dir: {self._files_dir}, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables",
                 "warn",
             )
             return None
@@ -560,15 +577,15 @@ class JobBuilder:
             f.write(json.dumps(source_info, indent=4))
 
         artifact.add_file(
-            os.path.join(self._settings.files_dir, REQUIREMENTS_FNAME),
+            os.path.join(self._files_dir, REQUIREMENTS_FNAME),
             name=FROZEN_REQUIREMENTS_FNAME,
         )
 
         if source_type == "repo":
             # add diff
-            if os.path.exists(os.path.join(self._settings.files_dir, DIFF_FNAME)):
+            if os.path.exists(os.path.join(self._files_dir, DIFF_FNAME)):
                 artifact.add_file(
-                    os.path.join(self._settings.files_dir, DIFF_FNAME),
+                    os.path.join(self._files_dir, DIFF_FNAME),
                     name=DIFF_FNAME,
                 )
 
@@ -619,8 +636,8 @@ class JobBuilder:
     def _handle_metadata_file(
         self,
     ) -> Optional[Dict]:
-        if os.path.exists(os.path.join(self._settings.files_dir, METADATA_FNAME)):
-            with open(os.path.join(self._settings.files_dir, METADATA_FNAME)) as f:
+        if os.path.exists(os.path.join(self._files_dir, METADATA_FNAME)):
+            with open(os.path.join(self._files_dir, METADATA_FNAME)) as f:
                 metadata: Dict = json.load(f)
             return metadata
 

wandb/sdk/internal/sender.py

@@ -311,7 +311,10 @@ class SendManager:
         self._output_raw_file = None
 
         # job builder
-        self._job_builder = JobBuilder(settings)
+        self._job_builder = JobBuilder(
+            settings,
+            files_dir=settings.files_dir,
+        )
 
         time_now = time.monotonic()
         self._debounce_config_time = time_now

wandb/sdk/launch/create_job.py

@@ -417,10 +417,11 @@ def _configure_job_builder_for_partial(tmpdir: str, job_source: str) -> JobBuild
     if job_source == "code":
         job_source = "artifact"
 
-    settings = wandb.Settings(x_files_dir=tmpdir, job_source=job_source)
+    settings = wandb.Settings(job_source=job_source)
     job_builder = JobBuilder(
         settings=settings,  # type: ignore
         verbose=True,
+        files_dir=tmpdir,
     )
     job_builder._partial = True
     # never allow notebook runs

wandb/sdk/launch/inputs/schema.py

@@ -7,6 +7,9 @@ META_SCHEMA = {
         },
         "title": {"type": "string"},
         "description": {"type": "string"},
+        "label": {"type": "string"},
+        "placeholder": {"type": "string"},
+        "required": {"type": "boolean"},
         "format": {"type": "string"},
         "enum": {"type": "array", "items": {"type": ["integer", "number", "string"]}},
         "properties": {"type": "object", "patternProperties": {".*": {"$ref": "#"}}},
@@ -19,24 +22,24 @@ META_SCHEMA = {
     },
     "allOf": [
         {
-            "if": {"properties": {"type": {"const": "number"}}},
+            "if": {"properties": {"type": {"const": "integer"}}},
             "then": {
                 "properties": {
-                    "minimum": {"type": ["integer", "number"]},
-                    "maximum": {"type": ["integer", "number"]},
-                    "exclusiveMinimum": {"type": ["integer", "number"]},
-                    "exclusiveMaximum": {"type": ["integer", "number"]},
+                    "minimum": {"type": "integer"},
+                    "maximum": {"type": "integer"},
+                    "exclusiveMinimum": {"type": "integer"},
+                    "exclusiveMaximum": {"type": "integer"},
                 }
             },
         },
         {
-            "if": {"properties": {"type": {"const": "integer"}}},
+            "if": {"properties": {"type": {"const": "number"}}},
             "then": {
                 "properties": {
-                    "minimum": {"type": "integer"},
-                    "maximum": {"type": "integer"},
-                    "exclusiveMinimum": {"type": "integer"},
-                    "exclusiveMaximum": {"type": "integer"},
+                    "minimum": {"type": ["integer", "number"]},
+                    "maximum": {"type": ["integer", "number"]},
+                    "exclusiveMinimum": {"type": ["integer", "number"]},
+                    "exclusiveMaximum": {"type": ["integer", "number"]},
                 }
             },
         },

wandb/sdk/lib/apikey.py

@@ -136,12 +136,6 @@ def prompt_api_key(  # noqa: C901
     if (jupyter and not settings.login_timeout) or no_create:
         choices.remove(LOGIN_CHOICE_NEW)
 
-    if jupyter and "google.colab" in sys.modules:
-        log_string = term.LOG_STRING_NOCOLOR
-        key = wandb.jupyter.attempt_colab_login(app_url)  # type: ignore
-        if key is not None:
-            return key  # type: ignore
-
     if anon_mode == "must":
         result = LOGIN_CHOICE_ANON
     # If we're not in an interactive environment, default to dry-run.
@@ -236,9 +230,9 @@ def check_netrc_access(
 def write_netrc(host: str, entity: str, key: str):
     """Add our host and key to .netrc."""
     _, key_suffix = key.split("-", 1) if "-" in key else ("", key)
-    if len(key_suffix) != 40:
+    if len(key_suffix) < 40:
         raise ValueError(
-            f"API-key must be exactly 40 characters long: {key_suffix} ({len(key_suffix)} chars)"
+            f"API-key must be at least 40 characters long: {key_suffix} ({len(key_suffix)} chars)"
         )
 
     normalized_host = urlparse(host).netloc
@@ -305,12 +299,14 @@ def write_key(
     # TODO(jhr): api shouldn't be optional or it shouldn't be passed, clean up callers
     api = api or InternalApi()
 
-    # Normal API keys are 40-character hex strings. On-prem API keys have a
-    # variable-length prefix, a dash, then the 40-char string.
+    # API keys are strings of at least 40 characters. On-prem API keys have a
+    # variable-length prefix, a dash, then the string of at least 40 chars.
     _, suffix = key.split("-", 1) if "-" in key else ("", key)
 
-    if len(suffix) != 40:
-        raise ValueError(f"API key must be 40 characters long, yours was {len(key)}")
+    if len(suffix) < 40:
+        raise ValueError(
+            f"API key must be at least 40 characters long, yours was {len(key)}"
+        )
 
     write_netrc(settings.base_url, "user", key)
 

wandb/sdk/lib/asyncio_compat.py

@@ -133,7 +133,7 @@ class TaskGroup:
     """Object that `open_task_group()` yields."""
 
     def __init__(self) -> None:
-        self._tasks: list[asyncio.Task] = []
+        self._tasks: list[asyncio.Task[None]] = []
 
     def start_soon(self, coro: Coroutine[Any, Any, Any]) -> None:
         """Schedule a task in the group.

wandb/sdk/lib/asyncio_manager.py

@@ -7,7 +7,7 @@ import concurrent.futures
 import contextlib
 import logging
 import threading
-from typing import Any, Callable, Coroutine, TypeVar
+from typing import Awaitable, Callable, TypeVar
 
 from . import asyncio_compat
 
@@ -104,7 +104,7 @@ class AsyncioManager:
             # This only matters if the KeyboardInterrupt is suppressed.
             self._runner.cancel()
 
-    def run(self, fn: Callable[[], Coroutine[Any, Any, _T]]) -> _T:
+    def run(self, fn: Callable[[], Awaitable[_T]]) -> _T:
         """Run an async function to completion.
 
         The function is called in the asyncio thread. Blocks until start()
@@ -148,7 +148,7 @@ class AsyncioManager:
 
     def run_soon(
         self,
-        fn: Callable[[], Coroutine[Any, Any, None]],
+        fn: Callable[[], Awaitable[None]],
         *,
         daemon: bool = False,
         name: str | None = None,
@@ -186,7 +186,7 @@ class AsyncioManager:
 
     def _schedule(
         self,
-        fn: Callable[[], Coroutine[Any, Any, _T]],
+        fn: Callable[[], Awaitable[_T]],
         daemon: bool,
         name: str | None = None,
     ) -> concurrent.futures.Future[_T]:
@@ -207,7 +207,7 @@ class AsyncioManager:
 
     async def _wrap(
         self,
-        fn: Callable[[], Coroutine[Any, Any, _T]],
+        fn: Callable[[], Awaitable[_T]],
         daemon: bool,
         name: str | None,
     ) -> _T:

wandb/sdk/lib/console_capture.py

@@ -75,9 +75,12 @@ class _WriteCallback(Protocol):
         """
 
 
-# A reentrant lock is used to catch callbacks that write to stderr/stdout.
-_module_rlock = threading.RLock()
+_module_lock = threading.Lock()
 _is_writing = False
+"""Prevents infinite print-capture loops.
+
+If a capture callback prints, that output is not captured.
+"""
 
 _patch_exception: CannotCaptureConsoleError | None = None
 
@@ -99,7 +102,7 @@ def capture_stdout(callback: _WriteCallback) -> Callable[[], None]:
     Raises:
         CannotCaptureConsoleError: If patching failed on import.
     """
-    with _module_rlock:
+    with _module_lock:
         if _patch_exception:
             raise _patch_exception
 
@@ -121,7 +124,7 @@ def capture_stderr(callback: _WriteCallback) -> Callable[[], None]:
     Raises:
         CannotCaptureConsoleError: If patching failed on import.
     """
-    with _module_rlock:
+    with _module_lock:
         if _patch_exception:
             raise _patch_exception
 
@@ -144,7 +147,7 @@ def _insert_disposably(
     def dispose() -> None:
         nonlocal disposed
 
-        with _module_rlock:
+        with _module_lock:
             if disposed:
                 return
 
@@ -167,38 +170,43 @@ def _patch(
         global _is_writing
         n = orig_write(s)
 
-        # NOTE: Since _module_rlock is reentrant, this is safe. It will not
-        # deadlock if a callback invokes write() again.
-        with _module_rlock:
+        with _module_lock:
             if _is_writing:
                 return n
-
             _is_writing = True
-            try:
-                for cb in callbacks.values():
-                    cb(s, n)
-
-            except BaseException as e:
-                # Clear all callbacks on any exception to avoid infinite loops:
-                #
-                # * If we re-raise, an exception handler is likely to print
-                #   the exception to the console and trigger callbacks again
-                # * If we log, we can't guarantee that this doesn't print
-                #   to console.
-                #
-                # This is especially important for KeyboardInterrupt.
+
+            # Invoke callbacks outside of the lock to avoid deadlocks.
+            # 1. A callback may print, invoking this again.
+            # 2. A callback may block on a different thread which then prints.
+            callback_list = list(callbacks.values())
+
+        try:
+            for cb in callback_list:
+                cb(s, n)
+
+        except BaseException as e:
+            # Clear all callbacks on any exception to avoid infinite loops:
+            #
+            # * If we re-raise, an exception handler is likely to print
+            #   the exception to the console and trigger callbacks again
+            # * If we log, we can't guarantee that this doesn't print
+            #   to console.
+            #
+            # This is especially important for KeyboardInterrupt.
+            with _module_lock:
                 _stderr_callbacks.clear()
                 _stdout_callbacks.clear()
 
-                if isinstance(e, Exception):
-                    # We suppress Exceptions so that bugs in W&B code don't
-                    # cause the user's print() statements to raise errors.
-                    _logger.exception("Error in console callback, clearing all!")
-                else:
-                    # Re-raise errors like KeyboardInterrupt.
-                    raise
+            if isinstance(e, Exception):
+                # We suppress Exceptions so that bugs in W&B code don't
+                # cause the user's print() statements to raise errors.
+                _logger.exception("Error in console callback, clearing all!")
+            else:
+                # Re-raise errors like KeyboardInterrupt.
+                raise
 
-            finally:
+        finally:
+            with _module_lock:
                 _is_writing = False
 
         return n