Add files using upload-large-folder tool

.gitattributes

@@ -745,3 +745,12 @@ deepseekvl2/lib/python3.10/lib-dynload/_curses.cpython-310-x86_64-linux-gnu.so f
 deepseekvl2/lib/python3.10/lib-dynload/_struct.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 deepseekvl2/lib/python3.10/lib-dynload/audioop.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 deepseekvl2/lib/python3.10/lib-dynload/_testcapi.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_codecs_hk.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_zoneinfo.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_ssl.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_testclinic.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_lzma.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/readline.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_codecs_tw.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/lib-dynload/_socket.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

deepseekvl2/lib/python3.10/lib-dynload/_codecs_hk.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5028632a8d7f167721ab2e0de42fb9e1c4ea5a80161005dabfb5c559f784dcb
+size 194368

deepseekvl2/lib/python3.10/lib-dynload/_codecs_tw.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:148bfe2a46df83fdece3e335e31ff78e92a273a1bfe660764988c88682ea3066
+size 143232

deepseekvl2/lib/python3.10/lib-dynload/_lzma.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebfdcab2537ab089e99839348e41c28e8ce2b63d58d095f94c9f80a753748b0b
+size 145376

deepseekvl2/lib/python3.10/lib-dynload/_socket.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:457b4b1f4e960408aea7e2a1cbb92a8840ac68a682ecf5baf3450ee0e796fc00
+size 283680

deepseekvl2/lib/python3.10/lib-dynload/_ssl.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f93473eb2cfe128149c6d2973086402faa935d68856a103c752d0b513925432e
+size 499736

deepseekvl2/lib/python3.10/lib-dynload/_testclinic.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d21d17fa352f1e585afb8240dcbe49ad67b9bed71232b699c294b97820792559
+size 205672

deepseekvl2/lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:462ae2906ffebca406891ed2955376243f777336816acb18c6efc32aa1249e8d
+size 149936

deepseekvl2/lib/python3.10/lib-dynload/_zoneinfo.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb38a8e751825aa95af436b17da44762c3f446a02c33ee193788d4ab02124017
+size 160600

deepseekvl2/lib/python3.10/lib-dynload/readline.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96bcc678065c5ffab0324a9b557a7511f7fda79d85d84fafb7f2012261f4cee7
+size 112992

infer_4_33_0/lib/python3.10/site-packages/wandb/agents/pyagent.py

@@ -0,0 +1,363 @@
+"""Agent - Agent object.
+
+Manage wandb agent.
+
+"""
+
+import ctypes
+import logging
+import os
+import queue
+import socket
+import threading
+import time
+import traceback
+
+import wandb
+from wandb.apis import InternalApi
+from wandb.sdk.launch.sweeps import utils as sweep_utils
+
+logger = logging.getLogger(__name__)
+
+
+def _terminate_thread(thread):
+    if not thread.is_alive():
+        return
+    if hasattr(thread, "_terminated"):
+        return
+    thread._terminated = True
+    tid = getattr(thread, "_thread_id", None)
+    if tid is None:
+        for k, v in threading._active.items():
+            if v is thread:
+                tid = k
+    if tid is None:
+        # This should never happen
+        return
+    logger.debug(f"Terminating thread: {tid}")
+    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+        ctypes.c_long(tid), ctypes.py_object(Exception)
+    )
+    if res == 0:
+        # This should never happen
+        return
+    elif res != 1:
+        # Revert
+        logger.debug(f"Termination failed for thread {tid}")
+        ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), None)
+
+
+class Job:
+    def __init__(self, command):
+        self.command = command
+        job_type = command.get("type")
+        self.type = job_type
+        self.run_id = command.get("run_id")
+        self.config = command.get("args")
+
+    def __repr__(self):
+        if self.type == "run":
+            return f"Job({self.run_id},{self.config})"
+        elif self.type == "stop":
+            return f"stop({self.run_id})"
+        else:
+            return "exit"
+
+
+class RunStatus:
+    QUEUED = "QUEUED"
+    RUNNING = "RUNNING"
+    STOPPED = "STOPPED"
+    ERRORED = "ERRORED"
+    DONE = "DONE"
+
+
+class Agent:
+    FLAPPING_MAX_SECONDS = 60
+    FLAPPING_MAX_FAILURES = 3
+    MAX_INITIAL_FAILURES = 5
+
+    def __init__(
+        self, sweep_id=None, project=None, entity=None, function=None, count=None
+    ):
+        self._sweep_path = sweep_id
+        self._sweep_id = None
+        self._project = project
+        self._entity = entity
+        self._function = function
+        self._count = count
+        # glob_config = os.path.expanduser('~/.config/wandb/settings')
+        # loc_config = 'wandb/settings'
+        # files = (glob_config, loc_config)
+        self._api = InternalApi()
+        self._agent_id = None
+        self._max_initial_failures = wandb.env.get_agent_max_initial_failures(
+            self.MAX_INITIAL_FAILURES
+        )
+        # if the directory to log to is not set, set it
+        if os.environ.get(wandb.env.DIR) is None:
+            os.environ[wandb.env.DIR] = os.path.abspath(os.getcwd())
+
+    def _init(self):
+        # These are not in constructor so that Agent instance can be rerun
+        self._run_threads = {}
+        self._run_status = {}
+        self._queue = queue.Queue()
+        self._exit_flag = False
+        self._exceptions = {}
+        self._start_time = time.time()
+
+    def _register(self):
+        logger.debug("Agent._register()")
+        agent = self._api.register_agent(socket.gethostname(), sweep_id=self._sweep_id)
+        self._agent_id = agent["id"]
+        logger.debug(f"agent_id = {self._agent_id}")
+
+    def _setup(self):
+        logger.debug("Agent._setup()")
+        self._init()
+        parts = dict(entity=self._entity, project=self._project, name=self._sweep_path)
+        err = sweep_utils.parse_sweep_id(parts)
+        if err:
+            wandb.termerror(err)
+            return
+        entity = parts.get("entity") or self._entity
+        project = parts.get("project") or self._project
+        sweep_id = parts.get("name") or self._sweep_id
+        if sweep_id:
+            os.environ[wandb.env.SWEEP_ID] = sweep_id
+        if entity:
+            wandb.env.set_entity(entity)
+        if project:
+            wandb.env.set_project(project)
+        if sweep_id:
+            self._sweep_id = sweep_id
+        self._register()
+
+    def _stop_run(self, run_id):
+        logger.debug(f"Stopping run {run_id}.")
+        self._run_status[run_id] = RunStatus.STOPPED
+        thread = self._run_threads.get(run_id)
+        if thread:
+            _terminate_thread(thread)
+
+    def _stop_all_runs(self):
+        logger.debug("Stopping all runs.")
+        for run in list(self._run_threads.keys()):
+            self._stop_run(run)
+
+    def _exit(self):
+        self._stop_all_runs()
+        self._exit_flag = True
+        # _terminate_thread(self._main_thread)
+
+    def _heartbeat(self):
+        while True:
+            if self._exit_flag:
+                return
+            # if not self._main_thread.is_alive():
+            #     return
+            run_status = {
+                run: True
+                for run, status in self._run_status.items()
+                if status in (RunStatus.QUEUED, RunStatus.RUNNING)
+            }
+            commands = self._api.agent_heartbeat(self._agent_id, {}, run_status)
+            if commands:
+                job = Job(commands[0])
+                logger.debug(f"Job received: {job}")
+                if job.type in ["run", "resume"]:
+                    self._queue.put(job)
+                    self._run_status[job.run_id] = RunStatus.QUEUED
+                elif job.type == "stop":
+                    self._stop_run(job.run_id)
+                elif job.type == "exit":
+                    self._exit()
+                    return
+            time.sleep(5)
+
+    def _run_jobs_from_queue(self):  # noqa:C901
+        global _INSTANCES
+        _INSTANCES += 1
+        try:
+            waiting = False
+            count = 0
+            while True:
+                if self._exit_flag:
+                    return
+                try:
+                    try:
+                        job = self._queue.get(timeout=5)
+                        if self._exit_flag:
+                            logger.debug("Exiting main loop due to exit flag.")
+                            wandb.termlog("Sweep Agent: Exiting.")
+                            return
+                    except queue.Empty:
+                        if not waiting:
+                            logger.debug("Paused.")
+                            wandb.termlog("Sweep Agent: Waiting for job.")
+                            waiting = True
+                        time.sleep(5)
+                        if self._exit_flag:
+                            logger.debug("Exiting main loop due to exit flag.")
+                            wandb.termlog("Sweep Agent: Exiting.")
+                            return
+                        continue
+                    if waiting:
+                        logger.debug("Resumed.")
+                        wandb.termlog("Job received.")
+                        waiting = False
+                    count += 1
+                    run_id = job.run_id
+                    if self._run_status[run_id] == RunStatus.STOPPED:
+                        continue
+                    logger.debug(f"Spawning new thread for run {run_id}.")
+                    thread = threading.Thread(target=self._run_job, args=(job,))
+                    self._run_threads[run_id] = thread
+                    thread.start()
+                    self._run_status[run_id] = RunStatus.RUNNING
+                    thread.join()
+                    logger.debug(f"Thread joined for run {run_id}.")
+                    if self._run_status[run_id] == RunStatus.RUNNING:
+                        self._run_status[run_id] = RunStatus.DONE
+                    elif self._run_status[run_id] == RunStatus.ERRORED:
+                        exc = self._exceptions[run_id]
+                        exc_type, exc_value, exc_traceback = (
+                            exc.__class__,
+                            exc,
+                            exc.__traceback__,
+                        )
+                        exc_traceback_formatted = traceback.format_exception(
+                            exc_type, exc_value, exc_traceback
+                        )
+                        exc_repr = "".join(exc_traceback_formatted)
+                        logger.error(f"Run {run_id} errored:\n{exc_repr}")
+                        wandb.termerror(f"Run {run_id} errored:\n{exc_repr}")
+                        if os.getenv(wandb.env.AGENT_DISABLE_FLAPPING) == "true":
+                            self._exit_flag = True
+                            return
+                        elif (
+                            time.time() - self._start_time < self.FLAPPING_MAX_SECONDS
+                        ) and (len(self._exceptions) >= self.FLAPPING_MAX_FAILURES):
+                            msg = "Detected {} failed runs in the first {} seconds, killing sweep.".format(
+                                self.FLAPPING_MAX_FAILURES, self.FLAPPING_MAX_SECONDS
+                            )
+                            logger.error(msg)
+                            wandb.termerror(msg)
+                            wandb.termlog(
+                                "To disable this check set WANDB_AGENT_DISABLE_FLAPPING=true"
+                            )
+                            self._exit_flag = True
+                            return
+                        if (
+                            self._max_initial_failures < len(self._exceptions)
+                            and len(self._exceptions) >= count
+                        ):
+                            msg = "Detected {} failed runs in a row at start, killing sweep.".format(
+                                self._max_initial_failures
+                            )
+                            logger.error(msg)
+                            wandb.termerror(msg)
+                            wandb.termlog(
+                                "To change this value set WANDB_AGENT_MAX_INITIAL_FAILURES=val"
+                            )
+                            self._exit_flag = True
+                            return
+                    if self._count and self._count == count:
+                        logger.debug("Exiting main loop because max count reached.")
+                        self._exit_flag = True
+                        return
+                except KeyboardInterrupt:
+                    logger.debug("Ctrl + C detected. Stopping sweep.")
+                    wandb.termlog("Ctrl + C detected. Stopping sweep.")
+                    self._exit()
+                    return
+                except Exception as e:
+                    if self._exit_flag:
+                        logger.debug("Exiting main loop due to exit flag.")
+                        wandb.termlog("Sweep Agent: Killed.")
+                        return
+                    else:
+                        raise e
+        finally:
+            _INSTANCES -= 1
+
+    def _run_job(self, job):
+        try:
+            run_id = job.run_id
+
+            config_file = os.path.join(
+                "wandb", "sweep-" + self._sweep_id, "config-" + run_id + ".yaml"
+            )
+            os.environ[wandb.env.RUN_ID] = run_id
+            base_dir = os.environ.get(wandb.env.DIR, "")
+            sweep_param_path = os.path.join(base_dir, config_file)
+            os.environ[wandb.env.SWEEP_PARAM_PATH] = sweep_param_path
+            wandb.wandb_lib.config_util.save_config_file_from_dict(
+                sweep_param_path, job.config
+            )
+            os.environ[wandb.env.SWEEP_ID] = self._sweep_id
+            wandb.teardown()
+
+            wandb.termlog(f"Agent Starting Run: {run_id} with config:")
+            for k, v in job.config.items():
+                wandb.termlog("\t{}: {}".format(k, v["value"]))
+
+            self._function()
+            wandb.finish()
+        except KeyboardInterrupt as ki:
+            raise ki
+        except Exception as e:
+            wandb.finish(exit_code=1)
+            if self._run_status[run_id] == RunStatus.RUNNING:
+                self._run_status[run_id] = RunStatus.ERRORED
+                self._exceptions[run_id] = e
+        finally:
+            # clean up the environment changes made
+            os.environ.pop(wandb.env.RUN_ID, None)
+            os.environ.pop(wandb.env.SWEEP_ID, None)
+            os.environ.pop(wandb.env.SWEEP_PARAM_PATH, None)
+
+    def run(self):
+        logger.info(
+            "Starting sweep agent: entity={}, project={}, count={}".format(
+                self._entity, self._project, self._count
+            )
+        )
+        self._setup()
+        # self._main_thread = threading.Thread(target=self._run_jobs_from_queue)
+        self._heartbeat_thread = threading.Thread(target=self._heartbeat)
+        self._heartbeat_thread.daemon = True
+        # self._main_thread.start()
+        self._heartbeat_thread.start()
+        # self._main_thread.join()
+        self._run_jobs_from_queue()
+
+
+def pyagent(sweep_id, function, entity=None, project=None, count=None):
+    """Generic agent entrypoint, used for CLI or jupyter.
+
+    Args:
+        sweep_id (dict): Sweep ID generated by CLI or sweep API
+        function (func, optional): A function to call instead of the "program"
+        entity (str, optional): W&B Entity
+        project (str, optional): W&B Project
+        count (int, optional): the number of trials to run.
+    """
+    if not callable(function):
+        raise Exception("function parameter must be callable!")
+    agent = Agent(
+        sweep_id,
+        function=function,
+        entity=entity,
+        project=project,
+        count=count,
+    )
+    agent.run()
+
+
+_INSTANCES = 0
+
+
+def is_running():
+    return bool(_INSTANCES)

infer_4_33_0/lib/python3.10/site-packages/wandb/docker/wandb-entrypoint.sh

@@ -0,0 +1,33 @@
+#!/bin/sh
+set -e
+
+wandb="\x1b[34m\x1b[1mwandb\x1b[0m"
+/bin/echo -e "${wandb}: Checking image for required packages."
+
+if ! [ -x "$(command -v python)" ]; then
+    /bin/echo -e "${wandb}: python not installed, can't use wandb with this image."
+    exit 1
+fi
+
+if ! [ -x "$(command -v wandb)" ]; then
+    /bin/echo -e "${wandb}: wandb not installed, installing."
+    pip install wandb --upgrade
+else
+    ver=$(wandb --version)
+    /bin/echo -e "${wandb}: Found $ver"
+fi
+
+if [ "$WANDB_ENSURE_JUPYTER" = "1" ]; then
+    if ! [ -x "$(command -v jupyter-lab)" ]; then
+        /bin/echo -e "${wandb}: jupyter not installed, installing."
+        pip install jupyterlab
+        /bin/echo -e "${wandb}: starting jupyter, you can access it at: http://127.0.0.1:8888"
+    fi
+fi
+
+if ! [ -z "$WANDB_COMMAND" ]; then
+    /bin/echo $WANDB_COMMAND >> ~/.bash_history
+    /bin/echo -e "${wandb}: Command added to history, press up arrow to access it."
+    /bin/echo -e "${wandb}: $WANDB_COMMAND"
+fi
+exec "$@"

