> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-sdk-add-methods-properties.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Settings

export const GitHubLink = ({url, compact = false}) => <a href={url} target="_blank" rel="noopener noreferrer" className={compact ? "source-link" : "github-source-link"}>
    {compact ? "View source" : <>
    <svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
      <path d="M12 0C5.37 0 0 5.37 0 12c0 5.31 3.435 9.795 8.205 11.385.6.105.825-.255.825-.57 0-.285-.015-1.23-.015-2.235-3.015.555-3.795-.735-4.035-1.41-.135-.345-.72-1.41-1.23-1.695-.42-.225-1.02-.78-.015-.795.945-.015 1.62.87 1.845 1.23 1.08 1.815 2.805 1.305 3.495.99.105-.78.42-1.305.765-1.605-2.67-.3-5.46-1.335-5.46-5.925 0-1.305.465-2.385 1.23-3.225-.12-.3-.54-1.53.12-3.18 0 0 1.005-.315 3.3 1.23.96-.27 1.98-.405 3-.405s2.04.135 3 .405c2.295-1.56 3.3-1.23 3.3-1.23.66 1.65.24 2.88.12 3.18.765.84 1.23 1.905 1.23 3.225 0 4.605-2.805 5.625-5.475 5.925.435.375.81 1.095.81 2.22 0 1.605-.015 2.895-.015 3.3 0 .315.225.69.825.57A12.02 12.02 0 0024 12c0-6.63-5.37-12-12-12z" />
    </svg>
    GitHub source
      </>}
  </a>;

<GitHubLink compact url="https://github.com/wandb/wandb/blob/main/wandb/sdk/wandb_settings.py#L60" />

## <Badge color="yellow" size="lg" shape="rounded">Class</Badge> wandb.Settings

Settings for the W\&B SDK.

This class manages configuration settings for the W\&B SDK,
ensuring type safety and validation of all settings. Settings are accessible
as attributes and can be initialized programmatically, through environment
variables (`WANDB_ prefix`), and with configuration files.

The settings are organized into three categories:

1. Public settings: Core configuration options that users can safely modify to customize
   W\&B's behavior for their specific needs.
2. Internal settings: Settings prefixed with 'x\_' that handle low-level SDK behavior.
   These settings are primarily for internal use and debugging. While they can be modified,
   they are not considered part of the public API and may change without notice in future
   versions.
3. Computed settings: Read-only settings that are automatically derived from other settings or
   the environment.

Settings are loaded from multiple sources. When the same setting is supplied
by more than one source, the source listed later wins. From lowest to highest
precedence:

1. Default values defined on this `Settings` model.
2. Configuration files (`~/.config/wandb/settings`, or the `settings` file in
   the directory named by the `WANDB_CONFIG_DIR` environment variable).
3. Environment variables (those prefixed with `WANDB_`, e.g. `WANDB_MODE`).
4. Values detected from the runtime environment, such as the hostname, the
   running program/script path, the Python executable, the Docker image, and
   Jupyter notebook details.
5. SageMaker settings, when running in an Amazon SageMaker environment.
6. The `settings` parameter of `wandb.setup()`.
7. The `settings` parameter of `wandb.init()`.
8. Certain `wandb.init()` parameters (for example, `mode=` overrides the
   `mode` setting).

