wandb 0.19.1rc1__py3-none-win32.whl → 0.19.3__py3-none-win32.whl

wandb/sdk/wandb_setup.py

@@ -20,6 +20,7 @@ import threading
 from typing import TYPE_CHECKING, Any, Union
 
 import wandb
+import wandb.integration.sagemaker as sagemaker
 from wandb.sdk.lib import import_hooks
 
 from . import wandb_settings
@@ -61,29 +62,19 @@ class _EarlyLogger:
     def log(self, level: str, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((level, msg, args, kwargs))
 
-    def _flush(self) -> None:
-        assert self is not logger
-        assert logger is not None
+    def _flush(self, new_logger: Logger) -> None:
+        assert self is not new_logger
         for level, msg, args, kwargs in self._log:
-            logger.log(level, msg, *args, **kwargs)
+            new_logger.log(level, msg, *args, **kwargs)
         for msg, args, kwargs in self._exception:
-            logger.exception(msg, *args, **kwargs)
+            new_logger.exception(msg, *args, **kwargs)
 
 
 Logger = Union[logging.Logger, _EarlyLogger]
 
-# logger will be configured to be either a standard logger instance or _EarlyLogger
-logger: Logger | None = None
 
-
-def _set_logger(log_object: Logger) -> None:
-    """Configure module logger."""
-    global logger
-    logger = log_object
-
-
-class _WandbSetup__WandbSetup:  # noqa: N801
-    """Inner class of _WandbSetup."""
+class _WandbSetup:
+    """W&B library singleton."""
 
     def __init__(
         self,
@@ -104,48 +95,52 @@ class _WandbSetup__WandbSetup:  # noqa: N801
 
         # TODO(jhr): defer strict checks until settings are fully initialized
         #            and logging is ready
-        self._early_logger = _EarlyLogger()
-        _set_logger(self._early_logger)
+        self._logger: Logger = _EarlyLogger()
 
-        self._settings = self._settings_setup(settings, self._early_logger)
+        self._settings = self._settings_setup(settings)
 
-        wandb.termsetup(self._settings, logger)
+        wandb.termsetup(self._settings, None)
 
         self._check()
         self._setup()
 
     def _settings_setup(
         self,
-        settings: Settings | None = None,
-        early_logger: _EarlyLogger | None = None,
+        settings: Settings | None,
     ) -> wandb_settings.Settings:
         s = wandb_settings.Settings()
 
         # the pid of the process to monitor for system stats
         pid = os.getpid()
-        if early_logger:
-            early_logger.info(f"Current SDK version is {wandb.__version__}")
-            early_logger.info(f"Configure stats pid to {pid}")
+        self._logger.info(f"Current SDK version is {wandb.__version__}")
+        self._logger.info(f"Configure stats pid to {pid}")
         s.x_stats_pid = pid
 
         # load settings from the system config
-        if s.settings_system and early_logger:
-            early_logger.info(f"Loading settings from {s.settings_system}")
+        if s.settings_system:
+            self._logger.info(f"Loading settings from {s.settings_system}")
         s.update_from_system_config_file()
 
         # load settings from the workspace config
-        if s.settings_workspace and early_logger:
-            early_logger.info(f"Loading settings from {s.settings_workspace}")
+        if s.settings_workspace:
+            self._logger.info(f"Loading settings from {s.settings_workspace}")
         s.update_from_workspace_config_file()
 
         # load settings from the environment variables
-        if early_logger:
-            early_logger.info("Loading settings from environment variables")
+        self._logger.info("Loading settings from environment variables")
         s.update_from_env_vars(self._environ)
 
         # infer settings from the system environment
         s.update_from_system_environment()
 
+        # load SageMaker settings
+        check_sagemaker_env = not s.sagemaker_disable
+        if settings and settings.sagemaker_disable:
+            check_sagemaker_env = False
+        if check_sagemaker_env and sagemaker.is_using_sagemaker():
+            self._logger.info("Loading SageMaker settings")
+            sagemaker.set_global_settings(s)
+
         # load settings from the passed init/setup settings
         if settings:
             s.update_from_settings(settings)
@@ -165,13 +160,15 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             self._settings.update_from_dict(user_settings)
 
     def _early_logger_flush(self, new_logger: Logger) -> None:
-        if not self._early_logger:
+        if self._logger is new_logger:
             return
-        _set_logger(new_logger)
-        self._early_logger._flush()
 
-    def _get_logger(self) -> Logger | None:
-        return logger
+        if isinstance(self._logger, _EarlyLogger):
+            self._logger._flush(new_logger)
+        self._logger = new_logger
+
+    def _get_logger(self) -> Logger:
+        return self._logger
 
     @property
     def settings(self) -> wandb_settings.Settings:
@@ -236,16 +233,11 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             if threading.current_thread() is not threading.main_thread():
                 pass
         elif threading.current_thread().name != "MainThread":
-            print("bad thread2", threading.current_thread().name)
+            wandb.termwarn(f"bad thread2: {threading.current_thread().name}")
         if getattr(sys, "frozen", False):
-            print("frozen, could be trouble")
+            wandb.termwarn("frozen, could be trouble")
 
     def _setup(self) -> None:
-        if not self._settings._noop and not self._settings.x_disable_service:
-            from wandb.sdk.lib import service_connection
-
-            self._connection = service_connection.connect_to_service(self._settings)
-
         sweep_path = self._settings.sweep_param_path
         if sweep_path:
             self._sweep_config = config_util.dict_from_config_file(
@@ -278,53 +270,61 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         if internal_exit_code != 0:
             sys.exit(internal_exit_code)
 
-    @property
-    def service(self) -> ServiceConnection | None:
-        """Returns a connection to the service process, if it exists."""
+    def ensure_service(self) -> ServiceConnection:
+        """Returns a connection to the service process creating it if needed."""
+        if self._connection:
+            return self._connection
+
+        from wandb.sdk.lib import service_connection
+
+        self._connection = service_connection.connect_to_service(self._settings)
         return self._connection
 
+    def assert_service(self) -> ServiceConnection:
+        """Returns a connection to the service process, asserting it exists.
 
-class _WandbSetup:
-    """Wandb singleton class.
+        Unlike ensure_service(), this will not start up a service process
+        if it didn't already exist.
+        """
+        if not self._connection:
+            raise AssertionError("Expected service process to exist.")
 
-    Note: This is a process local singleton.
-    (Forked processes will get a new copy of the object)
-    """
+        return self._connection
 
-    _instance: _WandbSetup__WandbSetup | None = None
 
-    def __init__(self, settings: Settings | None = None) -> None:
-        pid = os.getpid()
-        if _WandbSetup._instance and _WandbSetup._instance._pid == pid:
-            _WandbSetup._instance._update(settings=settings)
-            return
-        _WandbSetup._instance = _WandbSetup__WandbSetup(settings=settings, pid=pid)
+_singleton: _WandbSetup | None = None
+"""The W&B library singleton, or None if not yet set up.
 
-    @property
-    def service(self) -> ServiceConnection | None:
-        """Returns a connection to the service process, if it exists."""
-        if not self._instance:
-            return None
-        return self._instance.service
+The value is invalid and must not be used if `os.getpid() != _singleton._pid`.
+"""
 
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._instance, name)
 
+def singleton() -> _WandbSetup | None:
+    """Returns the W&B singleton if it exists for the current process.
 
-def _setup(
-    settings: Settings | None = None,
-    _reset: bool = False,
-) -> _WandbSetup | None:
-    """Set up library context."""
-    if _reset:
-        teardown()
+    Unlike setup(), this does not create the singleton if it doesn't exist.
+    """
+    if _singleton and _singleton._pid == os.getpid():
+        return _singleton
+    else:
         return None
 
-    wl = _WandbSetup(settings=settings)
-    return wl
 
+def _setup(settings: Settings | None = None) -> _WandbSetup:
+    """Set up library context."""
+    global _singleton
+
+    pid = os.getpid()
 
-def setup(settings: Settings | None = None) -> _WandbSetup | None:
+    if _singleton and _singleton._pid == pid:
+        _singleton._update(settings=settings)
+        return _singleton
+    else:
+        _singleton = _WandbSetup(settings=settings, pid=pid)
+        return _singleton
+
+
+def setup(settings: Settings | None = None) -> _WandbSetup:
     """Prepares W&B for use in the current process and its children.
 
     You can usually ignore this as it is implicitly called by `wandb.init()`.
@@ -380,8 +380,7 @@ def setup(settings: Settings | None = None) -> _WandbSetup | None:
             wandb.teardown()
         ```
     """
-    ret = _setup(settings=settings)
-    return ret
+    return _setup(settings=settings)
 
 
 def teardown(exit_code: int | None = None) -> None:
@@ -395,8 +394,10 @@ def teardown(exit_code: int | None = None) -> None:
     in an `atexit` hook, but this is not reliable in certain setups
     such as when using Python's `multiprocessing` module.
     """
-    setup_instance = _WandbSetup._instance
-    _WandbSetup._instance = None
+    global _singleton
+
+    orig_singleton = _singleton
+    _singleton = None
 
-    if setup_instance:
-        setup_instance._teardown(exit_code=exit_code)
+    if orig_singleton:
+        orig_singleton._teardown(exit_code=exit_code)

wandb/sdk/wandb_sweep.py

@@ -85,10 +85,10 @@ def sweep(
     api = InternalApi()
     sweep_id, warnings = api.upsert_sweep(sweep, prior_runs=prior_runs)
     handle_sweep_config_violations(warnings)
-    print("Create sweep with ID:", sweep_id)
+    print("Create sweep with ID:", sweep_id)  # noqa: T201
     sweep_url = _get_sweep_url(api, sweep_id)
     if sweep_url:
-        print("Sweep URL:", sweep_url)
+        print("Sweep URL:", sweep_url)  # noqa: T201
     return sweep_id
 
 

wandb/sdk/wandb_sync.py

@@ -1,6 +1,7 @@
 import pathlib
 from typing import TYPE_CHECKING, Optional
 
+from wandb import util
 from wandb.errors.term import termerror, termlog
 
 from . import wandb_setup
@@ -21,26 +22,31 @@ def _sync(
     append: Optional[bool] = None,
     skip_console: Optional[bool] = None,
 ) -> "wandb_internal_pb2.SyncResponse":
-    p = pathlib.Path(path)
-
     wl = wandb_setup.setup()
     assert wl is not None
 
     stream_id = generate_id()
 
     settings = wl.settings.to_proto()
+    p = pathlib.Path(path)
+
     # update sync_file setting to point to the passed path
     settings.sync_file.value = str(p.absolute())
     settings.sync_dir.value = str(p.parent.absolute())
     settings.files_dir.value = str(p.parent.absolute() / "files")
-    settings._sync.value = True
-    settings.run_id.value = stream_id  # TODO: remove this
+    settings.x_sync.value = True
+    if run_id:
+        settings.run_id.value = run_id
+    if entity:
+        settings.entity.value = entity
+    if project:
+        settings.project.value = project
+    if skip_console:
+        settings.console.value = "off"
     if append:
         settings.resume.value = "allow"
 
-    service = wl.service
-    assert service
-
+    service = wl.ensure_service()
     service.inform_init(settings=settings, run_id=stream_id)
 
     mailbox = Mailbox()
@@ -55,21 +61,12 @@ def _sync(
     backend.interface._stream_id = stream_id  # type: ignore
 
     mailbox.enable_keepalive()
-
-    # TODO: let's add extra sync messages here so we get the url in the beginning
-    handle = backend.interface.deliver_sync(
-        start_offset=0,
-        final_offset=-1,
-        entity=entity,
-        project=project,
-        run_id=run_id,
-        skip_output_raw=skip_console,
-    )
+    handle = backend.interface.deliver_finish_sync()
     result = handle.wait(timeout=-1)
     assert result and result.response
     response = result.response.sync_response
     if response.url:
-        termlog(f"Synced {p} to {response.url}")
+        termlog(f"Synced {p} to {util.app_url(response.url)}")
         # create a .synced file in the directory if mark_synced is true
         if mark_synced:
             with open(f"{p}.synced", "w"):

wandb/sync/sync.py

@@ -81,9 +81,9 @@ class SyncThread(threading.Thread):
         record_type = pb.WhichOneof("record_type")
         if self._view:
             if self._verbose:
-                print("Record:", pb)
+                print("Record:", pb)  # noqa: T201
             else:
-                print("Record:", record_type)
+                print("Record:", record_type)  # noqa: T201
             return pb, exit_pb, True
         if record_type == "run":
             if self._run_id:
@@ -137,7 +137,7 @@ class SyncThread(threading.Thread):
             if tb_event_files > 0 and sync_item.endswith(WANDB_SUFFIX):
                 wandb.termwarn("Found .wandb file, not streaming tensorboard metrics.")
             else:
-                print(f"Found {tb_event_files} tfevent files in {tb_root}")
+                print(f"Found {tb_event_files} tfevent files in {tb_root}")  # noqa: T201
                 if len(tb_logdirs) > 3:
                     wandb.termwarn(
                         f"Found {len(tb_logdirs)} directories containing tfevent files. "
@@ -163,7 +163,7 @@ class SyncThread(threading.Thread):
             url_quote(proto_run.project),
             url_quote(proto_run.run_id),
         )
-        print("Syncing: {} ...".format(url))
+        print("Syncing: {} ...".format(url))  # noqa: T201
         sys.stdout.flush()
         # using a handler here automatically handles the step
         # logic, adds summaries to the run, and handles different
@@ -245,7 +245,7 @@ class SyncThread(threading.Thread):
 
     def run(self):
         if self._log_path is not None:
-            print(f"Find logs at: {self._log_path}")
+            print(f"Find logs at: {self._log_path}")  # noqa: T201
         for sync_item in self._sync_list:
             tb_event_files, tb_logdirs, tb_root = self._find_tfevent_files(sync_item)
             if os.path.isdir(sync_item):
@@ -254,7 +254,7 @@ class SyncThread(threading.Thread):
                 if tb_root is None and (
                     check_and_warn_old(files) or len(filtered_files) != 1
                 ):
-                    print(f"Skipping directory: {sync_item}")
+                    print(f"Skipping directory: {sync_item}")  # noqa: T201
                     continue
                 if len(filtered_files) > 0:
                     sync_item = os.path.join(sync_item, filtered_files[0])
@@ -265,7 +265,7 @@ class SyncThread(threading.Thread):
             root_dir = self._tmp_dir.name if sync_tb else os.path.dirname(sync_item)
 
             # When appending we are allowing a possible resume, ie the run
-            # doesnt have to exist already
+            # does not have to exist already
             resume = "allow" if self._append else None
 
             sm = sender.SendManager.setup(root_dir, resume=resume)
@@ -277,7 +277,7 @@ class SyncThread(threading.Thread):
             try:
                 ds.open_for_scan(sync_item)
             except AssertionError as e:
-                print(f".wandb file is empty ({e}), skipping: {sync_item}")
+                print(f".wandb file is empty ({e}), skipping: {sync_item}")  # noqa: T201
                 continue
 
             # save exit for final send
@@ -311,7 +311,7 @@ class SyncThread(threading.Thread):
                             url_quote(r.project),
                             url_quote(r.run_id),
                         )
-                        print("Syncing: {} ... ".format(url), end="")
+                        print("Syncing: {} ... ".format(url), end="")  # noqa: T201
                         sys.stdout.flush()
                         shown = True
             sm.finish()
@@ -320,7 +320,7 @@ class SyncThread(threading.Thread):
                 synced_file = f"{sync_item}{SYNCED_SUFFIX}"
                 with open(synced_file, "w"):
                     pass
-            print("done.")
+            print("done.")  # noqa: T201
 
 
 class SyncManager:

wandb/util.py

@@ -1717,9 +1717,17 @@ def _get_max_cli_version() -> Union[str, None]:
 
 
 def _is_offline() -> bool:
-    return (  # type: ignore[no-any-return]
-        wandb.run is not None and wandb.run.settings._offline
-    ) or wandb.setup().settings._offline  # type: ignore
+    """Returns true if wandb is configured to be offline.
+
+    If there is an active run, returns whether the run is offline.
+    Otherwise, returns the default mode, which is affected by explicit settings
+    passed to `wandb.setup()`, environment variables, and W&B configuration
+    files.
+    """
+    if wandb.run:
+        return wandb.run.settings._offline
+    else:
+        return wandb.setup().settings._offline
 
 
 def ensure_text(

wandb/wandb_agent.py

@@ -62,10 +62,10 @@ class AgentProcess:
                 os.environ[k] = v
 
         # call user function
-        print("wandb: Agent Started Run:", run_id)
+        wandb.termlog(f"Agent Started Run: {run_id}")
         if function:
             function()
-        print("wandb: Agent Finished Run:", run_id, "\n")
+        wandb.termlog(f"Agent Finished Run: {run_id}\n")
 
         # complete the run
         run = wandb.run
@@ -92,7 +92,7 @@ class AgentProcess:
 
     def wait(self):
         if self._popen:
-            # if on windows, wait() will block and we wont be able to interrupt
+            # if on windows, wait() will block and we won't be able to interrupt
             if platform.system() == "Windows":
                 try:
                     while True:
@@ -353,15 +353,10 @@ class Agent:
             )
         )
         if self._in_jupyter:
-            print(
-                "wandb: Agent Starting Run: {} with config:\n".format(
-                    command.get("run_id")
-                )
+            wandb.termlog(
+                f"Agent Starting Run: {command.get('run_id')} with config:\n"
                 + "\n".join(
-                    [
-                        "\t{}: {}".format(k, v["value"])
-                        for k, v in command["args"].items()
-                    ]
+                    [f"\t{k}: {v['value']}" for k, v in command["args"].items()]
                 )
             )
 
@@ -397,7 +392,7 @@ class Agent:
 
         if self._function:
             # make sure that each run regenerates setup singleton
-            wandb_sdk.wandb_setup._setup(_reset=True)
+            wandb.teardown()
             proc = AgentProcess(
                 function=self._function,
                 env=env,
@@ -477,12 +472,12 @@ class AgentApi:
         command["resp_queue"] = resp_queue
         self._queue.put(command)
         result = resp_queue.get()
-        print("result:", result)
+        print("result:", result)  # noqa: T201
         if "exception" in result:
-            print("Exception occurred while running command")
+            print("Exception occurred while running command")  # noqa: T201
             for line in result["traceback"]:
-                print(line.strip())
-            print(result["exception"])
+                print(line.strip())  # noqa: T201
+            print(result["exception"])  # noqa: T201
         return result
 
 

wandb/wandb_controller.py

@@ -353,19 +353,19 @@ class _WandbController:
         self._logged += 1
 
     def _error(self, s: str) -> None:
-        print("ERROR:", s)
+        print("ERROR:", s)  # noqa: T201
         self._log()
 
     def _warn(self, s: str) -> None:
-        print("WARN:", s)
+        print("WARN:", s)  # noqa: T201
         self._log()
 
     def _info(self, s: str) -> None:
-        print("INFO:", s)
+        print("INFO:", s)  # noqa: T201
         self._log()
 
     def _debug(self, s: str) -> None:
-        print("DEBUG:", s)
+        print("DEBUG:", s)  # noqa: T201
         self._log()
 
     def _configure_check(self) -> None:
@@ -396,10 +396,10 @@ class _WandbController:
         sweep_id, warnings = self._api.upsert_sweep(self._create)
         handle_sweep_config_violations(warnings)
 
-        print("Create sweep with ID:", sweep_id)
+        print("Create sweep with ID:", sweep_id)  # noqa: T201
         sweep_url = wandb_sweep._get_sweep_url(self._api, sweep_id)
         if sweep_url:
-            print("Sweep URL:", sweep_url)
+            print("Sweep URL:", sweep_url)  # noqa: T201
         self._sweep_id = sweep_id
         self._defer_sweep_creation = False
         return sweep_id
@@ -636,7 +636,7 @@ class _WandbController:
     def print_status(self) -> None:
         status = _sweep_status(self._sweep_obj, self._sweep_config, self._sweep_runs)
         if self._laststatus != status or self._logged:
-            print(status)
+            print(status)  # noqa: T201
         self._laststatus = status
         self._logged = 0
 

{wandb-0.19.1rc1.dist-info → wandb-0.19.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wandb
-Version: 0.19.1rc1
+Version: 0.19.3
 Summary: A CLI and library for interacting with the Weights & Biases API.
 Project-URL: Source, https://github.com/wandb/wandb
 Project-URL: Bug Reports, https://github.com/wandb/wandb/issues
@@ -66,6 +66,7 @@ Requires-Dist: setuptools
 Requires-Dist: typing-extensions<5,>=4.4; python_version < '3.12'
 Provides-Extra: aws
 Requires-Dist: boto3; extra == 'aws'
+Requires-Dist: botocore>=1.5.76; extra == 'aws'
 Provides-Extra: azure
 Requires-Dist: azure-identity; extra == 'azure'
 Requires-Dist: azure-storage-blob; extra == 'azure'
@@ -88,7 +89,7 @@ Requires-Dist: azure-containerregistry; extra == 'launch'
 Requires-Dist: azure-identity; extra == 'launch'
 Requires-Dist: azure-storage-blob; extra == 'launch'
 Requires-Dist: boto3; extra == 'launch'
-Requires-Dist: botocore; extra == 'launch'
+Requires-Dist: botocore>=1.5.76; extra == 'launch'
 Requires-Dist: chardet; extra == 'launch'
 Requires-Dist: google-auth; extra == 'launch'
 Requires-Dist: google-cloud-aiplatform; extra == 'launch'