infer_4_33_0/lib/python3.10/site-packages/wandb/docker/www_authenticate.py

@@ -0,0 +1,94 @@
+# Taken from: https://github.com/alexsdutton/www-authenticate
+import re
+from collections import OrderedDict
+from typing import Any, Optional
+
+_tokens = (
+    ("token", re.compile(r"""^([!#$%&'*+\-.^_`|~\w/]+(?:={1,2}$)?)""")),
+    ("token", re.compile(r'''^"((?:[^"\\]|\\\\|\\")+)"''')),
+    (None, re.compile(r"^\s+")),
+    ("equals", re.compile(r"^(=)")),
+    ("comma", re.compile(r"^(,)")),
+)
+
+
+def _casefold(value: str) -> str:
+    try:
+        return value.casefold()
+    except AttributeError:
+        return value.lower()
+
+
+class CaseFoldedOrderedDict(OrderedDict):
+    def __getitem__(self, key: str) -> Any:
+        return super().__getitem__(_casefold(key))
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        super().__setitem__(_casefold(key), value)
+
+    def __contains__(self, key: object) -> bool:
+        return super().__contains__(_casefold(key))  # type: ignore
+
+    def get(self, key: str, default: Optional[Any] = None) -> Any:
+        return super().get(_casefold(key), default)
+
+    def pop(self, key: str, default: Optional[Any] = None) -> Any:
+        return super().pop(_casefold(key), default)
+
+
+def _group_pairs(tokens: list) -> None:
+    i = 0
+    while i < len(tokens) - 2:
+        if (
+            tokens[i][0] == "token"
+            and tokens[i + 1][0] == "equals"
+            and tokens[i + 2][0] == "token"
+        ):
+            tokens[i : i + 3] = [("pair", (tokens[i][1], tokens[i + 2][1]))]
+        i += 1
+
+
+def _group_challenges(tokens: list) -> list:
+    challenges = []
+    while tokens:
+        j = 1
+        if len(tokens) == 1:
+            pass
+        elif tokens[1][0] == "comma":
+            pass
+        elif tokens[1][0] == "token":
+            j = 2
+        else:
+            while j < len(tokens) and tokens[j][0] == "pair":
+                j += 2
+            j -= 1
+        challenges.append((tokens[0][1], tokens[1:j]))
+        tokens[: j + 1] = []
+    return challenges
+
+
+def parse(value: str) -> CaseFoldedOrderedDict:
+    tokens = []
+    while value:
+        for token_name, pattern in _tokens:
+            match = pattern.match(value)
+            if match:
+                value = value[match.end() :]
+                if token_name:
+                    tokens.append((token_name, match.group(1)))
+                break
+        else:
+            raise ValueError("Failed to parse value")
+    _group_pairs(tokens)
+
+    challenges = CaseFoldedOrderedDict()
+    for name, tokens in _group_challenges(tokens):  # noqa: B020
+        args, kwargs = [], {}
+        for token_name, value in tokens:
+            if token_name == "token":
+                args.append(value)
+            elif token_name == "pair":
+                kwargs[value[0]] = value[1]
+        challenges[name] = (args and args[0]) or kwargs or None
+
+    return challenges

infer_4_33_0/lib/python3.10/site-packages/wandb/sdk/__init__.py

@@ -0,0 +1,37 @@
+"""W&B SDK module."""
+
+__all__ = (
+    "Config",
+    "Settings",
+    "Summary",
+    "Artifact",
+    "AlertLevel",
+    "init",
+    "setup",
+    "_attach",
+    "_sync",
+    "login",
+    "require",
+    "finish",
+    "teardown",
+    "_watch",
+    "_unwatch",
+    "sweep",
+    "controller",
+    "helper",
+)
+
+from . import wandb_helper as helper
+from .artifacts.artifact import Artifact
+from .wandb_alerts import AlertLevel
+from .wandb_config import Config
+from .wandb_init import _attach, init
+from .wandb_login import login
+from .wandb_require import require
+from .wandb_run import finish
+from .wandb_settings import Settings
+from .wandb_setup import setup, teardown
+from .wandb_summary import Summary
+from .wandb_sweep import controller, sweep
+from .wandb_sync import _sync
+from .wandb_watch import _unwatch, _watch

infer_4_33_0/lib/python3.10/site-packages/wandb/sdk/wandb_config.py

@@ -0,0 +1,322 @@
+"""config."""
+
+import logging
+from typing import Optional
+
+import wandb
+from wandb.util import (
+    _is_artifact_representation,
+    check_dict_contains_nested_artifact,
+    json_friendly_val,
+)
+
+from . import wandb_helper
+from .lib import config_util
+
+logger = logging.getLogger("wandb")
+
+
+# TODO(jhr): consider a callback for persisting changes?
+# if this is done right we might make sure this is pickle-able
+# we might be able to do this on other objects like Run?
+class Config:
+    """Config object.
+
+    Config objects are intended to hold all of the hyperparameters associated with
+    a wandb run and are saved with the run object when `wandb.init` is called.
+
+    We recommend setting `wandb.config` once at the top of your training experiment or
+    setting the config as a parameter to init, ie. `wandb.init(config=my_config_dict)`
+
+    You can create a file called `config-defaults.yaml`, and it will automatically be
+    loaded into `wandb.config`. See https://docs.wandb.com/guides/track/config#file-based-configs.
+
+    You can also load a config YAML file with your custom name and pass the filename
+    into `wandb.init(config="special_config.yaml")`.
+    See https://docs.wandb.com/guides/track/config#file-based-configs.
+
+    Examples:
+        Basic usage
+        ```
+        wandb.config.epochs = 4
+        wandb.init()
+        for x in range(wandb.config.epochs):
+            # train
+        ```
+
+        Using wandb.init to set config
+        ```
+        wandb.init(config={"epochs": 4, "batch_size": 32})
+        for x in range(wandb.config.epochs):
+            # train
+        ```
+
+        Nested configs
+        ```
+        wandb.config['train']['epochs'] = 4
+        wandb.init()
+        for x in range(wandb.config['train']['epochs']):
+            # train
+        ```
+
+        Using absl flags
+        ```
+        flags.DEFINE_string("model", None, "model to run")  # name, default, help
+        wandb.config.update(flags.FLAGS)  # adds all absl flags to config
+        ```
+
+        Argparse flags
+        ```python
+        wandb.init()
+        wandb.config.epochs = 4
+
+        parser = argparse.ArgumentParser()
+        parser.add_argument(
+            "-b",
+            "--batch-size",
+            type=int,
+            default=8,
+            metavar="N",
+            help="input batch size for training (default: 8)",
+        )
+        args = parser.parse_args()
+        wandb.config.update(args)
+        ```
+
+        Using TensorFlow flags (deprecated in tensorflow v2)
+        ```python
+        flags = tf.app.flags
+        flags.DEFINE_string("data_dir", "/tmp/data")
+        flags.DEFINE_integer("batch_size", 128, "Batch size.")
+        wandb.config.update(flags.FLAGS)  # adds all of the tensorflow flags to config
+        ```
+    """
+
+    def __init__(self):
+        object.__setattr__(self, "_items", dict())
+        object.__setattr__(self, "_locked", dict())
+        object.__setattr__(self, "_users", dict())
+        object.__setattr__(self, "_users_inv", dict())
+        object.__setattr__(self, "_users_cnt", 0)
+        object.__setattr__(self, "_callback", None)
+        object.__setattr__(self, "_settings", None)
+        object.__setattr__(self, "_artifact_callback", None)
+
+        self._load_defaults()
+
+    def _set_callback(self, cb):
+        object.__setattr__(self, "_callback", cb)
+
+    def _set_artifact_callback(self, cb):
+        object.__setattr__(self, "_artifact_callback", cb)
+
+    def _set_settings(self, settings):
+        object.__setattr__(self, "_settings", settings)
+
+    def __repr__(self):
+        return str(dict(self))
+
+    def keys(self):
+        return [k for k in self._items.keys() if not k.startswith("_")]
+
+    def _as_dict(self):
+        return self._items
+
+    def as_dict(self):
+        # TODO: add telemetry, deprecate, then remove
+        return dict(self)
+
+    def __getitem__(self, key):
+        return self._items[key]
+
+    def __iter__(self):
+        return iter(self._items)
+
+    def _check_locked(self, key, ignore_locked=False) -> bool:
+        locked = self._locked.get(key)
+        if locked is not None:
+            locked_user = self._users_inv[locked]
+            if not ignore_locked:
+                wandb.termwarn(
+                    f"Config item '{key}' was locked by '{locked_user}' (ignored update)."
+                )
+            return True
+        return False
+
+    def __setitem__(self, key, val):
+        if self._check_locked(key):
+            return
+        with wandb.sdk.lib.telemetry.context() as tel:
+            tel.feature.set_config_item = True
+        self._raise_value_error_on_nested_artifact(val, nested=True)
+        key, val = self._sanitize(key, val)
+        self._items[key] = val
+        logger.info("config set %s = %s - %s", key, val, self._callback)
+        if self._callback:
+            self._callback(key=key, val=val)
+
+    def items(self):
+        return [(k, v) for k, v in self._items.items() if not k.startswith("_")]
+
+    __setattr__ = __setitem__
+
+    def __getattr__(self, key):
+        try:
+            return self.__getitem__(key)
+        except KeyError as ke:
+            raise AttributeError(
+                f"{self.__class__!r} object has no attribute {key!r}"
+            ) from ke
+
+    def __contains__(self, key):
+        return key in self._items
+
+    def _update(self, d, allow_val_change=None, ignore_locked=None):
+        parsed_dict = wandb_helper.parse_config(d)
+        locked_keys = set()
+        for key in list(parsed_dict):
+            if self._check_locked(key, ignore_locked=ignore_locked):
+                locked_keys.add(key)
+        sanitized = self._sanitize_dict(
+            parsed_dict, allow_val_change, ignore_keys=locked_keys
+        )
+        self._items.update(sanitized)
+        return sanitized
+
+    def update(self, d, allow_val_change=None):
+        sanitized = self._update(d, allow_val_change)
+        if self._callback:
+            self._callback(data=sanitized)
+
+    def get(self, *args):
+        return self._items.get(*args)
+
+    def persist(self):
+        """Call the callback if it's set."""
+        if self._callback:
+            self._callback(data=self._as_dict())
+
+    def setdefaults(self, d):
+        d = wandb_helper.parse_config(d)
+        # strip out keys already configured
+        d = {k: v for k, v in d.items() if k not in self._items}
+        d = self._sanitize_dict(d)
+        self._items.update(d)
+        if self._callback:
+            self._callback(data=d)
+
+    def _get_user_id(self, user) -> int:
+        if user not in self._users:
+            self._users[user] = self._users_cnt
+            self._users_inv[self._users_cnt] = user
+            object.__setattr__(self, "_users_cnt", self._users_cnt + 1)
+
+        return self._users[user]
+
+    def update_locked(self, d, user=None, _allow_val_change=None):
+        """Shallow-update config with `d` and lock config updates on d's keys."""
+        num = self._get_user_id(user)
+
+        for k, v in d.items():
+            k, v = self._sanitize(k, v, allow_val_change=_allow_val_change)
+            self._locked[k] = num
+            self._items[k] = v
+
+        if self._callback:
+            self._callback(data=d)
+
+    def merge_locked(self, d, user=None, _allow_val_change=None):
+        """Recursively merge-update config with `d` and lock config updates on d's keys."""
+        num = self._get_user_id(user)
+        callback_d = {}
+
+        for k, v in d.items():
+            k, v = self._sanitize(k, v, allow_val_change=_allow_val_change)
+            self._locked[k] = num
+
+            if (
+                k in self._items
+                and isinstance(self._items[k], dict)
+                and isinstance(v, dict)
+            ):
+                self._items[k] = config_util.merge_dicts(self._items[k], v)
+            else:
+                self._items[k] = v
+
+            callback_d[k] = self._items[k]
+
+        if self._callback:
+            self._callback(data=callback_d)
+
+    def _load_defaults(self):
+        conf_dict = config_util.dict_from_config_file("config-defaults.yaml")
+        if conf_dict is not None:
+            self.update(conf_dict)
+
+    def _sanitize_dict(
+        self,
+        config_dict,
+        allow_val_change=None,
+        ignore_keys: Optional[set] = None,
+    ):
+        sanitized = {}
+        self._raise_value_error_on_nested_artifact(config_dict)
+        for k, v in config_dict.items():
+            if ignore_keys and k in ignore_keys:
+                continue
+            k, v = self._sanitize(k, v, allow_val_change)
+            sanitized[k] = v
+        return sanitized
+
+    def _sanitize(self, key, val, allow_val_change=None):
+        # TODO: enable WBValues in the config in the future
+        # refuse all WBValues which is all Media and Histograms
+        if isinstance(val, wandb.sdk.data_types.base_types.wb_value.WBValue):
+            raise ValueError("WBValue objects cannot be added to the run config")
+        # Let jupyter change config freely by default
+        if self._settings and self._settings._jupyter and allow_val_change is None:
+            allow_val_change = True
+        # We always normalize keys by stripping '-'
+        key = key.strip("-")
+        if _is_artifact_representation(val):
+            val = self._artifact_callback(key, val)
+        # if the user inserts an artifact into the config
+        if not isinstance(val, wandb.Artifact):
+            val = json_friendly_val(val)
+        if not allow_val_change:
+            if key in self._items and val != self._items[key]:
+                raise config_util.ConfigError(
+                    f'Attempted to change value of key "{key}" '
+                    f"from {self._items[key]} to {val}\n"
+                    "If you really want to do this, pass"
+                    " allow_val_change=True to config.update()"
+                )
+        return key, val
+
+    def _raise_value_error_on_nested_artifact(self, v, nested=False):
+        # we can't swap nested artifacts because their root key can be locked by other values
+        # best if we don't allow nested artifacts until we can lock nested keys in the config
+        if isinstance(v, dict) and check_dict_contains_nested_artifact(v, nested):
+            raise ValueError(
+                "Instances of wandb.Artifact can only be top level keys in wandb.config"
+            )
+
+
+class ConfigStatic:
+    def __init__(self, config):
+        object.__setattr__(self, "__dict__", dict(config))
+
+    def __setattr__(self, name, value):
+        raise AttributeError("Error: wandb.run.config_static is a readonly object")
+
+    def __setitem__(self, key, val):
+        raise AttributeError("Error: wandb.run.config_static is a readonly object")
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def __getitem__(self, key):
+        return self.__dict__[key]
+
+    def __str__(self):
+        return str(self.__dict__)

infer_4_33_0/lib/python3.10/site-packages/wandb/sdk/wandb_init.py