```python theme={null}
*,
allow_media_symlink: bool = False,
allow_offline_artifacts: bool = True,
allow_val_change: bool = False,
anonymous: object = object(),
api_key: str | None = None,
azure_account_url_to_access_key: dict[str, str] | None = None,
app_url_override: str | None = None,
base_url: str = 'https://api.wandb.ai',
code_dir: str | None = None,
config_paths: collections.abc.Sequence[str] | None = None,
console: Literal['auto', 'off', 'wrap', 'redirect', 'wrap_raw', 'wrap_emu'] = 'auto',
console_multipart: bool = False,
console_chunk_max_bytes: int = 0,
console_chunk_max_seconds: int = 0,
capture_loggers: dict[str, str] | None = None,
credentials_file: str = <factory>,
disable_code: bool = False,
disable_git: bool = False,
disable_git_fork_point: bool = True,
disable_job_creation: bool = True,
docker: str | None = None,
email: str | None = None,
entity: str | None = None,
organization: str | None = None,
force: bool = False,
fork_from: wandb.sdk.lib.run_moment.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,
http_proxy: str | None = None,
https_proxy: str | None = None,
identity_token_file: str | None = None,
ignore_globs: collections.abc.Sequence[str] = (),
init_timeout: float = 90.0,
finish_timeout: float = 0.0,
finish_timeout_raises: bool = False,
insecure_disable_ssl: bool = False,
job_name: str | None = None,
job_source: Optional[Literal['repo', 'artifact', 'image']] = None,
label_disable: bool = False,
launch: bool = False,
launch_config_path: str | None = None,
login_timeout: float | None = None,
mode: Literal['online', 'offline', 'shared', 'disabled', 'dryrun', 'run'] = 'online',
notebook_name: str | None = None,
program: str | None = None,
program_abspath: str | None = None,
program_relpath: str | None = None,
project: str | None = None,
quiet: bool = False,
reinit: Union[Literal['default', 'return_previous', 'finish_previous', 'create_new'], bool] = 'default',
relogin: bool = False,
resume: Optional[Literal['allow', 'must', 'never', 'auto']] = None,
resume_from: wandb.sdk.lib.run_moment.RunMoment | None = None,
resumed: bool = False,
root_dir: str = <factory>,
run_group: str | None = None,
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 | None = None,
stop_fn: collections.abc.Callable[[], None] | None = None,
max_end_of_run_history_metrics: int = 10,
max_end_of_run_summary_metrics: int = 10,
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,
stop_on_fatal_error: bool = False,
strict: bool | None = None,
summary_timeout: int = 60,
summary_warnings: int = 5,
sweep_id: str | None = None,
sweep_param_path: str | None = None,
symlink: bool = <factory>,
sync_tensorboard: bool | None = None,
table_raise_on_max_row_limit_exceeded: bool = False,
use_dot_wandb: bool | None = None,
username: str | None = None,
x_cli_only_mode: bool = False,
x_disable_meta: bool = False,
x_disable_stats: bool = False,
x_disable_viewer: bool = False,
x_disable_machine_info: bool = False,
x_executable: str | None = None,
x_extra_http_headers: dict[str, str] | None = None,
x_file_stream_max_bytes: int | None = None,
x_file_stream_max_line_bytes: int | None = None,
x_file_stream_transmit_interval: float | None = None,
x_file_stream_retry_max: int | None = None,
x_file_stream_retry_wait_min_seconds: float | None = None,
x_file_stream_retry_wait_max_seconds: float | None = None,
x_file_stream_timeout_seconds: float | None = None,
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,
x_files_dir: str | None = None,
x_flow_control_custom: bool | None = None,
x_flow_control_disabled: bool | None = None,
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,
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 = 20,
x_network_buffer: int | None = None,
x_primary: bool = True,
x_proxies: dict[str, str] | None = None,
x_runqueue_item_id: str | None = None,
x_save_requirements: bool = True,
x_server_side_derived_summary: bool = False,
x_server_side_expand_glob_metrics: bool = True,
x_service_transport: str | None = None,
x_service_wait: float = 30.0,
x_skip_transaction_log: bool = False,
x_start_time: float | None = None,
x_stats_pid: int = 62075,
x_stats_sampling_interval: float = 15.0,
x_stats_neuron_monitor_config_path: str | None = None,
x_stats_dcgm_exporter: str | None = None,
x_stats_open_metrics_endpoints: dict[str, str] | None = None,
x_stats_open_metrics_filters: dict[str, dict[str, str]] | collections.abc.Sequence[str] | None = None,
x_stats_open_metrics_http_headers: dict[str, str] | None = None,
x_stats_disk_paths: collections.abc.Sequence[str] | None = ('/',),
x_stats_cpu_count: int | None = None,
x_stats_cpu_logical_count: int | None = None,
x_stats_gpu_count: int | None = None,
x_stats_gpu_type: str | None = None,
x_stats_gpu_device_ids: collections.abc.Sequence[int] | None = None,
x_stats_buffer_size: int = 0,
x_stats_coreweave_metadata_base_url: str = 'http://169.254.169.254',
x_stats_coreweave_metadata_endpoint: str = '/api/v2/cloud-init/meta-data',
x_stats_track_process_tree: bool = False,
x_stats_no_cgroup: bool = False,
x_sync: bool = False,
x_sync_dir_suffix: str = '',
x_update_finish_state: bool = True
```

