wandb 0.19.1rc1__py3-none-any.whl → 0.19.3__py3-none-any.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
+Metadata-Version: 2.4
 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
@@ -27,6 +27,7 @@ License: MIT License
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
+License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -65,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'
@@ -87,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'