@@ -0,0 +1,1304 @@
+"""Defines wandb.init() and associated classes and methods.
+
+`wandb.init()` indicates the beginning of a new run. In an ML training pipeline,
+you could add `wandb.init()` to the beginning of your training script as well as
+your evaluation script, and each step would be tracked as a run in W&B.
+
+For more on using `wandb.init()`, including code snippets, check out our
+[guide and FAQs](https://docs.wandb.ai/guides/track/launch).
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import logging
+import os
+import platform
+import sys
+import tempfile
+import time
+from typing import TYPE_CHECKING, Any, Literal, Sequence
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+import wandb
+import wandb.env
+from wandb import trigger
+from wandb.errors import CommError, Error, UsageError
+from wandb.errors.links import url_registry
+from wandb.errors.util import ProtobufErrorHandler
+from wandb.integration import sagemaker
+from wandb.sdk.lib import runid
+from wandb.sdk.lib.paths import StrPath
+from wandb.util import _is_artifact_representation
+
+from . import wandb_login, wandb_setup
+from .backend.backend import Backend
+from .lib import SummaryDisabled, filesystem, module, printer, telemetry
+from .lib.deprecate import Deprecated, deprecate
+from .lib.mailbox import Mailbox, MailboxProgress
+from .wandb_helper import parse_config
+from .wandb_run import Run, TeardownHook, TeardownStage
+from .wandb_settings import Settings
+
+if TYPE_CHECKING:
+    from wandb.proto import wandb_internal_pb2 as pb
+
+logger: wandb_setup.Logger | None = None  # logger configured during wandb.init()
+
+
+def _set_logger(log_object: wandb_setup.Logger | None) -> None:
+    """Configure module logger."""
+    global logger
+    logger = log_object
+
+
+def _huggingface_version() -> str | None:
+    if "transformers" in sys.modules:
+        trans = wandb.util.get_module("transformers")
+        if hasattr(trans, "__version__"):
+            return str(trans.__version__)
+    return None
+
+
+def _maybe_mp_process(backend: Backend) -> bool:
+    parent_process = getattr(
+        backend._multiprocessing, "parent_process", None
+    )  # New in version 3.8.
+    if parent_process:
+        return parent_process() is not None
+    process = backend._multiprocessing.current_process()
+    if process.name == "MainProcess":
+        return False
+    if process.name.startswith("Process-"):
+        return True
+    return False
+
+
+def _handle_launch_config(settings: Settings) -> dict[str, Any]:
+    launch_run_config: dict[str, Any] = {}
+    if not settings.launch:
+        return launch_run_config
+    if os.environ.get("WANDB_CONFIG") is not None:
+        try:
+            launch_run_config = json.loads(os.environ.get("WANDB_CONFIG", "{}"))
+        except (ValueError, SyntaxError):
+            wandb.termwarn("Malformed WANDB_CONFIG, using original config")
+    elif settings.launch_config_path and os.path.exists(settings.launch_config_path):
+        with open(settings.launch_config_path) as fp:
+            launch_config = json.loads(fp.read())
+        launch_run_config = launch_config.get("overrides", {}).get("run_config")
+    else:
+        i = 0
+        chunks = []
+        while True:
+            key = f"WANDB_CONFIG_{i}"
+            if key in os.environ:
+                chunks.append(os.environ[key])
+                i += 1
+            else:
+                break
+        if len(chunks) > 0:
+            config_string = "".join(chunks)
+            try:
+                launch_run_config = json.loads(config_string)
+            except (ValueError, SyntaxError):
+                wandb.termwarn("Malformed WANDB_CONFIG, using original config")
+
+    return launch_run_config
+
+
+class _WandbInit:
+    _init_telemetry_obj: telemetry.TelemetryRecord
+
+    def __init__(self) -> None:
+        self.kwargs = None
+        self.settings: Settings | None = None
+        self.sweep_config: dict[str, Any] = {}
+        self.launch_config: dict[str, Any] = {}
+        self.config: dict[str, Any] = {}
+        self.run: Run | None = None
+        self.backend: Backend | None = None
+
+        self._teardown_hooks: list[TeardownHook] = []
+        self._wl = wandb.setup()
+        self.notebook: wandb.jupyter.Notebook | None = None  # type: ignore
+        self.printer = printer.new_printer()
+
+        self._init_telemetry_obj = telemetry.TelemetryRecord()
+
+        self.deprecated_features_used: dict[str, str] = dict()
+
+    def warn_env_vars_change_after_setup(self) -> None:
+        """Warn if environment variables change after wandb singleton is initialized.
+
+        Any settings from environment variables set after the singleton is initialized
+        (via login/setup/etc.) will be ignored.
+        """
+        singleton = wandb_setup.singleton()
+        if singleton is None:
+            return
+
+        exclude_env_vars = {"WANDB_SERVICE", "WANDB_KUBEFLOW_URL"}
+        # check if environment variables have changed
+        singleton_env = {
+            k: v
+            for k, v in singleton._environ.items()
+            if k.startswith("WANDB_") and k not in exclude_env_vars
+        }
+        os_env = {
+            k: v
+            for k, v in os.environ.items()
+            if k.startswith("WANDB_") and k not in exclude_env_vars
+        }
+        if set(singleton_env.keys()) != set(os_env.keys()) or set(
+            singleton_env.values()
+        ) != set(os_env.values()):
+            line = (
+                "Changes to your `wandb` environment variables will be ignored "
+                "because your `wandb` session has already started. "
+                "For more information on how to modify your settings with "
+                "`wandb.init()` arguments, please refer to "
+                f"{self.printer.link(url_registry.url('wandb-init'), 'the W&B docs')}."
+            )
+            self.printer.display(line, level="warn")
+
+    def clear_run_path_if_sweep_or_launch(
+        self,
+        init_settings: Settings,
+    ) -> None:
+        """Clear project/entity/run_id keys if in a Sweep or a Launch context.
+
+        Args:
+            init_settings: Settings specified in the call to `wandb.init()`.
+        """
+        when_doing_thing = ""
+
+        if self._wl.settings.sweep_id:
+            when_doing_thing = "when running a sweep"
+        elif self._wl.settings.launch:
+            when_doing_thing = "when running from a wandb launch context"
+
+        if not when_doing_thing:
+            return
+
+        def warn(key: str, value: str) -> None:
+            self.printer.display(
+                f"Ignoring {key} {value!r} {when_doing_thing}.",
+                level="warn",
+            )
+
+        if init_settings.project is not None:
+            warn("project", init_settings.project)
+            init_settings.project = None
+        if init_settings.entity is not None:
+            warn("entity", init_settings.entity)
+            init_settings.entity = None
+        if init_settings.run_id is not None:
+            warn("run_id", init_settings.run_id)
+            init_settings.run_id = None
+
+    def setup(  # noqa: C901
+        self,
+        init_settings: Settings,
+        config: dict | str | None = None,
+        config_exclude_keys: list[str] | None = None,
+        config_include_keys: list[str] | None = None,
+        allow_val_change: bool | None = None,
+        monitor_gym: bool | None = None,
+    ) -> None:
+        """Complete setup for `wandb.init()`.
+
+        This includes parsing all arguments, applying them with settings and enabling logging.
+        """
+        self.warn_env_vars_change_after_setup()
+
+        _set_logger(self._wl._get_logger())
+        assert logger
+
+        self.clear_run_path_if_sweep_or_launch(init_settings)
+
+        # Inherit global settings.
+        settings = self._wl.settings.model_copy()
+
+        # Apply settings from wandb.init() call.
+        settings.update_from_settings(init_settings)
+
+        # Infer the run ID from SageMaker.
+        if not settings.sagemaker_disable and sagemaker.is_using_sagemaker():
+            if sagemaker.set_run_id(settings):
+                logger.info("set run ID and group based on SageMaker")
+                with telemetry.context(obj=self._init_telemetry_obj) as tel:
+                    tel.feature.sagemaker = True
+
+        with telemetry.context(obj=self._init_telemetry_obj) as tel:
+            if config is not None:
+                tel.feature.set_init_config = True
+            if settings.run_name is not None:
+                tel.feature.set_init_name = True
+            if settings.run_id is not None:
+                tel.feature.set_init_id = True
+            if settings.run_tags is not None:
+                tel.feature.set_init_tags = True
+
+        # TODO: remove this once officially deprecated
+        if config_exclude_keys:
+            self.deprecated_features_used["config_exclude_keys"] = (
+                "Use `config=wandb.helper.parse_config(config_object, exclude=('key',))` instead."
+            )
+        if config_include_keys:
+            self.deprecated_features_used["config_include_keys"] = (
+                "Use `config=wandb.helper.parse_config(config_object, include=('key',))` instead."
+            )
+        config = parse_config(
+            config or dict(),
+            include=config_include_keys,
+            exclude=config_exclude_keys,
+        )
+
+        # Construct the run's config.
+        self.config = dict()
+        self.init_artifact_config: dict[str, Any] = dict()
+
+        if not settings.sagemaker_disable and sagemaker.is_using_sagemaker():
+            sagemaker_config = sagemaker.parse_sm_config()
+            self._split_artifacts_from_config(sagemaker_config, self.config)
+
+            with telemetry.context(obj=self._init_telemetry_obj) as tel:
+                tel.feature.sagemaker = True
+
+        if self._wl._config:
+            self._split_artifacts_from_config(self._wl._config, self.config)
+
+        if config and isinstance(config, dict):
+            self._split_artifacts_from_config(config, self.config)
+
+        self.sweep_config = dict()
+        sweep_config = self._wl._sweep_config or dict()
+        if sweep_config:
+            self._split_artifacts_from_config(sweep_config, self.sweep_config)
+
+        if monitor_gym and len(wandb.patched["gym"]) == 0:
+            wandb.gym.monitor()  # type: ignore
+
+        if wandb.patched["tensorboard"]:
+            with telemetry.context(obj=self._init_telemetry_obj) as tel:
+                tel.feature.tensorboard_patch = True
+
+        if settings.sync_tensorboard:
+            if len(wandb.patched["tensorboard"]) == 0:
+                wandb.tensorboard.patch()  # type: ignore
+            with telemetry.context(obj=self._init_telemetry_obj) as tel:
+                tel.feature.tensorboard_sync = True
+
+        if not settings._offline and not settings._noop:
+            wandb_login._login(
+                anonymous=settings.anonymous,
+                force=settings.force,
+                _disable_warning=True,
+                _silent=settings.quiet or settings.silent,
+                _entity=settings.entity,
+            )
+
+        # apply updated global state after login was handled
+        login_settings = {
+            k: v
+            for k, v in {
+                "anonymous": self._wl.settings.anonymous,
+                "api_key": self._wl.settings.api_key,
+                "base_url": self._wl.settings.base_url,
+                "force": self._wl.settings.force,
+                "login_timeout": self._wl.settings.login_timeout,
+            }.items()
+            if v is not None
+        }
+        if login_settings:
+            settings.update_from_dict(login_settings)
+
+        # handle custom resume logic
+        settings.handle_resume_logic()
+
+        # get status of code saving before applying user settings
+        save_code_pre_user_settings = settings.save_code
+        if not settings._offline and not settings._noop:
+            user_settings = self._wl._load_user_settings()
+            if user_settings is not None:
+                settings.update_from_dict(user_settings)
+
+        # ensure that user settings don't set saving to true
+        # if user explicitly set these to false in UI
+        if save_code_pre_user_settings is False:
+            settings.save_code = False
+
+        # TODO: remove this once we refactor the client. This is a temporary
+        # fix to make sure that we use the same project name for wandb-core.
+        # The reason this is not going through the settings object is to
+        # avoid failure cases in other parts of the code that will be
+        # removed with the switch to wandb-core.
+        if settings.project is None:
+            settings.project = wandb.util.auto_project_name(settings.program)
+
+        settings.x_start_time = time.time()
+
+        if not settings._noop:
+            self._log_setup(settings)
+
+            if settings._jupyter:
+                self._jupyter_setup(settings)
+        launch_config = _handle_launch_config(settings)
+        if launch_config:
+            self._split_artifacts_from_config(launch_config, self.launch_config)
+
+        self.settings = settings
+
+    def teardown(self) -> None:
+        # TODO: currently this is only called on failed wandb.init attempts
+        # normally this happens on the run object
+        assert logger
+        logger.info("tearing down wandb.init")
+        for hook in self._teardown_hooks:
+            hook.call()
+
+    def _split_artifacts_from_config(
+        self, config_source: dict, config_target: dict
+    ) -> None:
+        for k, v in config_source.items():
+            if _is_artifact_representation(v):
+                self.init_artifact_config[k] = v
+            else:
+                config_target.setdefault(k, v)
+
+    def _enable_logging(self, log_fname: str) -> None:
+        """Enable logging to the global debug log.
+
+        This adds a run_id to the log, in case of multiple processes on the same machine.
+        Currently, there is no way to disable logging after it's enabled.
+        """
+        handler = logging.FileHandler(log_fname)
+        handler.setLevel(logging.INFO)
+
+        formatter = logging.Formatter(
+            "%(asctime)s %(levelname)-7s %(threadName)-10s:%(process)d "
+            "[%(filename)s:%(funcName)s():%(lineno)s] %(message)s"
+        )
+
+        handler.setFormatter(formatter)
+        assert isinstance(logger, logging.Logger)
+        logger.propagate = False
+        logger.addHandler(handler)
+        # TODO: make me configurable
+        logger.setLevel(logging.DEBUG)
+        self._teardown_hooks.append(
+            TeardownHook(
+                lambda: (handler.close(), logger.removeHandler(handler)),  # type: ignore
+                TeardownStage.LATE,
+            )
+        )
+
+    def _safe_symlink(
+        self, base: str, target: str, name: str, delete: bool = False
+    ) -> None:
+        # TODO(jhr): do this with relpaths, but i can't figure it out on no sleep
+        if not hasattr(os, "symlink"):
+            return
+
+        pid = os.getpid()
+        tmp_name = os.path.join(base, f"{name}.{pid}")
+
+        if delete:
+            try:
+                os.remove(os.path.join(base, name))
+            except OSError:
+                pass
+        target = os.path.relpath(target, base)
+        try:
+            os.symlink(target, tmp_name)
+            os.rename(tmp_name, os.path.join(base, name))
+        except OSError:
+            pass
+
+    def _pause_backend(self, *args: Any, **kwargs: Any) -> None:  #  noqa
+        if self.backend is None:
+            return None
+
+        # Attempt to save the code on every execution
+        if self.notebook.save_ipynb():  # type: ignore
+            assert self.run is not None
+            res = self.run.log_code(root=None)
+            logger.info("saved code: %s", res)  # type: ignore
+        if self.backend.interface is not None:
+            logger.info("pausing backend")  # type: ignore
+            self.backend.interface.publish_pause()
+
+    def _resume_backend(self, *args: Any, **kwargs: Any) -> None:  #  noqa
+        if self.backend is not None and self.backend.interface is not None:
+            logger.info("resuming backend")  # type: ignore
+            self.backend.interface.publish_resume()
+
+    def _jupyter_teardown(self) -> None:
+        """Teardown hooks and display saving, called with wandb.finish."""
+        assert self.notebook
+        ipython = self.notebook.shell
+        self.notebook.save_history()
+        if self.notebook.save_ipynb():
+            assert self.run is not None
+            res = self.run.log_code(root=None)
+            logger.info("saved code and history: %s", res)  # type: ignore
+        logger.info("cleaning up jupyter logic")  # type: ignore
+        # because of how we bind our methods we manually find them to unregister
+        for hook in ipython.events.callbacks["pre_run_cell"]:
+            if "_resume_backend" in hook.__name__:
+                ipython.events.unregister("pre_run_cell", hook)
+        for hook in ipython.events.callbacks["post_run_cell"]:
+            if "_pause_backend" in hook.__name__:
+                ipython.events.unregister("post_run_cell", hook)
+        ipython.display_pub.publish = ipython.display_pub._orig_publish
+        del ipython.display_pub._orig_publish
+
+    def _jupyter_setup(self, settings: Settings) -> None:
+        """Add hooks, and session history saving."""
+        self.notebook = wandb.jupyter.Notebook(settings)  # type: ignore
+        ipython = self.notebook.shell
+
+        # Monkey patch ipython publish to capture displayed outputs
+        if not hasattr(ipython.display_pub, "_orig_publish"):
+            logger.info("configuring jupyter hooks %s", self)  # type: ignore
+            ipython.display_pub._orig_publish = ipython.display_pub.publish
+            # Registering resume and pause hooks
+
+            ipython.events.register("pre_run_cell", self._resume_backend)
+            ipython.events.register("post_run_cell", self._pause_backend)
+            self._teardown_hooks.append(
+                TeardownHook(self._jupyter_teardown, TeardownStage.EARLY)
+            )
+
+        def publish(data, metadata=None, **kwargs) -> None:  # type: ignore
+            ipython.display_pub._orig_publish(data, metadata=metadata, **kwargs)
+            assert self.notebook is not None
+            self.notebook.save_display(
+                ipython.execution_count, {"data": data, "metadata": metadata}
+            )
+
+        ipython.display_pub.publish = publish
+
+    def _log_setup(self, settings: Settings) -> None:
+        """Set up logging from settings."""
+        filesystem.mkdir_exists_ok(os.path.dirname(settings.log_user))
+        filesystem.mkdir_exists_ok(os.path.dirname(settings.log_internal))
+        filesystem.mkdir_exists_ok(os.path.dirname(settings.sync_file))
+        filesystem.mkdir_exists_ok(settings.files_dir)
+        filesystem.mkdir_exists_ok(settings._tmp_code_dir)
+
+        if settings.symlink:
+            self._safe_symlink(
+                os.path.dirname(settings.sync_symlink_latest),
+                os.path.dirname(settings.sync_file),
+                os.path.basename(settings.sync_symlink_latest),
+                delete=True,
+            )
+            self._safe_symlink(
+                os.path.dirname(settings.log_symlink_user),
+                settings.log_user,
+                os.path.basename(settings.log_symlink_user),
+                delete=True,
+            )
+            self._safe_symlink(
+                os.path.dirname(settings.log_symlink_internal),
+                settings.log_internal,
+                os.path.basename(settings.log_symlink_internal),
+                delete=True,
+            )
+
+        _set_logger(logging.getLogger("wandb"))
+        self._enable_logging(settings.log_user)
+
+        assert self._wl
+        assert logger
+
+        self._wl._early_logger_flush(logger)
+        logger.info(f"Logging user logs to {settings.log_user}")
+        logger.info(f"Logging internal logs to {settings.log_internal}")
+
+    def _make_run_disabled(self) -> Run:
+        """Returns a Run-like object where all methods are no-ops.
+
+        This method is used when wandb.init(mode="disabled") is called or WANDB_MODE=disabled
+        is set. It creates a Run object that mimics the behavior of a normal Run but doesn't
+        communicate with the W&B servers.
+
+        The returned Run object has all expected attributes and methods, but they are
+        no-op versions that don't perform any actual logging or communication.
+        """
+        run_id = runid.generate_id()
+        drun = Run(
+            settings=Settings(
+                mode="disabled",
+                x_files_dir=tempfile.gettempdir(),
+                run_id=run_id,
+                run_tags=tuple(),
+                run_notes=None,
+                run_group=None,
+                run_name=f"dummy-{run_id}",
+                project="dummy",
+                entity="dummy",
+            )
+        )
+        # config, summary, and metadata objects
+        drun._config = wandb.sdk.wandb_config.Config()
+        drun._config.update(self.sweep_config)
+        drun._config.update(self.config)
+        drun.summary = SummaryDisabled()  # type: ignore
+        drun._Run__metadata = wandb.sdk.wandb_metadata.Metadata()
+
+        # methods
+        drun.log = lambda data, *_, **__: drun.summary.update(data)  # type: ignore
+        drun.finish = lambda *_, **__: module.unset_globals()  # type: ignore
+        drun.join = drun.finish  # type: ignore
+        drun.define_metric = lambda *_, **__: wandb.sdk.wandb_metric.Metric("dummy")  # type: ignore
+        drun.save = lambda *_, **__: False  # type: ignore
+        for symbol in (
+            "alert",
+            "finish_artifact",
+            "get_project_url",
+            "get_sweep_url",
+            "get_url",
+            "link_artifact",
+            "link_model",
+            "use_artifact",
+            "log_code",
+            "log_model",
+            "use_model",
+            "mark_preempting",
+            "restore",
+            "status",
+            "watch",
+            "unwatch",
+            "upsert_artifact",
+            "_finish",
+        ):
+            setattr(drun, symbol, lambda *_, **__: None)  # type: ignore
+
+        class _ChainableNoOp:
+            """An object that allows chaining arbitrary attributes and method calls."""
+
+            def __getattr__(self, _: str) -> Self:
+                return self
+
+            def __call__(self, *_: Any, **__: Any) -> Self:
+                return self
+
+        class _ChainableNoOpField:
+            # This is used to chain arbitrary attributes and method calls.
+            # For example, `run.log_artifact().state` will work in disabled mode.
+            def __init__(self) -> None:
+                self._value = None
+
+            def __set__(self, instance: Any, value: Any) -> None:
+                self._value = value
+
+            def __get__(self, instance: Any, owner: type) -> Any:
+                return _ChainableNoOp() if (self._value is None) else self._value
+
+            def __call__(self, *args: Any, **kwargs: Any) -> _ChainableNoOp:
+                return _ChainableNoOp()
+
+        drun.log_artifact = _ChainableNoOpField()
+        # attributes
+        drun._start_time = time.time()
+        drun._starting_step = 0
+        drun._step = 0
+        drun._attach_id = None
+        drun._backend = None
+
+        # set the disabled run as the global run
+        module.set_global(
+            run=drun,
+            config=drun.config,
+            log=drun.log,
+            summary=drun.summary,
+            save=drun.save,
+            use_artifact=drun.use_artifact,
+            log_artifact=drun.log_artifact,
+            define_metric=drun.define_metric,
+            alert=drun.alert,
+            watch=drun.watch,
+            unwatch=drun.unwatch,
+        )
+        return drun
+
+    def _on_progress_init(self, handle: MailboxProgress) -> None:
+        line = "Waiting for wandb.init()...\r"
+        percent_done = handle.percent_done
+        self.printer.progress_update(line, percent_done=percent_done)
+
+    def init(self) -> Run:  # noqa: C901
+        if logger is None:
+            raise RuntimeError("Logger not initialized")
+        logger.info("calling init triggers")
+        trigger.call("on_init")
+
+        assert self.settings is not None
+        assert self._wl is not None
+
+        logger.info(
+            f"wandb.init called with sweep_config: {self.sweep_config}\nconfig: {self.config}"
+        )
+
+        if self.settings._noop:
+            return self._make_run_disabled()
+        if (
+            self.settings.reinit
+            or (self.settings._jupyter and self.settings.reinit is not False)
+        ) and len(self._wl._global_run_stack) > 0:
+            if len(self._wl._global_run_stack) > 1:
+                wandb.termwarn(
+                    "Launching multiple wandb runs using Python's threading"
+                    " module is not well-supported."
+                    " Please use multiprocessing instead."
+                    " Finishing previous run before initializing another."
+                )
+
+            latest_run = self._wl._global_run_stack[-1]
+            logger.info(f"found existing run on stack: {latest_run.id}")
+            latest_run.finish()
+        elif wandb.run is not None and os.getpid() == wandb.run._init_pid:
+            logger.info("wandb.init() called when a run is still active")
+            with telemetry.context() as tel:
+                tel.feature.init_return_run = True
+            return wandb.run
+
+        logger.info("starting backend")
+
+        if not self.settings.x_disable_service:
+            service = self._wl.ensure_service()
+            logger.info("sending inform_init request")
+            service.inform_init(
+                settings=self.settings.to_proto(),
+                run_id=self.settings.run_id,  # type: ignore
+            )
+        else:
+            service = None
+
+        mailbox = Mailbox()
+        backend = Backend(
+            settings=self.settings,
+            service=service,
+            mailbox=mailbox,
+        )
+        backend.ensure_launched()
+        logger.info("backend started and connected")
+
+        # resuming needs access to the server, check server_status()?
+        run = Run(
+            config=self.config,
+            settings=self.settings,
+            sweep_config=self.sweep_config,
+            launch_config=self.launch_config,
+        )
+
+        # Populate initial telemetry
+        with telemetry.context(run=run, obj=self._init_telemetry_obj) as tel:
+            tel.cli_version = wandb.__version__
+            tel.python_version = platform.python_version()
+            tel.platform = f"{platform.system()}-{platform.machine()}".lower()
+            hf_version = _huggingface_version()
+            if hf_version:
+                tel.huggingface_version = hf_version
+            if self.settings._jupyter:
+                tel.env.jupyter = True
+            if self.settings._ipython:
+                tel.env.ipython = True
+            if self.settings._colab:
+                tel.env.colab = True
+            if self.settings._kaggle:
+                tel.env.kaggle = True
+            if self.settings._windows:
+                tel.env.windows = True
+
+            if self.settings.launch:
+                tel.feature.launch = True
+
+            for module_name in telemetry.list_telemetry_imports(only_imported=True):
+                setattr(tel.imports_init, module_name, True)
+
+            # probe the active start method
+            active_start_method: str | None = None
+            if self.settings.start_method == "thread":
+                active_start_method = self.settings.start_method
+            else:
+                active_start_method = getattr(
+                    backend._multiprocessing, "get_start_method", lambda: None
+                )()
+
+            if active_start_method == "spawn":
+                tel.env.start_spawn = True
+            elif active_start_method == "fork":
+                tel.env.start_fork = True
+            elif active_start_method == "forkserver":
+                tel.env.start_forkserver = True
+            elif active_start_method == "thread":
+                tel.env.start_thread = True
+
+            if os.environ.get("PEX"):
+                tel.env.pex = True
+
+            if self.settings._aws_lambda:
+                tel.env.aws_lambda = True
+
+            if os.environ.get(wandb.env._DISABLE_SERVICE):
+                tel.feature.service_disabled = True
+
+            if service:
+                tel.feature.service = True
+            if self.settings.x_flow_control_disabled:
+                tel.feature.flow_control_disabled = True
+            if self.settings.x_flow_control_custom:
+                tel.feature.flow_control_custom = True
+            if not self.settings.x_require_legacy_service:
+                tel.feature.core = True
+            if self.settings._shared:
+                wandb.termwarn(
+                    "The `_shared` feature is experimental and may change. "
+                    "Please contact support@wandb.com for guidance and to report any issues."
+                )
+                tel.feature.shared_mode = True
+
+            tel.env.maybe_mp = _maybe_mp_process(backend)
+
+        if not self.settings.label_disable:
+            if self.notebook:
+                run._label_probe_notebook(self.notebook)
+            else:
+                run._label_probe_main()
+
+        for deprecated_feature, msg in self.deprecated_features_used.items():
+            warning_message = f"`{deprecated_feature}` is deprecated. {msg}"
+            deprecate(
+                field_name=getattr(Deprecated, "init__" + deprecated_feature),
+                warning_message=warning_message,
+                run=run,
+            )
+
+        logger.info("updated telemetry")
+
+        run._set_library(self._wl)
+        run._set_backend(backend)
+        run._set_teardown_hooks(self._teardown_hooks)
+
+        backend._hack_set_run(run)
+        assert backend.interface
+        mailbox.enable_keepalive()
+        backend.interface.publish_header()
+
+        # Using GitRepo() blocks & can be slow, depending on user's current git setup.
+        # We don't want to block run initialization/start request, so populate run's git
+        # info beforehand.
+        if not (self.settings.disable_git or self.settings.x_disable_machine_info):
+            run._populate_git_info()
+
+        run_result: pb.RunUpdateResult | None = None
+
+        if self.settings._offline:
+            with telemetry.context(run=run) as tel:
+                tel.feature.offline = True
+
+            if self.settings.resume:
+                wandb.termwarn(
+                    "`resume` will be ignored since W&B syncing is set to `offline`. "
+                    f"Starting a new run with run id {run.id}."
+                )
+        error: wandb.Error | None = None
+
+        timeout = self.settings.init_timeout
+
+        logger.info(f"communicating run to backend with {timeout} second timeout")
+
+        run_init_handle = backend.interface.deliver_run(run)
+        result = run_init_handle.wait(
+            timeout=timeout,
+            on_progress=self._on_progress_init,
+            cancel=True,
+        )
+        if result:
+            run_result = result.run_result
+
+        if run_result is None:
+            error_message = (
+                f"Run initialization has timed out after {timeout} sec. "
+                "Please try increasing the timeout with the `init_timeout` setting: "
+                "`wandb.init(settings=wandb.Settings(init_timeout=120))`."
+            )
+            # We're not certain whether the error we encountered is due to an issue
+            # with the server (a "CommError") or if it's a problem within the SDK (an "Error").
+            # This means that the error could be a result of the server being unresponsive,
+            # or it could be because we were unable to communicate with the wandb service.
+            error = CommError(error_message)
+            run_init_handle._cancel()
+        elif run_result.HasField("error"):
+            error = ProtobufErrorHandler.to_exception(run_result.error)
+
+        if error is not None:
+            logger.error(f"encountered error: {error}")
+            if not service:
+                # Shutdown the backend and get rid of the logger
+                # we don't need to do console cleanup at this point
+                backend.cleanup()
+                self.teardown()
+            raise error
+
+        assert run_result is not None  # for mypy
+
+        if not run_result.HasField("run"):
+            raise Error(
+                "It appears that something have gone wrong during the program "
+                "execution as an unexpected missing field was encountered. "
+                "(run_result is missing the 'run' field)"
+            )
+
+        if run_result.run.resumed:
+            logger.info("run resumed")
+            with telemetry.context(run=run) as tel:
+                tel.feature.resumed = run_result.run.resumed
+        run._set_run_obj(run_result.run)
+
+        logger.info("starting run threads in backend")
+        # initiate run (stats and metadata probing)
+
+        if service:
+            assert self.settings.run_id
+            service.inform_start(
+                settings=self.settings.to_proto(),
+                run_id=self.settings.run_id,
+            )
+
+        assert backend.interface
+
+        run_start_handle = backend.interface.deliver_run_start(run)
+        # TODO: add progress to let user know we are doing something
+        run_start_result = run_start_handle.wait(timeout=30)
+        if run_start_result is None:
+            run_start_handle.abandon()
+
+        assert self._wl is not None
+        self._wl._global_run_stack.append(run)
+        self.run = run
+
+        run._handle_launch_artifact_overrides()
+        if (
+            self.settings.launch
+            and self.settings.launch_config_path
+            and os.path.exists(self.settings.launch_config_path)
+        ):
+            run.save(self.settings.launch_config_path)
+        # put artifacts in run config here
+        # since doing so earlier will cause an error
+        # as the run is not upserted
+        for k, v in self.init_artifact_config.items():
+            run.config.update({k: v}, allow_val_change=True)
+        job_artifact = run._launch_artifact_mapping.get(
+            wandb.util.LAUNCH_JOB_ARTIFACT_SLOT_NAME
+        )
+        if job_artifact:
+            run.use_artifact(job_artifact)
+
+        self.backend = backend
+        run._on_start()
+        logger.info("run started, returning control to user process")
+        return run
+
+
+def _attach(
+    attach_id: str | None = None,
+    run_id: str | None = None,
+    *,
+    run: Run | None = None,
+) -> Run | None:
+    """Attach to a run currently executing in another process/thread.
+
+    Args:
+        attach_id: (str, optional) The id of the run or an attach identifier
+            that maps to a run.
+        run_id: (str, optional) The id of the run to attach to.
+        run: (Run, optional) The run instance to attach
+    """
+    attach_id = attach_id or run_id
+    if not ((attach_id is None) ^ (run is None)):
+        raise UsageError("Either (`attach_id` or `run_id`) or `run` must be specified")
+
+    attach_id = attach_id or (run._attach_id if run else None)
+
+    if attach_id is None:
+        raise UsageError(
+            "Either `attach_id` or `run_id` must be specified or `run` must have `_attach_id`"
+        )
+    wandb._assert_is_user_process()  # type: ignore
+
+    _wl = wandb.setup()
+
+    _set_logger(_wl._get_logger())
+    if logger is None:
+        raise UsageError("logger is not initialized")
+
+    service = _wl.ensure_service()
+
+    try:
+        attach_settings = service.inform_attach(attach_id=attach_id)
+    except Exception as e:
+        raise UsageError(f"Unable to attach to run {attach_id}") from e
+
+    settings: Settings = copy.copy(_wl._settings)
+
+    settings.update_from_dict(
+        {
+            "run_id": attach_id,
+            "x_start_time": attach_settings.x_start_time.value,
+            "mode": attach_settings.mode.value,
+        }
+    )
+
+    # TODO: consolidate this codepath with wandb.init()
+    mailbox = Mailbox()
+    backend = Backend(settings=settings, service=service, mailbox=mailbox)
+    backend.ensure_launched()
+    logger.info("attach backend started and connected")
+
+    if run is None:
+        run = Run(settings=settings)
+    else:
+        run._init(settings=settings)
+    run._set_library(_wl)
+    run._set_backend(backend)
+    backend._hack_set_run(run)
+    assert backend.interface
+
+    mailbox.enable_keepalive()
+
+    attach_handle = backend.interface.deliver_attach(attach_id)
+    # TODO: add progress to let user know we are doing something
+    attach_result = attach_handle.wait(timeout=30)
+    if not attach_result:
+        attach_handle.abandon()
+        raise UsageError("Timeout attaching to run")
+    attach_response = attach_result.response.attach_response
+    if attach_response.error and attach_response.error.message:
+        raise UsageError(f"Failed to attach to run: {attach_response.error.message}")
+
+    run._set_run_obj(attach_response.run)
+    run._on_attach()
+    return run
+
+
+def init(  # noqa: C901
+    entity: str | None = None,
+    project: str | None = None,
+    dir: StrPath | None = None,
+    id: str | None = None,
+    name: str | None = None,
+    notes: str | None = None,
+    tags: Sequence[str] | None = None,
+    config: dict[str, Any] | str | None = None,
+    config_exclude_keys: list[str] | None = None,
+    config_include_keys: list[str] | None = None,
+    allow_val_change: bool | None = None,
+    group: str | None = None,
+    job_type: str | None = None,
+    mode: Literal["online", "offline", "disabled"] | None = None,
+    force: bool | None = None,
+    anonymous: Literal["never", "allow", "must"] | None = None,
+    reinit: bool | None = None,
+    resume: bool | Literal["allow", "never", "must", "auto"] | None = None,
+    resume_from: str | None = None,
+    fork_from: str | None = None,
+    save_code: bool | None = None,
+    tensorboard: bool | None = None,
+    sync_tensorboard: bool | None = None,
+    monitor_gym: bool | None = None,
+    settings: Settings | dict[str, Any] | None = None,
+) -> Run:
+    r"""Start a new run to track and log to W&B.
+
+    In an ML training pipeline, you could add `wandb.init()` to the beginning of
+    your training script as well as your evaluation script, and each piece would
+    be tracked as a run in W&B.
+
+    `wandb.init()` spawns a new background process to log data to a run, and it
+    also syncs data to https://wandb.ai by default, so you can see your results
+    in real-time.
+
+    Call `wandb.init()` to start a run before logging data with `wandb.log()`.
+    When you're done logging data, call `wandb.finish()` to end the run. If you
+    don't call `wandb.finish()`, the run will end when your script exits.
+
+    For more on using `wandb.init()`, including detailed examples, check out our
+    [guide and FAQs](https://docs.wandb.ai/guides/track/launch).
+
+    Examples:
+        ### Explicitly set the entity and project and choose a name for the run:
+
+        ```python
+        import wandb
+
+        run = wandb.init(
+            entity="geoff",
+            project="capsules",
+            name="experiment-2021-10-31",
+        )
+
+        # ... your training code here ...
+
+        run.finish()
+        ```
+
+        ### Add metadata about the run using the `config` argument:
+
+        ```python
+        import wandb
+
+        config = {"lr": 0.01, "batch_size": 32}
+        with wandb.init(config=config) as run:
+            run.config.update({"architecture": "resnet", "depth": 34})
+
+            # ... your training code here ...
+        ```
+
+        Note that you can use `wandb.init()` as a context manager to automatically
+        call `wandb.finish()` at the end of the block.
+
+    Args:
+        entity: The username or team name under which the runs will be logged.
+            The entity must already exist, so ensure you’ve created your account
+            or team in the UI before starting to log runs. If not specified, the
+            run will default your default entity. To change the default entity,
+            go to [your settings](https://wandb.ai/settings) and update the
+            "Default location to create new projects" under "Default team".
+        project: The name of the project under which this run will be logged.
+            If not specified, we use a heuristic to infer the project name based
+            on the system, such as checking the git root or the current program
+            file. If we can't infer the project name, the project will default to
+            `"uncategorized"`.
+        dir: An absolute path to the directory where metadata and downloaded
+            files will be stored. When calling `download()` on an artifact, files
+            will be saved to this directory. If not specified, this defaults to
+            the `./wandb` directory.
+        id: A unique identifier for this run, used for resuming. It must be unique
+            within the project and cannot be reused once a run is deleted. The
+            identifier must not contain any of the following special characters:
+            `/ \ # ? % :`. For a short descriptive name, use the `name` field,
+            or for saving hyperparameters to compare across runs, use `config`.
+        name: A short display name for this run, which appears in the UI to help
+            you identify it. By default, we generate a random two-word name
+            allowing easy cross-reference runs from table to charts. Keeping these
+            run names brief enhances readability in chart legends and tables. For
+            saving hyperparameters, we recommend using the `config` field.
+        notes: A detailed description of the run, similar to a commit message in
+            Git. Use this argument to capture any context or details that may
+            help you recall the purpose or setup of this run in the future.
+        tags: A list of tags to label this run in the UI. Tags are helpful for
+            organizing runs or adding temporary identifiers like "baseline" or
+            "production." You can easily add, remove tags, or filter by tags in
+            the UI.
+            If resuming a run, the tags provided here will replace any existing
+            tags. To add tags to a resumed run without overwriting the current
+            tags, use `run.tags += ["new_tag"]` after calling `run = wandb.init()`.
+        config: Sets `wandb.config`, a dictionary-like object for storing input
+            parameters to your run, such as model hyperparameters or data
+            preprocessing settings.
+            The config appears in the UI in an overview page, allowing you to
+            group, filter, and sort runs based on these parameters.
+            Keys should not contain periods (`.`), and values should be
+            smaller than 10 MB.
+            If a dictionary, `argparse.Namespace`, or `absl.flags.FLAGS` is
+            provided, the key-value pairs will be loaded directly into
+            `wandb.config`.
+            If a string is provided, it is interpreted as a path to a YAML file,
+            from which configuration values will be loaded into `wandb.config`.
+        config_exclude_keys: A list of specific keys to exclude from `wandb.config`.
+        config_include_keys: A list of specific keys to include in `wandb.config`.
+        allow_val_change: Controls whether config values can be modified after their
+            initial set. By default, an exception is raised if a config value is
+            overwritten. For tracking variables that change during training, such as
+            a learning rate, consider using `wandb.log()` instead. By default, this
+            is `False` in scripts and `True` in Notebook environments.
+        group: Specify a group name to organize individual runs as part of a larger
+            experiment. This is useful for cases like cross-validation or running
+            multiple jobs that train and evaluate a model on different test sets.
+            Grouping allows you to manage related runs collectively in the UI,
+            making it easy to toggle and review results as a unified experiment.
+            For more information, refer to our
+            [guide to grouping runs](https://docs.wandb.com/guides/runs/grouping).
+        job_type: Specify the type of run, especially helpful when organizing runs
+            within a group as part of a larger experiment. For example, in a group,
+            you might label runs with job types such as "train" and "eval".
+            Defining job types enables you to easily filter and group similar runs
+            in the UI, facilitating direct comparisons.
+        mode: Specifies how run data is managed, with the following options:
+            - `"online"` (default): Enables live syncing with W&B when a network
+                connection is available, with real-time updates to visualizations.
+            - `"offline"`: Suitable for air-gapped or offline environments; data
+                is saved locally and can be synced later. Ensure the run folder
+                is preserved to enable future syncing.
+            - `"disabled"`: Disables all W&B functionality, making the run’s methods
+                no-ops. Typically used in testing to bypass W&B operations.
+        force: Determines if a W&B login is required to run the script. If `True`,
+            the user must be logged in to W&B; otherwise, the script will not
+            proceed. If `False` (default), the script can proceed without a login,
+            switching to offline mode if the user is not logged in.
+        anonymous: Specifies the level of control over anonymous data logging.
+            Available options are:
+            - `"never"` (default): Requires you to link your W&B account before
+                tracking the run. This prevents unintentional creation of anonymous
+                runs by ensuring each run is associated with an account.
+            - `"allow"`: Enables a logged-in user to track runs with their account,
+                but also allows someone running the script without a W&B account
+                to view the charts and data in the UI.
+            - `"must"`: Forces the run to be logged to an anonymous account, even
+                if the user is logged in.
+        reinit: Determines if multiple `wandb.init()` calls can start new runs
+            within the same process. By default (`False`), if an active run
+            exists, calling `wandb.init()` returns the existing run instead of
+            creating a new one. When `reinit=True`, the active run is finished
+            before a new run is initialized. In notebook environments, runs are
+            reinitialized by default unless `reinit` is explicitly set to `False`.
+        resume: Controls the behavior when resuming a run with the specified `id`.
+            Available options are:
+            - `"allow"`: If a run with the specified `id` exists, it will resume
+                from the last step; otherwise, a new run will be created.
+            - `"never"`: If a run with the specified `id` exists, an error will
+                be raised. If no such run is found, a new run will be created.
+            - `"must"`: If a run with the specified `id` exists, it will resume
+                from the last step. If no run is found, an error will be raised.
+            - `"auto"`: Automatically resumes the previous run if it crashed on
+                this machine; otherwise, starts a new run.
+            - `True`: Deprecated. Use `"auto"` instead.
+            - `False`: Deprecated. Use the default behavior (leaving `resume`
+                unset) to always start a new run.
+            Note: If `resume` is set, `fork_from` and `resume_from` cannot be
+            used. When `resume` is unset, the system will always start a new run.
+            For more details, see our
+            [guide to resuming runs](https://docs.wandb.com/guides/runs/resuming).
+        resume_from: Specifies a moment in a previous run to resume a run from,
+            using the format `{run_id}?_step={step}`. This allows users to truncate
+            the history logged to a run at an intermediate step and resume logging
+            from that step. The target run must be in the same project.
+            If an `id` argument is also provided, the `resume_from` argument will
+            take precedence.
+            `resume`, `resume_from` and `fork_from` cannot be used together, only
+            one of them can be used at a time.
+            Note: This feature is in beta and may change in the future.
+        fork_from: Specifies a point in a previous run from which to fork a new
+            run, using the format `{id}?_step={step}`. This creates a new run that
+            resumes logging from the specified step in the target run’s history.
+            The target run must be part of the current project.
+            If an `id` argument is also provided, it must be different from the
+            `fork_from` argument, an error will be raised if they are the same.
+            `resume`, `resume_from` and `fork_from` cannot be used together, only
+            one of them can be used at a time.
+            Note: This feature is in beta and may change in the future.
+        save_code: Enables saving the main script or notebook to W&B, aiding in
+            experiment reproducibility and allowing code comparisons across runs in
+            the UI. By default, this is disabled, but you can change the default to
+            enable on your [settings page](https://wandb.ai/settings).
+        tensorboard: Deprecated. Use `sync_tensorboard` instead.
+        sync_tensorboard: Enables automatic syncing of W&B logs from TensorBoard
+            or TensorBoardX, saving relevant event files for viewing in the W&B UI.
+            saving relevant event files for viewing in the W&B UI. (Default: `False`)
+        monitor_gym: Enables automatic logging of videos of the environment when
+            using OpenAI Gym. For additional details, see our
+            [guide for gym integration](https://docs.wandb.com/guides/integrations/openai-gym).
+        settings: Specifies a dictionary or `wandb.Settings` object with advanced
+            settings for the run.
+
+    Returns:
+        A `Run` object, which is a handle to the current run. Use this object
+        to perform operations like logging data, saving files, and finishing
+        the run. See the [Run API](https://docs.wandb.ai/ref/python/run) for
+        more details.
+
+    Raises:
+        Error: If some unknown or internal error happened during the run
+            initialization.
+        AuthenticationError: If the user failed to provide valid credentials.
+        CommError: If there was a problem communicating with the W&B server.
+        UsageError: If the user provided invalid arguments to the function.
+        KeyboardInterrupt: If the user interrupts the run initialization process.
+            If the user interrupts the run initialization process.
+    """
+    wandb._assert_is_user_process()  # type: ignore
+
+    init_settings = Settings()
+    if isinstance(settings, dict):
+        init_settings = Settings(**settings)
+    elif isinstance(settings, Settings):
+        init_settings = settings
+
+    # Explicit function arguments take precedence over settings
+    if job_type is not None:
+        init_settings.run_job_type = job_type
+    if dir is not None:
+        init_settings.root_dir = dir  # type: ignore
+    if project is not None:
+        init_settings.project = project
+    if entity is not None:
+        init_settings.entity = entity
+    if reinit is not None:
+        init_settings.reinit = reinit
+    if tags is not None:
+        init_settings.run_tags = tuple(tags)
+    if group is not None:
+        init_settings.run_group = group
+    if name is not None:
+        init_settings.run_name = name
+    if notes is not None:
+        init_settings.run_notes = notes
+    if anonymous is not None:
+        init_settings.anonymous = anonymous  # type: ignore
+    if mode is not None:
+        init_settings.mode = mode  # type: ignore
+    if resume is not None:
+        init_settings.resume = resume  # type: ignore
+    if force is not None:
+        init_settings.force = force
+    # TODO: deprecate "tensorboard" in favor of "sync_tensorboard"
+    if tensorboard is not None:
+        init_settings.sync_tensorboard = tensorboard
+    if sync_tensorboard is not None:
+        init_settings.sync_tensorboard = sync_tensorboard
+    if save_code is not None:
+        init_settings.save_code = save_code
+    if id is not None:
+        init_settings.run_id = id
+    if fork_from is not None:
+        init_settings.fork_from = fork_from  # type: ignore
+    if resume_from is not None:
+        init_settings.resume_from = resume_from  # type: ignore
+
+    try:
+        wi = _WandbInit()
+        wi.setup(
+            init_settings=init_settings,
+            config=config,
+            config_exclude_keys=config_exclude_keys,
+            config_include_keys=config_include_keys,
+            allow_val_change=allow_val_change,
+            monitor_gym=monitor_gym,
+        )
+        return wi.init()
+
+    except KeyboardInterrupt as e:
+        if logger is not None:
+            logger.warning("interrupted", exc_info=e)
+
+        raise
+
+    except Exception as e:
+        if logger is not None:
+            logger.exception("error in wandb.init()", exc_info=e)
+
+        # Need to build delay into this sentry capture because our exit hooks
+        # mess with sentry's ability to send out errors before the program ends.
+        wandb._sentry.reraise(e)
+        raise AssertionError()  # should never get here

infer_4_33_0/lib/python3.10/site-packages/wandb/sdk/wandb_settings.py

@@ -0,0 +1,1278 @@
+from __future__ import annotations
+
+import configparser
+import json
+import logging
+import multiprocessing
+import os
+import pathlib
+import platform
+import re
+import shutil
+import socket
+import sys
+import tempfile
+from datetime import datetime
+from typing import Any, Literal, Sequence
+from urllib.parse import quote, unquote, urlencode
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from google.protobuf.wrappers_pb2 import BoolValue, DoubleValue, Int32Value, StringValue
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    computed_field,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import SchemaValidator, core_schema
+
+import wandb
+from wandb import env, termwarn, util
+from wandb.apis.internal import Api
+from wandb.errors import UsageError
+from wandb.proto import wandb_settings_pb2
+
+from .lib import apikey, credentials, filesystem, ipython
+from .lib.gitlib import GitRepo
+from .lib.run_moment import RunMoment
+from .lib.runid import generate_id
+
+
+def _path_convert(*args: str) -> str:
+    """Join path and apply os.path.expanduser to it."""
+    return os.path.expanduser(os.path.join(*args))
+
+
+class Settings(BaseModel, validate_assignment=True):
+    """Settings for the W&B SDK."""
+
+    # Pydantic configuration.
+    model_config = ConfigDict(
+        extra="forbid",  # throw an error if extra fields are provided
+        # validate_default=True,  # validate default values
+    )
+
+    # Public settings.
+
+    # Flag to allow table artifacts to be synced in offline mode.
+    #
+    # To revert to the old behavior, set this to False.
+    allow_offline_artifacts: bool = True
+    allow_val_change: bool = False
+    # Controls anonymous data logging. Possible values are:
+    # - "never": requires you to link your W&B account before
+    #    tracking the run, so you don't accidentally create an anonymous
+    #    run.
+    # - "allow": lets a logged-in user track runs with their account, but
+    #    lets someone who is running the script without a W&B account see
+    #    the charts in the UI.
+    # - "must": sends the run to an anonymous account instead of to a
+    #    signed-up user account.
+    anonymous: Literal["allow", "must", "never"] | None = None
+    # The W&B API key.
+    api_key: str | None = None
+    azure_account_url_to_access_key: dict[str, str] | None = None
+    # The URL of the W&B backend, used for GraphQL and filestream operations.
+    base_url: str = "https://api.wandb.ai"
+    code_dir: str | None = None
+    config_paths: Sequence[str] | None = None
+    # The type of console capture to be applied. Possible values are:
+    #  "auto" - Automatically selects the console capture method based on the
+    #   system environment and settings.
+    #
+    #   "off" - Disables console capture.
+    #
+    #   "redirect" - Redirects low-level file descriptors for capturing output.
+    #
+    #   "wrap" - Overrides the write methods of sys.stdout/sys.stderr. Will be
+    #   mapped to either "wrap_raw" or "wrap_emu" based on the state of the system.
+    #
+    #   "wrap_raw" - Same as "wrap" but captures raw output directly instead of
+    #   through an emulator.
+    #
+    #   "wrap_emu" - Same as "wrap" but captures output through an emulator.
+    console: Literal["auto", "off", "wrap", "redirect", "wrap_raw", "wrap_emu"] = Field(
+        default="auto",
+        validate_default=True,
+    )
+    # Whether to produce multipart console log files.
+    console_multipart: bool = False
+    # Path to file for writing temporary access tokens.
+    credentials_file: str = Field(
+        default_factory=lambda: str(credentials.DEFAULT_WANDB_CREDENTIALS_FILE)
+    )
+    # Whether to disable code saving.
+    disable_code: bool = False
+    # Whether to disable capturing the git state.
+    disable_git: bool = False
+    # Whether to disable the creation of a job artifact for W&B Launch.
+    disable_job_creation: bool = True
+    # The Docker image used to execute the script.
+    docker: str | None = None
+    # The email address of the user.
+    email: str | None = None
+    # The W&B entity, like a user or a team.
+    entity: str | None = None
+    force: bool = False
+    fork_from: RunMoment | None = None
+    git_commit: str | None = None
+    git_remote: str = "origin"
+    git_remote_url: str | None = None
+    git_root: str | None = None
+    heartbeat_seconds: int = 30
+    host: str | None = None
+    # The custom proxy servers for http requests to W&B.
+    http_proxy: str | None = None
+    # The custom proxy servers for https requests to W&B.
+    https_proxy: str | None = None
+    # Path to file containing an identity token (JWT) for authentication.
+    identity_token_file: str | None = None
+    # Unix glob patterns relative to `files_dir` to not upload.
+    ignore_globs: tuple[str, ...] = ()
+    # Time in seconds to wait for the wandb.init call to complete before timing out.
+    init_timeout: float = 90.0
+    # Whether to insecurely disable SSL verification.
+    insecure_disable_ssl: bool = False
+    job_name: str | None = None
+    job_source: Literal["repo", "artifact", "image"] | None = None
+    label_disable: bool = False
+    launch: bool = False
+    launch_config_path: str | None = None
+    login_timeout: float | None = None
+    mode: Literal["online", "offline", "dryrun", "disabled", "run", "shared"] = Field(
+        default="online",
+        validate_default=True,
+    )
+    notebook_name: str | None = None
+    # Path to the script that created the run, if available.
+    program: str | None = None
+    # The absolute path from the root repository directory to the script that
+    # created the run.
+    #
+    # Root repository directory is defined as the directory containing the
+    # .git directory, if it exists. Otherwise, it's the current working directory.
+    program_abspath: str | None = None
+    program_relpath: str | None = None
+    # The W&B project ID.
+    project: str | None = None
+    quiet: bool = False
+    reinit: bool = False
+    relogin: bool = False
+    # Specifies the resume behavior for the run. The available options are:
+    #
+    #   "must": Resumes from an existing run with the same ID. If no such run exists,
+    #   it will result in failure.
+    #
+    #   "allow": Attempts to resume from an existing run with the same ID. If none is
+    #   found, a new run will be created.
+    #
+    #   "never": Always starts a new run. If a run with the same ID already exists,
+    #   it will result in failure.
+    #
+    #   "auto": Automatically resumes from the most recent failed run on the same
+    #   machine.
+    resume: Literal["allow", "must", "never", "auto"] | None = None
+    resume_from: RunMoment | None = None
+    # Indication from the server about the state of the run.
+    #
+    # This is different from resume, a user provided flag.
+    resumed: bool = False
+    # The root directory that will be used to derive other paths,
+    # such as the wandb directory, and the run directory.
+    root_dir: str = Field(default_factory=lambda: os.path.abspath(os.getcwd()))
+    run_group: str | None = None
+    # The ID of the run.
+    run_id: str | None = None
+    run_job_type: str | None = None
+    run_name: str | None = None
+    run_notes: str | None = None
+    run_tags: tuple[str, ...] | None = None
+    sagemaker_disable: bool = False
+    save_code: bool | None = None
+    settings_system: str = Field(
+        default_factory=lambda: _path_convert(
+            os.path.join("~", ".config", "wandb", "settings")
+        )
+    )
+    show_colors: bool | None = None
+    show_emoji: bool | None = None
+    show_errors: bool = True
+    show_info: bool = True
+    show_warnings: bool = True
+    silent: bool = False
+    start_method: str | None = None
+    strict: bool | None = None
+    summary_timeout: int = 60
+    summary_warnings: int = 5  # TODO: kill this with fire
+    sweep_id: str | None = None
+    sweep_param_path: str | None = None
+    symlink: bool = Field(
+        default_factory=lambda: False if platform.system() == "Windows" else True
+    )
+    sync_tensorboard: bool | None = None
+    table_raise_on_max_row_limit_exceeded: bool = False
+    username: str | None = None
+
+    # Internal settings.
+    #
+    # These are typically not meant to be set by the user and should not be considered
+    # a part of the public API as they may change or be removed in future versions.
+
+    # CLI mode.
+    x_cli_only_mode: bool = False
+    # Disable the collection of system metadata.
+    x_disable_meta: bool = False
+    # Pre-wandb-core, this setting was used to disable the (now legacy) wandb service.
+    #
+    # TODO: this is deprecated and will be removed in future versions.
+    x_disable_service: bool = False
+    # Do not use setproctitle for internal process in legacy service.
+    x_disable_setproctitle: bool = False
+    # Disable system metrics collection.
+    x_disable_stats: bool = False
+    # Disable check for latest version of wandb, from PyPI.
+    x_disable_update_check: bool = False
+    # Prevent early viewer query.
+    x_disable_viewer: bool = False
+    # Disable automatic machine info collection.
+    x_disable_machine_info: bool = False
+    # Python executable
+    x_executable: str | None = None
+    # Additional headers to add to all outgoing HTTP requests.
+    x_extra_http_headers: dict[str, str] | None = None
+    # An approximate maximum request size for the filestream API.
+    #
+    # This applies when wandb-core is enabled. Its purpose is to prevent
+    # HTTP requests from failing due to containing too much data.
+    #
+    # This number is approximate: requests will be slightly larger.
+    x_file_stream_max_bytes: int | None = None
+    # Max line length for filestream jsonl files.
+    x_file_stream_max_line_bytes: int | None = None
+    # Interval in seconds between filestream transmissions.
+    x_file_stream_transmit_interval: float | None = None
+    # Filestream retry client configuration.
+    # max number of retries
+    x_file_stream_retry_max: int | None = None
+    # min wait time between retries
+    x_file_stream_retry_wait_min_seconds: float | None = None
+    # max wait time between retries
+    x_file_stream_retry_wait_max_seconds: float | None = None
+    # timeout for individual HTTP requests
+    x_file_stream_timeout_seconds: float | None = None
+    # file transfer retry client configuration
+    x_file_transfer_retry_max: int | None = None
+    x_file_transfer_retry_wait_min_seconds: float | None = None
+    x_file_transfer_retry_wait_max_seconds: float | None = None
+    x_file_transfer_timeout_seconds: float | None = None
+    # override setting for the computed files_dir
+    x_files_dir: str | None = None
+    # flow control configuration for file stream
+    x_flow_control_custom: bool | None = None
+    x_flow_control_disabled: bool | None = None
+    # graphql retry client configuration
+    x_graphql_retry_max: int | None = None
+    x_graphql_retry_wait_min_seconds: float | None = None
+    x_graphql_retry_wait_max_seconds: float | None = None
+    x_graphql_timeout_seconds: float | None = None
+    x_internal_check_process: float = 8.0
+    x_jupyter_name: str | None = None
+    x_jupyter_path: str | None = None
+    x_jupyter_root: str | None = None
+    # Label to assign to system metrics and console logs collected for the run
+    # to group by on the frontend. Can be used to distinguish data from different
+    # nodes in a distributed training job.
+    x_label: str | None = None
+    x_live_policy_rate_limit: int | None = None
+    x_live_policy_wait_time: int | None = None
+    x_log_level: int = logging.INFO
+    x_network_buffer: int | None = None
+    # Determines whether to save internal wandb files and metadata.
+    # In a distributed setting, this is useful for avoiding file overwrites on secondary nodes
+    # when only system metrics and logs are needed, as the primary node handles the main logging.
+    x_primary_node: bool = True
+    # [deprecated, use http(s)_proxy] custom proxy servers for the requests to W&B
+    # [scheme -> url].
+    x_proxies: dict[str, str] | None = None
+    x_runqueue_item_id: str | None = None
+    x_require_legacy_service: bool = False
+    x_save_requirements: bool = True
+    x_service_transport: str | None = None
+    x_service_wait: float = 30.0
+    x_show_operation_stats: bool = True
+    # The start time of the run in seconds since the Unix epoch.
+    x_start_time: float | None = None
+    # PID of the process that started the wandb-core process to collect system stats for.
+    x_stats_pid: int = os.getpid()
+    # Sampling interval for the system monitor in seconds.
+    x_stats_sampling_interval: float = Field(default=10.0)
+    # Path to store the default config file for the neuron-monitor tool
+    # used to monitor AWS Trainium devices.
+    x_stats_neuron_monitor_config_path: str | None = None
+    # Open metrics endpoint names and urls.
+    x_stats_open_metrics_endpoints: dict[str, str] | None = None
+    # Filter to apply to metrics collected from OpenMetrics endpoints.
+    # Supports two formats:
+    # - {"metric regex pattern, including endpoint name as prefix": {"label": "label value regex pattern"}}
+    # - ("metric regex pattern 1", "metric regex pattern 2", ...)
+    x_stats_open_metrics_filters: dict[str, dict[str, str]] | Sequence[str] | None = (
+        None
+    )
+    # HTTP headers to add to OpenMetrics requests.
+    x_stats_open_metrics_http_headers: dict[str, str] | None = None
+    # System paths to monitor for disk usage.
+    x_stats_disk_paths: Sequence[str] | None = Field(
+        default_factory=lambda: ("/", "/System/Volumes/Data")
+        if platform.system() == "Darwin"
+        else ("/",)
+    )
+    # GPU device indices to monitor (e.g. [0, 1, 2]).
+    # If not set, captures metrics for all GPUs.
+    # Assumes 0-based indexing matching CUDA/ROCm device enumeration.
+    x_stats_gpu_device_ids: Sequence[int] | None = None
+    # Number of system metric samples to buffer in memory in the wandb-core process.
+    # Can be accessed via run._system_metrics.
+    x_stats_buffer_size: int = 0
+    # Flag to indicate whether we are syncing a run from the transaction log.
+    x_sync: bool = False
+    # Controls whether this process can update the run's final state (finished/failed) on the server.
+    # Set to False in distributed training when only the main process should determine the final state.
+    x_update_finish_state: bool = True
+
+    # Model validator to catch legacy settings.
+    @model_validator(mode="before")
+    @classmethod
+    def catch_private_settings(cls, values):
+        """Check if a private field is provided and assign to the corresponding public one.
+
+        This is a compatibility layer to handle previous versions of the settings.
+        """
+        new_values = {}
+        for key in values:
+            # Internal settings are prefixed with "x_" instead of "_"
+            # as Pydantic does not allow "_" in field names.
+            if key.startswith("_"):
+                new_values["x" + key] = values[key]
+            else:
+                new_values[key] = values[key]
+        return new_values
+
+    @model_validator(mode="after")
+    def validate_mutual_exclusion_of_branching_args(self) -> Self:
+        if (
+            sum(
+                o is not None
+                for o in [
+                    self.fork_from,
+                    self.resume,
+                    self.resume_from,
+                ]
+            )
+            > 1
+        ):
+            raise ValueError(
+                "`fork_from`, `resume`, or `resume_from` are mutually exclusive. "
+                "Please specify only one of them."
+            )
+        return self
+
+    # Field validators.
+
+    @field_validator("x_disable_service", mode="after")
+    @classmethod
+    def validate_disable_service(cls, value):
+        if value:
+            termwarn(
+                "Disabling the wandb service is deprecated as of version 0.18.0 "
+                "and will be removed in future versions. ",
+                repeat=False,
+            )
+        return value
+
+    @field_validator("api_key", mode="after")
+    @classmethod
+    def validate_api_key(cls, value):
+        if value is not None and (len(value) > len(value.strip())):
+            raise UsageError("API key cannot start or end with whitespace")
+        return value
+
+    @field_validator("base_url", mode="after")
+    @classmethod
+    def validate_base_url(cls, value):
+        cls.validate_url(value)
+        # wandb.ai-specific checks
+        if re.match(r".*wandb\.ai[^\.]*$", value) and "api." not in value:
+            # user might guess app.wandb.ai or wandb.ai is the default cloud server
+            raise ValueError(
+                f"{value} is not a valid server address, did you mean https://api.wandb.ai?"
+            )
+        elif re.match(r".*wandb\.ai[^\.]*$", value) and not value.startswith("https"):
+            raise ValueError("http is not secure, please use https://api.wandb.ai")
+        return value.rstrip("/")
+
+    @field_validator("code_dir", mode="before")
+    @classmethod
+    def validate_code_dir(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("console", mode="after")
+    @classmethod
+    def validate_console(cls, value, info):
+        if value != "auto":
+            return value
+        if (
+            ipython.in_jupyter()
+            or (info.data.get("start_method") == "thread")
+            or not info.data.get("disable_service")
+            or platform.system() == "Windows"
+        ):
+            value = "wrap"
+        else:
+            value = "redirect"
+        return value
+
+    @field_validator("x_executable", mode="before")
+    @classmethod
+    def validate_x_executable(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("x_file_stream_max_line_bytes", mode="after")
+    @classmethod
+    def validate_file_stream_max_line_bytes(cls, value):
+        if value is not None and value < 1:
+            raise ValueError("File stream max line bytes must be greater than 0")
+        return value
+
+    @field_validator("x_files_dir", mode="before")
+    @classmethod
+    def validate_x_files_dir(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("fork_from", mode="before")
+    @classmethod
+    def validate_fork_from(cls, value, info) -> RunMoment | None:
+        run_moment = cls._runmoment_preprocessor(value)
+        if run_moment and info.data.get("run_id") == run_moment.run:
+            raise ValueError(
+                "Provided `run_id` is the same as the run to `fork_from`. "
+                "Please provide a different `run_id` or remove the `run_id` argument. "
+                "If you want to rewind the current run, please use `resume_from` instead."
+            )
+        return run_moment
+
+    @field_validator("http_proxy", mode="after")
+    @classmethod
+    def validate_http_proxy(cls, value):
+        if value is None:
+            return None
+        cls.validate_url(value)
+        return value.rstrip("/")
+
+    @field_validator("https_proxy", mode="after")
+    @classmethod
+    def validate_https_proxy(cls, value):
+        if value is None:
+            return None
+        cls.validate_url(value)
+        return value.rstrip("/")
+
+    @field_validator("ignore_globs", mode="after")
+    @classmethod
+    def validate_ignore_globs(cls, value):
+        return tuple(value) if not isinstance(value, tuple) else value
+
+    @field_validator("program", mode="before")
+    @classmethod
+    def validate_program(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("program_abspath", mode="before")
+    @classmethod
+    def validate_program_abspath(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("program_relpath", mode="before")
+    @classmethod
+    def validate_program_relpath(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("project", mode="after")
+    @classmethod
+    def validate_project(cls, value, info):
+        if value is None:
+            return None
+        invalid_chars_list = list("/\\#?%:")
+        if len(value) > 128:
+            raise UsageError(f"Invalid project name {value!r}: exceeded 128 characters")
+        invalid_chars = {char for char in invalid_chars_list if char in value}
+        if invalid_chars:
+            raise UsageError(
+                f"Invalid project name {value!r}: "
+                f"cannot contain characters {','.join(invalid_chars_list)!r}, "
+                f"found {','.join(invalid_chars)!r}"
+            )
+        return value
+
+    @field_validator("resume", mode="before")
+    @classmethod
+    def validate_resume(cls, value):
+        if value is False:
+            return None
+        if value is True:
+            return "auto"
+        return value
+
+    @field_validator("resume_from", mode="before")
+    @classmethod
+    def validate_resume_from(cls, value, info) -> RunMoment | None:
+        run_moment = cls._runmoment_preprocessor(value)
+        if run_moment and info.data.get("run_id") != run_moment.run:
+            raise ValueError(
+                "Both `run_id` and `resume_from` have been specified with different ids."
+            )
+        return run_moment
+
+    @field_validator("root_dir", mode="before")
+    @classmethod
+    def validate_root_dir(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("run_id", mode="after")
+    @classmethod
+    def validate_run_id(cls, value, info):
+        if value is None:
+            return None
+
+        if len(value) == 0:
+            raise UsageError("Run ID cannot be empty")
+        if len(value) > len(value.strip()):
+            raise UsageError("Run ID cannot start or end with whitespace")
+        if not bool(value.strip()):
+            raise UsageError("Run ID cannot contain only whitespace")
+        return value
+
+    @field_validator("settings_system", mode="after")
+    @classmethod
+    def validate_settings_system(cls, value):
+        if isinstance(value, pathlib.Path):
+            return str(_path_convert(value))
+        return _path_convert(value)
+
+    @field_validator("x_service_wait", mode="after")
+    @classmethod
+    def validate_service_wait(cls, value):
+        if value < 0:
+            raise UsageError("Service wait time cannot be negative")
+        return value
+
+    @field_validator("start_method")
+    @classmethod
+    def validate_start_method(cls, value):
+        if value is None:
+            return value
+        available_methods = ["thread"]
+        if hasattr(multiprocessing, "get_all_start_methods"):
+            available_methods += multiprocessing.get_all_start_methods()
+        if value not in available_methods:
+            raise UsageError(
+                f"Settings field `start_method`: {value!r} not in {available_methods}"
+            )
+        return value
+
+    @field_validator("x_stats_gpu_device_ids", mode="before")
+    @classmethod
+    def validate_x_stats_gpu_device_ids(cls, value):
+        if isinstance(value, str):
+            return json.loads(value)
+        return value
+
+    @field_validator("x_stats_neuron_monitor_config_path", mode="before")
+    @classmethod
+    def validate_x_stats_neuron_monitor_config_path(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    @field_validator("x_stats_open_metrics_endpoints", mode="before")
+    @classmethod
+    def validate_stats_open_metrics_endpoints(cls, value):
+        if isinstance(value, str):
+            return json.loads(value)
+        return value
+
+    @field_validator("x_stats_open_metrics_filters", mode="before")
+    @classmethod
+    def validate_stats_open_metrics_filters(cls, value):
+        if isinstance(value, str):
+            return json.loads(value)
+        return value
+
+    @field_validator("x_stats_open_metrics_http_headers", mode="before")
+    @classmethod
+    def validate_stats_open_metrics_http_headers(cls, value):
+        if isinstance(value, str):
+            return json.loads(value)
+        return value
+
+    @field_validator("x_stats_sampling_interval", mode="after")
+    @classmethod
+    def validate_stats_sampling_interval(cls, value):
+        if value < 0.1:
+            raise UsageError("Stats sampling interval cannot be less than 0.1 seconds")
+        return value
+
+    @field_validator("sweep_id", mode="after")
+    @classmethod
+    def validate_sweep_id(cls, value):
+        if value is None:
+            return None
+        if len(value) == 0:
+            raise UsageError("Sweep ID cannot be empty")
+        if len(value) > len(value.strip()):
+            raise UsageError("Sweep ID cannot start or end with whitespace")
+        if not bool(value.strip()):
+            raise UsageError("Sweep ID cannot contain only whitespace")
+        return value
+
+    @field_validator("sweep_param_path", mode="before")
+    @classmethod
+    def validate_sweep_param_path(cls, value):
+        # TODO: add native support for pathlib.Path
+        if isinstance(value, pathlib.Path):
+            return str(value)
+        return value
+
+    # Computed fields.
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _args(self) -> list[str]:
+        if not self._jupyter:
+            return sys.argv[1:]
+        return []
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _aws_lambda(self) -> bool:
+        """Check if we are running in a lambda environment."""
+        from sentry_sdk.integrations.aws_lambda import (  # type: ignore[import-not-found]
+            get_lambda_bootstrap,
+        )
+
+        lambda_bootstrap = get_lambda_bootstrap()
+        if not lambda_bootstrap or not hasattr(
+            lambda_bootstrap, "handle_event_request"
+        ):
+            return False
+        return True
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _code_path_local(self) -> str | None:
+        """The relative path from the current working directory to the code path.
+
+        For example, if the code path is /home/user/project/example.py, and the
+        current working directory is /home/user/project, then the code path local
+        is example.py.
+
+        If couldn't find the relative path, this will be an empty string.
+        """
+        return self._get_program_relpath(self.program) if self.program else None
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _colab(self) -> bool:
+        return "google.colab" in sys.modules
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _ipython(self) -> bool:
+        return ipython.in_ipython()
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _jupyter(self) -> bool:
+        return ipython.in_jupyter()
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _kaggle(self) -> bool:
+        return util._is_likely_kaggle()
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _noop(self) -> bool:
+        return self.mode == "disabled"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _notebook(self) -> bool:
+        return self._ipython or self._jupyter or self._colab or self._kaggle
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _offline(self) -> bool:
+        return self.mode in ("offline", "dryrun")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _os(self) -> str:
+        """The operating system of the machine running the script."""
+        return platform.platform(aliased=True)
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _platform(self) -> str:
+        return f"{platform.system()}-{platform.machine()}".lower()
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _python(self) -> str:
+        return f"{platform.python_implementation()} {platform.python_version()}"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _shared(self) -> bool:
+        """Whether we are in shared mode.
+
+        In "shared" mode, multiple processes can write to the same run,
+        for example from different machines.
+        """
+        return self.mode == "shared"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _start_datetime(self) -> str:
+        if self.x_start_time is None:
+            return ""
+        datetime_now = datetime.fromtimestamp(self.x_start_time)
+        return datetime_now.strftime("%Y%m%d_%H%M%S")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _tmp_code_dir(self) -> str:
+        return _path_convert(
+            self.wandb_dir,
+            f"{self.run_mode}-{self.timespec}-{self.run_id}",
+            "tmp",
+            "code",
+        )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def _windows(self) -> bool:
+        return platform.system() == "Windows"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def colab_url(self) -> str | None:
+        """The URL to the Colab notebook, if running in Colab."""
+        if not self._colab:
+            return None
+        if self.x_jupyter_path and self.x_jupyter_path.startswith("fileId="):
+            unescaped = unquote(self.x_jupyter_path)
+            return "https://colab.research.google.com/notebook#" + unescaped
+        return None
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def deployment(self) -> Literal["local", "cloud"]:
+        return "local" if self.is_local else "cloud"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def files_dir(self) -> str:
+        """Absolute path to the local directory where the run's files are stored."""
+        return self.x_files_dir or _path_convert(
+            self.wandb_dir,
+            f"{self.run_mode}-{self.timespec}-{self.run_id}",
+            "files",
+        )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def is_local(self) -> bool:
+        return str(self.base_url) != "https://api.wandb.ai"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def log_dir(self) -> str:
+        """The directory for storing log files."""
+        return _path_convert(
+            self.wandb_dir, f"{self.run_mode}-{self.timespec}-{self.run_id}", "logs"
+        )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def log_internal(self) -> str:
+        """The path to the file to use for internal logs."""
+        return _path_convert(self.log_dir, "debug-internal.log")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def log_symlink_internal(self) -> str:
+        """The path to the symlink to the internal log file of the most recent run."""
+        return _path_convert(self.wandb_dir, "debug-internal.log")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def log_symlink_user(self) -> str:
+        """The path to the symlink to the user-process log file of the most recent run."""
+        return _path_convert(self.wandb_dir, "debug.log")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def log_user(self) -> str:
+        """The path to the file to use for user-process logs."""
+        return _path_convert(self.log_dir, "debug.log")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def project_url(self) -> str:
+        """The W&B URL where the project can be viewed."""
+        project_url = self._project_url_base()
+        if not project_url:
+            return ""
+
+        query = self._get_url_query_string()
+
+        return f"{project_url}{query}"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def resume_fname(self) -> str:
+        """The path to the resume file."""
+        return _path_convert(self.wandb_dir, "wandb-resume.json")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def run_mode(self) -> Literal["run", "offline-run"]:
+        return "run" if not self._offline else "offline-run"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def run_url(self) -> str:
+        """The W&B URL where the run can be viewed."""
+        project_url = self._project_url_base()
+        if not all([project_url, self.run_id]):
+            return ""
+
+        query = self._get_url_query_string()
+        return f"{project_url}/runs/{quote(self.run_id or '')}{query}"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def settings_workspace(self) -> str:
+        """The path to the workspace settings file."""
+        return _path_convert(self.wandb_dir, "settings")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def sweep_url(self) -> str:
+        """The W&B URL where the sweep can be viewed."""
+        project_url = self._project_url_base()
+        if not all([project_url, self.sweep_id]):
+            return ""
+
+        query = self._get_url_query_string()
+        return f"{project_url}/sweeps/{quote(self.sweep_id or '')}{query}"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def sync_dir(self) -> str:
+        return _path_convert(
+            self.wandb_dir, f"{self.run_mode}-{self.timespec}-{self.run_id}"
+        )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def sync_file(self) -> str:
+        """Path to the append-only binary transaction log file."""
+        return _path_convert(self.sync_dir, f"run-{self.run_id}.wandb")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def sync_symlink_latest(self) -> str:
+        return _path_convert(self.wandb_dir, "latest-run")
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def timespec(self) -> str:
+        return self._start_datetime
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def wandb_dir(self) -> str:
+        """Full path to the wandb directory.
+
+        The setting exposed to users as `dir=` or `WANDB_DIR` is the `root_dir`.
+        We add the `__stage_dir__` to it to get the full `wandb_dir`
+        """
+        root_dir = self.root_dir or ""
+
+        # We use the hidden version if it already exists, otherwise non-hidden.
+        if os.path.exists(os.path.join(root_dir, ".wandb")):
+            __stage_dir__ = ".wandb" + os.sep
+        else:
+            __stage_dir__ = "wandb" + os.sep
+
+        path = os.path.join(root_dir, __stage_dir__)
+        if not os.access(root_dir or ".", os.W_OK):
+            termwarn(
+                f"Path {path} wasn't writable, using system temp directory.",
+                repeat=False,
+            )
+            path = os.path.join(
+                tempfile.gettempdir(), __stage_dir__ or ("wandb" + os.sep)
+            )
+
+        return os.path.expanduser(path)
+
+    # Methods to collect and update settings from different sources.
+    #
+    # The Settings class does not track the source of the settings,
+    # so it is up to the developer to ensure that the settings are applied
+    # in the correct order. Most of the updates are done in
+    # wandb/sdk/wandb_setup.py::_WandbSetup._settings_setup.
+
+    def update_from_system_config_file(self):
+        """Update settings from the system config file."""
+        if not self.settings_system or not os.path.exists(self.settings_system):
+            return
+        for key, value in self._load_config_file(self.settings_system).items():
+            if value is not None:
+                setattr(self, key, value)
+
+    def update_from_workspace_config_file(self):
+        """Update settings from the workspace config file."""
+        if not self.settings_workspace or not os.path.exists(self.settings_workspace):
+            return
+        for key, value in self._load_config_file(self.settings_workspace).items():
+            if value is not None:
+                setattr(self, key, value)
+
+    def update_from_env_vars(self, environ: dict[str, Any]):
+        """Update settings from environment variables."""
+        env_prefix: str = "WANDB_"
+        private_env_prefix: str = env_prefix + "_"
+        special_env_var_names = {
+            "WANDB_DISABLE_SERVICE": "x_disable_service",
+            "WANDB_SERVICE_TRANSPORT": "x_service_transport",
+            "WANDB_DIR": "root_dir",
+            "WANDB_NAME": "run_name",
+            "WANDB_NOTES": "run_notes",
+            "WANDB_TAGS": "run_tags",
+            "WANDB_JOB_TYPE": "run_job_type",
+            "WANDB_HTTP_TIMEOUT": "x_graphql_timeout_seconds",
+            "WANDB_FILE_PUSHER_TIMEOUT": "x_file_transfer_timeout_seconds",
+            "WANDB_USER_EMAIL": "email",
+        }
+        env = dict()
+        for setting, value in environ.items():
+            if not setting.startswith(env_prefix):
+                continue
+
+            if setting in special_env_var_names:
+                key = special_env_var_names[setting]
+            elif setting.startswith(private_env_prefix):
+                key = "x_" + setting[len(private_env_prefix) :].lower()
+            else:
+                # otherwise, strip the prefix and convert to lowercase
+                key = setting[len(env_prefix) :].lower()
+
+            if key in self.__dict__:
+                if key in ("ignore_globs", "run_tags"):
+                    value = value.split(",")
+                env[key] = value
+
+        for key, value in env.items():
+            if value is not None:
+                setattr(self, key, value)
+
+    def update_from_system_environment(self):
+        """Update settings from the system environment."""
+        # For code saving, only allow env var override if value from server is true, or
+        # if no preference was specified.
+        if (self.save_code is True or self.save_code is None) and (
+            os.getenv(env.SAVE_CODE) is not None
+            or os.getenv(env.DISABLE_CODE) is not None
+        ):
+            self.save_code = env.should_save_code()
+
+        self.disable_git = env.disable_git()
+
+        # Attempt to get notebook information if not already set by the user
+        if self._jupyter and (self.notebook_name is None or self.notebook_name == ""):
+            meta = wandb.jupyter.notebook_metadata(self.silent)  # type: ignore
+            self.x_jupyter_path = meta.get("path")
+            self.x_jupyter_name = meta.get("name")
+            self.x_jupyter_root = meta.get("root")
+        elif (
+            self._jupyter
+            and self.notebook_name is not None
+            and os.path.exists(self.notebook_name)
+        ):
+            self.x_jupyter_path = self.notebook_name
+            self.x_jupyter_name = self.notebook_name
+            self.x_jupyter_root = os.getcwd()
+        elif self._jupyter:
+            wandb.termwarn(
+                "WANDB_NOTEBOOK_NAME should be a path to a notebook file, "
+                f"couldn't find {self.notebook_name}.",
+            )
+
+        # host and username are populated by apply_env_vars if corresponding env
+        # vars exist -- but if they don't, we'll fill them in here
+        if self.host is None:
+            self.host = socket.gethostname()  # type: ignore
+
+        _executable = (
+            self.x_executable
+            or os.environ.get(env._EXECUTABLE)
+            or sys.executable
+            or shutil.which("python3")
+            or "python3"
+        )
+        self.x_executable = _executable
+
+        if self.docker is None:
+            self.docker = env.get_docker(util.image_id_from_k8s())
+
+        # proceed if not in CLI mode
+        if self.x_cli_only_mode:
+            return
+
+        program = self.program or self._get_program()
+
+        if program is not None:
+            repo = GitRepo()
+            root = repo.root or os.getcwd()
+
+            self.program_relpath = self.program_relpath or self._get_program_relpath(
+                program, root
+            )
+            program_abspath = os.path.abspath(
+                os.path.join(root, os.path.relpath(os.getcwd(), root), program)
+            )
+            if os.path.exists(program_abspath):
+                self.program_abspath = program_abspath
+        else:
+            program = "<python with no main file>"
+
+        self.program = program
+
+    def update_from_dict(self, settings: dict[str, Any]) -> None:
+        """Update settings from a dictionary."""
+        for key, value in dict(settings).items():
+            if value is not None:
+                setattr(self, key, value)
+
+    def update_from_settings(self, settings: Settings) -> None:
+        """Update settings from another instance of `Settings`."""
+        d = {field: getattr(settings, field) for field in settings.model_fields_set}
+        if d:
+            self.update_from_dict(d)
+
+    # Helper methods.
+
+    def to_proto(self) -> wandb_settings_pb2.Settings:
+        """Generate a protobuf representation of the settings."""
+        settings_proto = wandb_settings_pb2.Settings()
+        for k, v in self.model_dump(exclude_none=True).items():
+            # special case for x_stats_open_metrics_filters
+            if k == "x_stats_open_metrics_filters":
+                if isinstance(v, (list, set, tuple)):
+                    setting = getattr(settings_proto, k)
+                    setting.sequence.value.extend(v)
+                elif isinstance(v, dict):
+                    setting = getattr(settings_proto, k)
+                    for key, value in v.items():
+                        for kk, vv in value.items():
+                            setting.mapping.value[key].value[kk] = vv
+                else:
+                    raise TypeError(f"Unsupported type {type(v)} for setting {k}")
+                continue
+
+            if isinstance(v, bool):
+                getattr(settings_proto, k).CopyFrom(BoolValue(value=v))
+            elif isinstance(v, int):
+                getattr(settings_proto, k).CopyFrom(Int32Value(value=v))
+            elif isinstance(v, float):
+                getattr(settings_proto, k).CopyFrom(DoubleValue(value=v))
+            elif isinstance(v, str):
+                getattr(settings_proto, k).CopyFrom(StringValue(value=v))
+            elif isinstance(v, (list, set, tuple)):
+                # we only support sequences of strings for now
+                sequence = getattr(settings_proto, k)
+                sequence.value.extend(v)
+            elif isinstance(v, dict):
+                mapping = getattr(settings_proto, k)
+                for key, value in v.items():
+                    # we only support dicts with string values for now
+                    mapping.value[key] = value
+            elif isinstance(v, RunMoment):
+                getattr(settings_proto, k).CopyFrom(
+                    wandb_settings_pb2.RunMoment(
+                        run=v.run,
+                        value=v.value,
+                        metric=v.metric,
+                    )
+                )
+            elif v is None:
+                # None means that the setting value was not set.
+                pass
+            else:
+                raise TypeError(f"Unsupported type {type(v)} for setting {k}")
+
+        return settings_proto
+
+    def handle_resume_logic(self):
+        """Handle logic for resuming runs."""
+        # handle auto resume logic
+        if self.resume == "auto":
+            if os.path.exists(self.resume_fname):
+                with open(self.resume_fname) as f:
+                    resume_run_id = json.load(f)["run_id"]
+                if self.run_id is None:
+                    self.run_id = resume_run_id
+                elif self.run_id != resume_run_id:
+                    wandb.termwarn(
+                        "Tried to auto resume run with "
+                        f"id {resume_run_id} but id {self.run_id} is set.",
+                    )
+        if self.run_id is None:
+            self.run_id = generate_id()
+
+        # persist run_id in case of failure
+        if self.resume == "auto" and self.resume_fname is not None:
+            filesystem.mkdir_exists_ok(self.wandb_dir)
+            with open(self.resume_fname, "w") as f:
+                f.write(json.dumps({"run_id": self.run_id}))
+
+    @staticmethod
+    def validate_url(url: str) -> None:
+        """Validate a URL string."""
+        url_validator = SchemaValidator(
+            core_schema.url_schema(
+                allowed_schemes=["http", "https"],
+                strict=True,
+            )
+        )
+        url_validator.validate_python(url)
+
+    def _get_program(self) -> str | None:
+        """Get the program that started the current process."""
+        if not self._jupyter:
+            # If not in a notebook, try to get the program from the environment
+            # or the __main__ module for scripts run as `python -m ...`.
+            program = os.getenv(env.PROGRAM)
+            if program is not None:
+                return program
+            try:
+                import __main__
+
+                if __main__.__spec__ is None:
+                    return __main__.__file__
+                return f"-m {__main__.__spec__.name}"
+            except (ImportError, AttributeError):
+                return None
+        else:
+            # If in a notebook, try to get the program from the notebook metadata.
+            if self.notebook_name:
+                return self.notebook_name
+
+            if not self.x_jupyter_path:
+                return self.program
+
+            if self.x_jupyter_path.startswith("fileId="):
+                return self.x_jupyter_name
+            else:
+                return self.x_jupyter_path
+
+    @staticmethod
+    def _get_program_relpath(program: str, root: str | None = None) -> str | None:
+        """Get the relative path to the program from the root directory."""
+        if not program:
+            return None
+
+        root = root or os.getcwd()
+        if not root:
+            return None
+
+        full_path_to_program = os.path.join(
+            root, os.path.relpath(os.getcwd(), root), program
+        )
+        if os.path.exists(full_path_to_program):
+            relative_path = os.path.relpath(full_path_to_program, start=root)
+            if "../" in relative_path:
+                return None
+            return relative_path
+
+        return None
+
+    @staticmethod
+    def _load_config_file(file_name: str, section: str = "default") -> dict:
+        """Load a config file and return the settings for a given section."""
+        parser = configparser.ConfigParser()
+        parser.add_section(section)
+        parser.read(file_name)
+        config: dict[str, Any] = dict()
+        for k in parser[section]:
+            config[k] = parser[section][k]
+            if k == "ignore_globs":
+                config[k] = config[k].split(",")
+        return config
+
+    def _project_url_base(self) -> str:
+        """Construct the base URL for the project."""
+        if not all([self.entity, self.project]):
+            return ""
+
+        app_url = util.app_url(self.base_url)
+        return f"{app_url}/{quote(self.entity or '')}/{quote(self.project or '')}"
+
+    def _get_url_query_string(self) -> str:
+        """Construct the query string for project, run, and sweep URLs."""
+        # TODO: remove dependency on Api()
+        if Api().settings().get("anonymous") not in ["allow", "must"]:
+            return ""
+
+        api_key = apikey.api_key(settings=self)
+
+        return f"?{urlencode({'apiKey': api_key})}"
+
+    @staticmethod
+    def _runmoment_preprocessor(val: RunMoment | str | None) -> RunMoment | None:
+        """Preprocess the setting for forking or resuming a run."""
+        if isinstance(val, RunMoment) or val is None:
+            return val
+        elif isinstance(val, str):
+            return RunMoment.from_uri(val)

infer_4_33_0/lib/python3.10/site-packages/wandb/sdk/wandb_summary.py

@@ -0,0 +1,150 @@
+import abc
+import typing as t
+
+from .interface.summary_record import SummaryItem, SummaryRecord
+
+
+def _get_dict(d):
+    if isinstance(d, dict):
+        return d
+    # assume argparse Namespace
+    return vars(d)
+
+
+class SummaryDict(metaclass=abc.ABCMeta):
+    """dict-like wrapper for the nested dictionaries in a SummarySubDict.
+
+    Triggers self._root._callback on property changes.
+    """
+
+    @abc.abstractmethod
+    def _as_dict(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _update(self, record: SummaryRecord):
+        raise NotImplementedError
+
+    def keys(self):
+        return [k for k in self._as_dict().keys() if k != "_wandb"]
+
+    def get(self, key, default=None):
+        return self._as_dict().get(key, default)
+
+    def __getitem__(self, key):
+        item = self._as_dict()[key]
+
+        if isinstance(item, dict):
+            # this nested dict needs to be wrapped:
+            wrapped_item = SummarySubDict()
+            object.__setattr__(wrapped_item, "_items", item)
+            object.__setattr__(wrapped_item, "_parent", self)
+            object.__setattr__(wrapped_item, "_parent_key", key)
+
+            return wrapped_item
+
+        # this item isn't a nested dict
+        return item
+
+    __getattr__ = __getitem__
+
+    def __setitem__(self, key, val):
+        self.update({key: val})
+
+    __setattr__ = __setitem__
+
+    def __delattr__(self, key):
+        record = SummaryRecord()
+        item = SummaryItem()
+        item.key = (key,)
+        record.remove = (item,)
+        self._update(record)
+
+    __delitem__ = __delattr__
+
+    def update(self, d: t.Dict):
+        # import ipdb; ipdb.set_trace()
+        record = SummaryRecord()
+        for key, value in d.items():
+            item = SummaryItem()
+            item.key = (key,)
+            item.value = value
+            record.update.append(item)
+
+        self._update(record)
+
+
+class Summary(SummaryDict):
+    """Track single values for each metric for each run.
+
+    By default, a metric's summary is the last value of its History.
+
+    For example, `wandb.log({'accuracy': 0.9})` will add a new step to History and
+    update Summary to the latest value. In some cases, it's more useful to have
+    the maximum or minimum of a metric instead of the final value. You can set
+    history manually `(wandb.summary['accuracy'] = best_acc)`.
+
+    In the UI, summary metrics appear in the table to compare across runs.
+    Summary metrics are also used in visualizations like the scatter plot and
+    parallel coordinates chart.
+
+    After training has completed, you may want to save evaluation metrics to a
+    run. Summary can handle numpy arrays and PyTorch/TensorFlow tensors. When
+    you save one of these types to Summary, we persist the entire tensor in a
+    binary file and store high level metrics in the summary object, such as min,
+    mean, variance, and 95th percentile.
+
+    Examples:
+        ```python
+        wandb.init(config=args)
+
+        best_accuracy = 0
+        for epoch in range(1, args.epochs + 1):
+            test_loss, test_accuracy = test()
+            if test_accuracy > best_accuracy:
+                wandb.run.summary["best_accuracy"] = test_accuracy
+                best_accuracy = test_accuracy
+        ```
+    """
+
+    _update_callback: t.Callable
+    _get_current_summary_callback: t.Callable
+
+    def __init__(self, get_current_summary_callback: t.Callable):
+        super().__init__()
+        object.__setattr__(self, "_update_callback", None)
+        object.__setattr__(
+            self, "_get_current_summary_callback", get_current_summary_callback
+        )
+
+    def _set_update_callback(self, update_callback: t.Callable):
+        object.__setattr__(self, "_update_callback", update_callback)
+
+    def _as_dict(self):
+        return self._get_current_summary_callback()
+
+    def _update(self, record: SummaryRecord):
+        if self._update_callback:  # type: ignore
+            self._update_callback(record)
+
+
+class SummarySubDict(SummaryDict):
+    """Non-root node of the summary data structure.
+
+    Contains a path to itself from the root.
+    """
+
+    _items: t.Dict
+    _parent: SummaryDict
+    _parent_key: str
+
+    def __init__(self):
+        object.__setattr__(self, "_items", dict())
+        object.__setattr__(self, "_parent", None)
+        object.__setattr__(self, "_parent_key", None)
+
+    def _as_dict(self):
+        return self._items
+
+    def _update(self, record: SummaryRecord):
+        return self._parent._update(record._add_next_parent(self._parent_key))