## Args

<ResponseField name="allow_media_symlink" type="bool">
  Whether to symlink media files to the run directory.

  If true, media files will be symlinked or hardlinked to the
  run directory instead of copied. This may result in faster
  logging and reduced disk usage. However, deleting or modifying
  the original files before upload to the W\&B server will be
  reflected in the uploaded data.
</ResponseField>

<ResponseField name="allow_offline_artifacts" type="bool">
  Flag to allow table artifacts to be synced in offline mode.

  To revert to the old behavior, set this to False.
</ResponseField>

<ResponseField name="allow_val_change" type="bool">
  Flag to allow modification of `Config` values after they've been set.
</ResponseField>

<ResponseField name="anonymous" type="object">
  Deprecated and will be removed.
</ResponseField>

<ResponseField name="api_key" type="str | None">
  The W\&B API key.
</ResponseField>

<ResponseField name="azure_account_url_to_access_key" type="dict[str, str] | None">
  Mapping of Azure account URLs to their corresponding access keys for Azure integration.
</ResponseField>

<ResponseField name="app_url_override" type="str | None">
  Override for the 'app' URL for the W\&B UI.

  The `app_url` is normally computed based on `base_url`, but this can be
  used to set it explicitly.

  WANDB\_APP\_URL is the corresponding environment variable.
</ResponseField>

<ResponseField name="base_url" type="str">
  The URL of the W\&B backend for data synchronization.
</ResponseField>

<ResponseField name="code_dir" type="str | None">
  Directory containing the code to be tracked by W\&B.
</ResponseField>

<ResponseField name="config_paths" type="collections.abc.Sequence[str] | None">
  Paths to files to load configuration from into the `Config` object.
</ResponseField>

<ResponseField name="console" type="Literal['auto', 'off', 'wrap', 'redirect', 'wrap_raw', 'wrap_emu']">
  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. Derived from the `wrap` setting and should not be set manually.
  * "wrap\_emu" - Same as "wrap" but captures output through an emulator.
    Derived from the `wrap` setting and should not be set manually.
</ResponseField>

<ResponseField name="console_multipart" type="bool">
  Enable multipart console logging.

  When True, the SDK writes console output to timestamped files
  under the `logs/` directory instead of a single `output.log`.

  Each part is uploaded as soon as it is closed, giving users live
  access to logs while the run is active. Rollover cadence is
  controlled by `console_chunk_max_bytes` and/or `console_chunk_max_seconds`.
  If both limits are `0`, all logs are uploaded once at run finish.

  Note: Uploaded chunks are immutable; terminal control sequences
  that modify previous lines (e.g., progress bars using carriage returns)
  only affect the current chunk.
</ResponseField>

<ResponseField name="console_chunk_max_bytes" type="int">
  Size-based rollover threshold for multipart console logs, in bytes.

  Starts a new console log file when the current part reaches this
  size. Has an effect only when `console_multipart` is `True`.
  Can be combined with `console_chunk_max_seconds`; whichever limit is
  hit first triggers the rollover. A value of `0` disables the
  size-based limit.
</ResponseField>

<ResponseField name="console_chunk_max_seconds" type="int">
  Time-based rollover threshold for multipart console logs, in seconds.

  Starts a new console log file after this many seconds have elapsed
  since the current part began. Requires `console_multipart` to be
  `True`.  May be used with `console_chunk_max_bytes`; the first limit
  reached closes the part. A value of `0` disables the time-based
  limit.
</ResponseField>

<ResponseField name="capture_loggers" type="dict[str, str] | None">
  Names of Python loggers to capture into the run's Logs tab.

  A mapping of logger name to minimum log level. When set, wandb installs a
  logging.Handler on each named logger and removes it when the run finishes.
  Log records emitted by those loggers are published as console output to the
  run, similar to stdout/stderr capture.

  Log records are formatted the same as `logging.basicConfig()`, like
  `INFO:my_module:Some message.` This is not currently customizable.

  To capture all logs, pass the name of the root logger, which is 'root'.

  This is independent of the `console` setting: both can be active
  simultaneously.

  Example:

  ```python theme={null}
  wandb.init(
      settings=wandb.Settings(
          console="off",
          capture_loggers={
              "my_app": "INFO",
              "my_app.training": "ERROR",
          },
      ),
  )
  ```
</ResponseField>

<ResponseField name="credentials_file" type="str">
  Path to file for writing temporary access tokens.
</ResponseField>

<ResponseField name="disable_code" type="bool">
  Whether to disable capturing the code.
</ResponseField>

<ResponseField name="disable_git" type="bool">
  Whether to disable capturing the git state.
</ResponseField>

<ResponseField name="disable_git_fork_point" type="bool">
  Whether to disable inferring fork point from remote branches

  When set to True, the SDK will use the latest commit from the upstream
  branch, if one is set. Otherwise skip generating the diff patch.

  When set to False, the SDK will try to use the latest commit from the upstream branch,
  if one is set.
  Otherwise, it will find the closest commit from all remote branches.
  This may impact performance for repos with many upstream branches.
</ResponseField>

<ResponseField name="disable_job_creation" type="bool">
  Whether to disable the creation of a job artifact for W\&B Launch.
</ResponseField>

<ResponseField name="docker" type="str | None">
  The Docker image used to execute the script.
</ResponseField>

<ResponseField name="email" type="str | None">
  The email address of the user.
</ResponseField>

<ResponseField name="entity" type="str | None">
  The W\&B entity, such as a user or a team.
</ResponseField>

<ResponseField name="organization" type="str | None">
  The W\&B organization.
</ResponseField>

<ResponseField name="force" type="bool">
  Whether to pass the `force` flag to `wandb.login()`.
</ResponseField>

<ResponseField name="fork_from" type="wandb.sdk.lib.run_moment.RunMoment | None">
  Specifies a point in a previous execution of a run to fork from.

  The point is defined by the run ID, a metric, and its value.
  Currently, only the metric '\_step' is supported.
</ResponseField>

<ResponseField name="git_commit" type="str | None">
  The git commit hash to associate with the run.
</ResponseField>

<ResponseField name="git_remote" type="str">
  The git remote to associate with the run.
</ResponseField>

<ResponseField name="git_remote_url" type="str | None">
  The URL of the git remote repository.
</ResponseField>

<ResponseField name="git_root" type="str | None">
  Root directory of the git repository.
</ResponseField>

<ResponseField name="host" type="str | None">
  Hostname of the machine running the script.
</ResponseField>

<ResponseField name="http_proxy" type="str | None">
  Custom proxy servers for http requests to W\&B.
</ResponseField>

<ResponseField name="https_proxy" type="str | None">
  Custom proxy servers for https requests to W\&B.
</ResponseField>

<ResponseField name="identity_token_file" type="str | None">
  Path to file containing an identity token (JWT) for authentication.
</ResponseField>

<ResponseField name="ignore_globs" type="collections.abc.Sequence[str]">
  Unix glob patterns relative to `files_dir` specifying files to exclude from upload.
</ResponseField>

<ResponseField name="init_timeout" type="float">
  Time in seconds to wait for the `wandb.init` call to complete before timing out.
</ResponseField>

<ResponseField name="finish_timeout" type="float">
  Time in seconds to wait for data to upload at the end of a run.

  Setting this can limit costs caused by slow uploads to W\&B at the end of a
  run, with the trade-off that the run will be marked crashed and may be
  missing some data. The default is for `run.finish()` to block until all
  data finishes uploading.

  If this is set to a number greater than zero, W\&B gives up on uploading a
  run's data after this many seconds at the end of a run, unblocking your
  script. After some time, the run becomes Crashed or Failed in the UI. Any
  unuploaded data is still stored on disk and can be uploaded with `wandb
    sync`.

  Use the `finish_timeout_raises` setting to raise an error in addition to
  printing a warning message.

  Runs shut down by `wandb.teardown()` (which automatically runs at the end
  of a script in an atexit hook) will also respect this setting.
</ResponseField>

<ResponseField name="finish_timeout_raises" type="bool">
  Whether to raise a TimeoutError if finish\_timeout expires.

  Using this together with the `finish_timeout` setting causes `run.finish()`
  to raise a TimeoutError after a timeout in addition to printing a message.

  Note that `run.finish()` is called implicitly when using a Run as a context
  manager:

  with wandb.init() as run:
  ...  # run.finish() executes at the end of the `with` block

  This does not cause `wandb.teardown()` to raise an error (since it runs
  at the end of a script anyway).
</ResponseField>

<ResponseField name="insecure_disable_ssl" type="bool">
  Whether to insecurely disable SSL verification.
</ResponseField>

<ResponseField name="job_name" type="str | None">
  Name of the Launch job running the script.
</ResponseField>

<ResponseField name="job_source" type="Optional[Literal['repo', 'artifact', 'image']]">
  Source type for Launch.
</ResponseField>

<ResponseField name="label_disable" type="bool">
  Whether to disable automatic labeling features.
</ResponseField>

<ResponseField name="launch_config_path" type="str | None">
  Path to the launch configuration file.
</ResponseField>

<ResponseField name="login_timeout" type="float | None">
  Time in seconds to wait for login operations before timing out.
</ResponseField>

<ResponseField name="mode" type="Literal['online', 'offline', 'shared', 'disabled', 'dryrun', 'run']">
  The operating mode for W\&B logging and synchronization.
</ResponseField>

<ResponseField name="notebook_name" type="str | None">
  Name of the notebook if running in a Jupyter-like environment.
</ResponseField>

<ResponseField name="program" type="str | None">
  Path to the script that created the run, if available.
</ResponseField>

<ResponseField name="program_abspath" type="str | 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.
</ResponseField>

<ResponseField name="program_relpath" type="str | None">
  The relative path to the script that created the run.
</ResponseField>

<ResponseField name="project" type="str | None">
  The W\&B project ID.
</ResponseField>

<ResponseField name="quiet" type="bool">
  Flag to suppress non-essential output.
</ResponseField>

<ResponseField name="reinit" type="Union[Literal['default', 'return_previous', 'finish_previous', 'create_new'], bool]">
  What to do when `wandb.init()` is called while a run is active.

  Options:

  * "default": Use "finish\_previous" in notebooks and "return\_previous"
    otherwise.
  * "return\_previous": Return the most recently created run
    that is not yet finished. This does not update `wandb.run`; see
    the "create\_new" option.
  * "finish\_previous": Finish all active runs, then return a new run.
  * "create\_new": Create a new run without modifying other active runs.
    Does not update `wandb.run` and top-level functions like `wandb.log`.
    Because of this, some older integrations that rely on the global run
    will not work.

  Can also be a boolean, but this is deprecated. False is the same as
  "return\_previous", and True is the same as "finish\_previous".
</ResponseField>

<ResponseField name="relogin" type="bool">
  Flag to force a new login attempt.
</ResponseField>

<ResponseField name="resume" type="Optional[Literal['allow', 'must', 'never', 'auto']]">
  Specifies the resume behavior for the run.

  Options:

  * "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.
</ResponseField>

<ResponseField name="resume_from" type="wandb.sdk.lib.run_moment.RunMoment | None">
  Specifies a point in a previous execution of a run to resume from.

  The point is defined by the run ID, a metric, and its value.
  Currently, only the metric '\_step' is supported.
</ResponseField>

<ResponseField name="root_dir" type="str">
  The root directory to use as the base for all run-related paths.

  In particular, this is used to derive the wandb directory and the run directory.
</ResponseField>

<ResponseField name="run_group" type="str | None">
  Group identifier for related runs.

  Used for grouping runs in the UI.
</ResponseField>

<ResponseField name="run_id" type="str | None">
  The ID of the run.
</ResponseField>

<ResponseField name="run_job_type" type="str | None">
  Type of job being run (e.g., training, evaluation).
</ResponseField>

<ResponseField name="run_name" type="str | None">
  Human-readable name for the run.
</ResponseField>

<ResponseField name="run_notes" type="str | None">
  Additional notes or description for the run.
</ResponseField>

<ResponseField name="run_tags" type="tuple[str, ...] | None">
  Tags to associate with the run for organization and filtering.
</ResponseField>

<ResponseField name="sagemaker_disable" type="bool">
  Flag to disable SageMaker-specific functionality.
</ResponseField>

<ResponseField name="save_code" type="bool | None">
  Whether to save the code associated with the run.
</ResponseField>

<ResponseField name="settings_system" type="str | None">
  Path to the system-wide settings file.
</ResponseField>

<ResponseField name="stop_fn" type="collections.abc.Callable[[], None] | None">
  A callback to execute to stop the run.

  A run can be stopped through the web UI, or after a fatal error
  (if configured via a setting).

  By default, to stop a run, W\&B sends a SIGINT to the main thread.
  Set this callback to override this behavior, like to use a different
  signal or to take some other action before interrupting.

  The callback runs in a separate thread. It runs soon after a stop is
  requested, but not immediately.
</ResponseField>

<ResponseField name="max_end_of_run_history_metrics" type="int">
  Maximum number of history sparklines to display at the end of a run.
</ResponseField>

<ResponseField name="max_end_of_run_summary_metrics" type="int">
  Maximum number of summary metrics to display at the end of a run.
</ResponseField>

<ResponseField name="show_errors" type="bool">
  Whether to display error messages.
</ResponseField>

<ResponseField name="show_info" type="bool">
  Whether to display informational messages.
</ResponseField>

<ResponseField name="show_warnings" type="bool">
  Whether to display warning messages.
</ResponseField>

<ResponseField name="silent" type="bool">
  Flag to suppress all output.
</ResponseField>

<ResponseField name="stop_on_fatal_error" type="bool">
  Whether to stop the run after a fatal error.

  After W\&B hits an unrecoverable error while uploading data, it prints
  a message and stops uploading, but still allows logging more data.
  This is usually desirable: your training metrics get stored on disk
  and can be recovered using `wandb sync`, even if they aren't uploaded.

  This is not useful if your files get deleted after training.
  In that case, setting this to True will stop the run after a fatal error,
  as if the stop button was pressed in the web UI.
</ResponseField>

<ResponseField name="strict" type="bool | None">
  Whether to enable strict mode for validation and error checking.
</ResponseField>

<ResponseField name="summary_timeout" type="int">
  Time in seconds to wait for summary operations before timing out.
</ResponseField>

<ResponseField name="sweep_id" type="str | None">
  Identifier of the sweep this run belongs to.
</ResponseField>

<ResponseField name="sweep_param_path" type="str | None">
  Path to the sweep parameters configuration.
</ResponseField>

<ResponseField name="symlink" type="bool">
  Whether to use symlinks (True by default except on Windows).
</ResponseField>

<ResponseField name="sync_tensorboard" type="bool | None">
  Whether to synchronize TensorBoard logs with W\&B.
</ResponseField>

<ResponseField name="table_raise_on_max_row_limit_exceeded" type="bool">
  Whether to raise an exception when table row limits are exceeded.
</ResponseField>

<ResponseField name="use_dot_wandb" type="bool | None">
  Whether to use a hidden `.wandb` or visible `wandb` directory for run data.

  If True, the SDK uses `.wandb`. If False, `wandb`.
  If not set, defaults to `.wandb` if it already exists, otherwise `wandb`.
</ResponseField>

<ResponseField name="username" type="str | None">
  Username.
</ResponseField>

<ResponseField name="x_disable_meta" type="bool">
  Flag to disable the collection of system metadata.
</ResponseField>

<ResponseField name="x_disable_stats" type="bool">
  Flag to disable the collection of system metrics.
</ResponseField>

<ResponseField name="x_extra_http_headers" type="dict[str, str] | None">
  Additional headers to add to all outgoing HTTP requests.
</ResponseField>

<ResponseField name="x_label" type="str | None">
  Label to assign to system metrics and console logs collected for the run.

  This is used to group data by on the frontend and can be used to distinguish data
  from different processes in a distributed training job.
</ResponseField>

<ResponseField name="x_primary" type="bool">
  Determines whether to save internal wandb files and metadata.

  In a distributed setting, this is useful for avoiding file overwrites
  from secondary processes when only system metrics and logs are needed,
  as the primary process handles the main logging.
</ResponseField>

<ResponseField name="x_save_requirements" type="bool">
  Flag to save the requirements file.
</ResponseField>

<ResponseField name="x_server_side_derived_summary" type="bool">
  Flag to delegate automatic computation of summary from history to the server.

  This does not disable user-provided summary updates.
</ResponseField>

<ResponseField name="x_service_wait" type="float">
  Time in seconds to wait for the wandb-core internal service to start.
</ResponseField>

<ResponseField name="x_skip_transaction_log" type="bool">
  Whether to skip saving the run events to the transaction log.

  This is only relevant for online runs. Can be used to reduce the amount of
  data written to disk.

  Should be used with caution, as it removes the gurantees about
  recoverability.
</ResponseField>

<ResponseField name="x_stats_sampling_interval" type="float">
  Sampling interval for the system monitor in seconds.
</ResponseField>

<ResponseField name="x_stats_open_metrics_endpoints" type="dict[str, str] | None">
  OpenMetrics `/metrics` endpoints to monitor for system metrics.
</ResponseField>

<ResponseField name="x_stats_open_metrics_filters" type="dict[str, dict[str, str]] | collections.abc.Sequence[str] | None">
  Filter to apply to metrics collected from OpenMetrics `/metrics` 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", ...)`
</ResponseField>

<ResponseField name="x_stats_open_metrics_http_headers" type="dict[str, str] | None">
  HTTP headers to add to OpenMetrics requests.
</ResponseField>

<ResponseField name="x_stats_disk_paths" type="collections.abc.Sequence[str] | None">
  System paths to monitor for disk usage.
</ResponseField>

<ResponseField name="x_stats_cpu_count" type="int | None">
  System CPU count.

  If set, overrides the auto-detected value in the run metadata.
</ResponseField>

<ResponseField name="x_stats_cpu_logical_count" type="int | None">
  Logical CPU count.

  If set, overrides the auto-detected value in the run metadata.
</ResponseField>

<ResponseField name="x_stats_gpu_count" type="int | None">
  GPU device count.

  If set, overrides the auto-detected value in the run metadata.
</ResponseField>

<ResponseField name="x_stats_gpu_type" type="str | None">
  GPU device type.

  If set, overrides the auto-detected value in the run metadata.
</ResponseField>

<ResponseField name="x_stats_gpu_device_ids" type="collections.abc.Sequence[int] | None">
  GPU device indices to monitor.

  If not set, the system monitor captures metrics for all GPUs.
  Assumes 0-based indexing matching CUDA/ROCm device enumeration.
</ResponseField>

<ResponseField name="x_stats_track_process_tree" type="bool">
  Monitor the entire process tree for resource usage, starting from `x_stats_pid`.

  When `True`, the system monitor aggregates the RSS, CPU%, and thread count
  from the process with PID `x_stats_pid` and all of its descendants.
  This can have a performance overhead and is disabled by default.
</ResponseField>

<ResponseField name="x_stats_no_cgroup" type="bool">
  Disable cgroup v2 CPU and memory limits for system metric percentages.
</ResponseField>

<ResponseField name="x_sync_dir_suffix" type="str">
  Suffix to add to the run's directory name (sync\_dir).

  This is set in wandb.init() to avoid naming conflicts.
  If set, it is joined to the default name with a dash.
</ResponseField>

<ResponseField name="x_update_finish_state" type="bool">
  Flag to indicate whether this process can update the run's final state on the server.

  Set to False in distributed training when only the main process should determine the final state.
</ResponseField>