Upgrading wandb 0.24 to 0.25

Breaking0.24.2 → 0.25.1Platform2New9Changed1Fixed5

Full comparison Back to wandb

BreakingUpgrade verdict

2 platform requirement changes.

In plain terms

This version no longer works on Python 3.8; you need a newer Python version.
Python 3.8 is no longer supported; upgrade to a newer Python version.

Must act 2 items need code or config changes

Python requirement changed in 0.25.0: >=3.8 → >=3.9.

What you must change

Platform2

Drops support for Python 3.8.

0.25.0GitHub ReleaseSummarizedView source

Removes support for Python 3.8.

0.25.0GitHub ReleaseSummarizedView source

API changes

Generated by DepDelta from published Python source. Not mixed with prose notes.

changed: function agent(sweep_id: str, function: Optional[Callable]=…, entity: Optional[str]=…, project: Optional[str]=…, count: Optional[int]=…, forward_signals: bool=…) -> None → function agent(sweep_id: str, function: Callable | None=…, entity: str | None=…, project: str | None=…, count: int | None=…, forward_signals: bool=…) -> None
changed: function controller(sweep_id_or_config: Optional[Union[str, Dict]]=…, entity: Optional[str]=…, project: Optional[str]=…) -> _WandbController → function controller(sweep_id_or_config: str | dict | None=…, entity: str | None=…, project: str | None=…) -> _WandbController
changed: function sweep(sweep: Union[dict, Callable], entity: Optional[str]=…, project: Optional[str]=…, prior_runs: Optional[List[str]]=…) -> str → function sweep(sweep: dict | Callable, entity: str | None=…, project: str | None=…, prior_runs: list[str] | None=…) -> str

changed: function send_run(run: ImporterRun, *, extra_arts: Optional[Iterable[Artifact]]=…, extra_used_arts: Optional[Iterable[Artifact]]=…, config: Optional[SendManagerConfig]=…, overrides: Optional[Dict[str, Any]]=…, settings_override: Optional[Dict[str, Any]]=…) -> None → function send_run(run: ImporterRun, *, extra_arts: Iterable[Artifact] | None=…, extra_used_arts: Iterable[Artifact] | None=…, config: SendManagerConfig | None=…, overrides: dict[str, Any] | None=…, settings_override: dict[str, Any] | None=…) -> None
changed: method RecordMaker.make_artifacts_only_records(artifacts: Optional[Iterable[Artifact]]=…, used_artifacts: Optional[Iterable[Artifact]]=…) -> Iterable[pb.Record] → method RecordMaker.make_artifacts_only_records(artifacts: Iterable[Artifact] | None=…, used_artifacts: Iterable[Artifact] | None=…) -> Iterable[pb.Record]

changed: method ImporterRun.artifacts() -> Optional[Iterable[Artifact]] → method ImporterRun.artifacts() -> Iterable[Artifact] | None
changed: method ImporterRun.cli_version() -> Optional[str] → method ImporterRun.cli_version() -> str | None
changed: method ImporterRun.code_path() -> Optional[str] → method ImporterRun.code_path() -> str | None
changed: method ImporterRun.config() -> Dict[str, Any] → method ImporterRun.config() -> dict[str, Any]
changed: method ImporterRun.cpus_used() -> Optional[int] → method ImporterRun.cpus_used() -> int | None
changed: method ImporterRun.cuda_version() -> Optional[str] → method ImporterRun.cuda_version() -> str | None
changed: method ImporterRun.executable() -> Optional[str] → method ImporterRun.executable() -> str | None
changed: method ImporterRun.files() -> Optional[Iterable[Tuple[PathStr, Policy]]] → method ImporterRun.files() -> Iterable[tuple[PathStr, Policy]] | None
changed: method ImporterRun.gpus_used() -> Optional[str] → method ImporterRun.gpus_used() -> str | None
changed: method ImporterRun.host() -> Optional[str] → method ImporterRun.host() -> str | None
changed: method ImporterRun.job_type() -> Optional[str] → method ImporterRun.job_type() -> str | None
changed: method ImporterRun.logs() -> Optional[Iterable[str]] → method ImporterRun.logs() -> Iterable[str] | None
changed: method ImporterRun.memory_used() -> Optional[int] → method ImporterRun.memory_used() -> int | None
changed: method ImporterRun.metrics() -> Iterable[Dict[str, float]] → method ImporterRun.metrics() -> Iterable[dict[str, float]]
changed: method ImporterRun.notes() -> Optional[str] → method ImporterRun.notes() -> str | None
changed: method ImporterRun.os_version() -> Optional[str] → method ImporterRun.os_version() -> str | None
changed: method ImporterRun.program() -> Optional[str] → method ImporterRun.program() -> str | None
changed: method ImporterRun.python_version() -> Optional[str] → method ImporterRun.python_version() -> str | None
changed: method ImporterRun.run_group() -> Optional[str] → method ImporterRun.run_group() -> str | None
changed: method ImporterRun.runtime() -> Optional[int] → method ImporterRun.runtime() -> int | None
changed: method ImporterRun.start_time() -> Optional[int] → method ImporterRun.start_time() -> int | None
changed: method ImporterRun.summary() -> Dict[str, float] → method ImporterRun.summary() -> dict[str, float]
changed: method ImporterRun.tags() -> Optional[List[str]] → method ImporterRun.tags() -> list[str] | None
changed: method ImporterRun.used_artifacts() -> Optional[Iterable[Artifact]] → method ImporterRun.used_artifacts() -> Iterable[Artifact] | None
changed: method ImporterRun.username() -> Optional[str] → method ImporterRun.username() -> str | None

changed: function for_each(func, iterable: Iterable, parallel: bool=…, max_workers: Optional[int]=…) → function for_each(func, iterable: Iterable, parallel: bool=…, max_workers: int | None=…)
changed: function parallelize(func, iterable: Iterable, *args, max_workers: Optional[int]=…, raise_on_error: bool=…, **kwargs) → function parallelize(func, iterable: Iterable, *args, max_workers: int | None=…, raise_on_error: bool=…, **kwargs)

changed: constructor MlflowImporter(dst_base_url: str, dst_api_key: str, mlflow_tracking_uri: str, mlflow_registry_uri: Optional[str]=…, *, custom_api_kwargs: Optional[Dict[str, Any]]=…) -> None → constructor MlflowImporter(dst_base_url: str, dst_api_key: str, mlflow_tracking_uri: str, mlflow_registry_uri: str | None=…, *, custom_api_kwargs: dict[str, Any] | None=…) -> None
changed: method MlflowImporter.collect_runs(*, limit: Optional[int]=…) -> Iterable[MlflowRun] → method MlflowImporter.collect_runs(*, limit: int | None=…) -> Iterable[MlflowRun]
changed: method MlflowImporter.import_runs(runs: Iterable[MlflowRun], *, artifacts: bool=…, namespace: Optional[Namespace]=…, parallel: bool=…, max_workers: Optional[int]=…) -> None → method MlflowImporter.import_runs(runs: Iterable[MlflowRun], *, artifacts: bool=…, namespace: Namespace | None=…, parallel: bool=…, max_workers: int | None=…) -> None
changed: method MlflowRun.artifacts() -> Optional[Iterable[Artifact]] → method MlflowRun.artifacts() -> Iterable[Artifact] | None
changed: method MlflowRun.cli_version() -> Optional[str] → method MlflowRun.cli_version() -> str | None
changed: method MlflowRun.code_path() -> Optional[str] → method MlflowRun.code_path() -> str | None
changed: method MlflowRun.config() -> Dict[str, Any] → method MlflowRun.config() -> dict[str, Any]
changed: method MlflowRun.cpus_used() -> Optional[int] → method MlflowRun.cpus_used() -> int | None
changed: method MlflowRun.cuda_version() -> Optional[str] → method MlflowRun.cuda_version() -> str | None
changed: method MlflowRun.executable() -> Optional[str] → method MlflowRun.executable() -> str | None
changed: method MlflowRun.files() -> Optional[Iterable[Tuple[str, str]]] → method MlflowRun.files() -> Iterable[tuple[str, str]] | None
changed: method MlflowRun.gpus_used() -> Optional[str] → method MlflowRun.gpus_used() -> str | None
changed: method MlflowRun.host() -> Optional[str] → method MlflowRun.host() -> str | None
changed: method MlflowRun.job_type() -> Optional[str] → method MlflowRun.job_type() -> str | None
changed: method MlflowRun.logs() -> Optional[Iterable[str]] → method MlflowRun.logs() -> Iterable[str] | None
changed: method MlflowRun.memory_used() -> Optional[int] → method MlflowRun.memory_used() -> int | None
changed: method MlflowRun.metrics() -> Iterable[Dict[str, float]] → method MlflowRun.metrics() -> Iterable[dict[str, float]]
changed: method MlflowRun.notes() -> Optional[str] → method MlflowRun.notes() -> str | None
changed: method MlflowRun.os_version() -> Optional[str] → method MlflowRun.os_version() -> str | None
changed: method MlflowRun.program() -> Optional[str] → method MlflowRun.program() -> str | None
changed: method MlflowRun.python_version() -> Optional[str] → method MlflowRun.python_version() -> str | None
changed: method MlflowRun.run_group() -> Optional[str] → method MlflowRun.run_group() -> str | None
changed: method MlflowRun.runtime() -> Optional[int] → method MlflowRun.runtime() -> int | None
changed: method MlflowRun.start_time() -> Optional[int] → method MlflowRun.start_time() -> int | None
changed: method MlflowRun.summary() -> Dict[str, float] → method MlflowRun.summary() -> dict[str, float]
changed: method MlflowRun.tags() -> Optional[List[str]] → method MlflowRun.tags() -> list[str] | None
changed: method MlflowRun.used_artifacts() -> Optional[Iterable[Artifact]] → method MlflowRun.used_artifacts() -> Iterable[Artifact] | None
changed: method MlflowRun.username() -> Optional[str] → method MlflowRun.username() -> str | None

changed: constructor WandbImporter(src_base_url: str, src_api_key: str, dst_base_url: str, dst_api_key: str, *, custom_api_kwargs: Optional[Dict[str, Any]]=…) -> None → constructor WandbImporter(src_base_url: str, src_api_key: str, dst_base_url: str, dst_api_key: str, *, custom_api_kwargs: dict[str, Any] | None=…) -> None
changed: method WandbImporter.import_all(*, runs: bool=…, artifacts: bool=…, reports: bool=…, namespaces: Optional[Iterable[Namespace]]=…, incremental: bool=…, remapping: Optional[Dict[Namespace, Namespace]]=…) → method WandbImporter.import_all(*, runs: bool=…, artifacts: bool=…, reports: bool=…, namespaces: Iterable[Namespace] | None=…, incremental: bool=…, remapping: dict[Namespace, Namespace] | None=…)
changed: method WandbImporter.import_artifact_sequences(*, namespaces: Optional[Iterable[Namespace]]=…, incremental: bool=…, max_workers: Optional[int]=…, remapping: Optional[Dict[Namespace, Namespace]]=…) → method WandbImporter.import_artifact_sequences(*, namespaces: Iterable[Namespace] | None=…, incremental: bool=…, max_workers: int | None=…, remapping: dict[Namespace, Namespace] | None=…)
changed: method WandbImporter.import_reports(*, namespaces: Optional[Iterable[Namespace]]=…, limit: Optional[int]=…, remapping: Optional[Dict[Namespace, Namespace]]=…) → method WandbImporter.import_reports(*, namespaces: Iterable[Namespace] | None=…, limit: int | None=…, remapping: dict[Namespace, Namespace] | None=…)
changed: method WandbImporter.import_runs(*, namespaces: Optional[Iterable[Namespace]]=…, remapping: Optional[Dict[Namespace, Namespace]]=…, parallel: bool=…, incremental: bool=…, max_workers: Optional[int]=…, limit: Optional[int]=…, metadata: bool=…, files: bool=…, media: bool=…, code: bool=…, history: bool=…, summary: bool=…, terminal_output: bool=…) → method WandbImporter.import_runs(*, namespaces: Iterable[Namespace] | None=…, remapping: dict[Namespace, Namespace] | None=…, parallel: bool=…, incremental: bool=…, max_workers: int | None=…, limit: int | None=…, metadata: bool=…, files: bool=…, media: bool=…, code: bool=…, history: bool=…, summary: bool=…, terminal_output: bool=…)
changed: method WandbRun.artifacts() -> Optional[Iterable[Artifact]] → method WandbRun.artifacts() -> Iterable[Artifact] | None
changed: method WandbRun.cli_version() -> Optional[str] → method WandbRun.cli_version() -> str | None
changed: method WandbRun.code_path() -> Optional[str] → method WandbRun.code_path() -> str | None
changed: method WandbRun.config() -> Dict[str, Any] → method WandbRun.config() -> dict[str, Any]
changed: method WandbRun.cpus_used() -> Optional[int] → method WandbRun.cpus_used() -> int | None
changed: method WandbRun.cuda_version() -> Optional[str] → method WandbRun.cuda_version() -> str | None
changed: method WandbRun.executable() -> Optional[str] → method WandbRun.executable() -> str | None
changed: method WandbRun.files() -> Optional[Iterable[Tuple[PathStr, Policy]]] → method WandbRun.files() -> Iterable[tuple[PathStr, Policy]] | None
changed: method WandbRun.gpus_used() -> Optional[str] → method WandbRun.gpus_used() -> str | None
changed: method WandbRun.host() -> Optional[str] → method WandbRun.host() -> str | None
changed: method WandbRun.job_type() -> Optional[str] → method WandbRun.job_type() -> str | None
changed: method WandbRun.logs() -> Optional[Iterable[str]] → method WandbRun.logs() -> Iterable[str] | None
changed: method WandbRun.memory_used() -> Optional[int] → method WandbRun.memory_used() -> int | None
changed: method WandbRun.metrics() -> Iterable[Dict[str, float]] → method WandbRun.metrics() -> Iterable[dict[str, float]]
changed: method WandbRun.notes() -> Optional[str] → method WandbRun.notes() -> str | None
changed: method WandbRun.os_version() -> Optional[str] → method WandbRun.os_version() -> str | None
changed: method WandbRun.program() -> Optional[str] → method WandbRun.program() -> str | None
changed: method WandbRun.python_version() -> Optional[str] → method WandbRun.python_version() -> str | None
changed: method WandbRun.run_group() -> Optional[str] → method WandbRun.run_group() -> str | None
changed: method WandbRun.runtime() -> Optional[int] → method WandbRun.runtime() -> int | None
changed: method WandbRun.start_time() -> Optional[int] → method WandbRun.start_time() -> int | None
changed: method WandbRun.summary() -> Dict[str, float] → method WandbRun.summary() -> dict[str, float]
changed: method WandbRun.tags() -> Optional[List[str]] → method WandbRun.tags() -> list[str] | None
changed: method WandbRun.used_artifacts() -> Optional[Iterable[Artifact]] → method WandbRun.used_artifacts() -> Iterable[Artifact] | None
changed: method WandbRun.username() -> Optional[str] → method WandbRun.username() -> str | None

added: export ProjectArtifactCollections

changed: constructor ArtifactCollections(client: RetryingClient, entity: str, project: str, type_name: str, per_page: int=…) → constructor ArtifactCollections(client: RetryingClient, entity: str, project: str, type_name: str, filters: Mapping[str, Any] | None=…, order: str | None=…, per_page: int=…)
changed: method ArtifactType.collections(per_page: int=…) -> ArtifactCollections → method ArtifactType.collections(filters: Mapping[str, Any] | None=…, order: str | None=…, per_page: int=…) -> ArtifactCollections
added: class ProjectArtifactCollections(SizedRelayPaginator['ArtifactCollectionFragment', 'ArtifactCollection'])
added: constructor ProjectArtifactCollections(client: RetryingClient, entity: str, project: str, filters: Mapping[str, Any] | None=…, order: str | None=…, per_page: int=…)
added: field ProjectArtifactCollections.QUERY: ClassVar[Document | None]
added: field ProjectArtifactCollections.last_response: ArtifactCollectionConnection | None
added: property ArtifactCollection.updated_at -> str | None

changed: constructor BetaHistoryScan(api: Api, run: runs.Run, min_step: int, max_step: int, keys: list[str] | None=…, page_size: int=…, use_cache: bool=…) → constructor BetaHistoryScan(service_api: ServiceApi, run: runs.Run, min_step: int, max_step: int, keys: list[str] | None=…, page_size: int=…, use_cache: bool=…)
changed: static method BetaHistoryScan.cleanup(api: Api, request_id: int) -> None → static method BetaHistoryScan.cleanup(service_api: ServiceApi, request_id: int) -> None

added: method Project.collections(filters: Mapping[str, Any] | None=…, order: str | None=…, per_page: int=…) -> public.ProjectArtifactCollections
added: property Project.owner -> public.User

added: export DownloadHistoryResult
added: export IncompleteRunHistoryError
added: export wait_for_download_with_progress

added: async function wait_for_download_with_progress(service_api: ServiceApi, request_id: int, contains_live_data: bool) -> DownloadHistoryResult
added: class DownloadHistoryResult
added: class IncompleteRunHistoryError(Exception)
added: field DownloadHistoryResult.contains_live_data: bool
added: field DownloadHistoryResult.errors: dict[pathlib.Path, str] | None
added: field DownloadHistoryResult.paths: list[pathlib.Path]

removed: class DownloadHistoryResult
removed: class IncompleteRunHistoryError(Exception)
removed: field DownloadHistoryResult.contains_live_data: bool
removed: field DownloadHistoryResult.errors: dict[pathlib.Path, str] | None
removed: field DownloadHistoryResult.paths: list[pathlib.Path]
changed: constructor Run(client: RetryingClient, entity: str, project: str, run_id: str, attrs: Mapping | None=…, include_sweeps: bool=…, lazy: bool=…, api: public.Api | None=…) → constructor Run(client: RetryingClient, entity: str, project: str, run_id: str, attrs: Mapping | None=…, include_sweeps: bool=…, lazy: bool=…, service_api: ServiceApi | None=…)
changed: constructor Runs(client: RetryingClient, entity: str, project: str, filters: dict[str, Any] | None=…, order: str=…, per_page: int=…, include_sweeps: bool=…, lazy: bool=…, api: public.Api | None=…) → constructor Runs(client: RetryingClient, entity: str, project: str, filters: dict[str, Any] | None=…, order: str=…, per_page: int=…, include_sweeps: bool=…, lazy: bool=…, service_api: ServiceApi | None=…)
changed: method Run.download_history_exports(download_dir: pathlib.Path | str, require_complete_history: bool=…) -> DownloadHistoryResult → method Run.download_history_exports(download_dir: pathlib.Path | str, require_complete_history: bool=…) -> runhistory.DownloadHistoryResult

added: async method ServiceApi.send_api_request_async(request: ApiRequest) -> MailboxHandle[ApiResponse]
added: class ServiceApi
added: constructor ServiceApi(settings: wandb_settings.Settings)
added: method ServiceApi.send_api_request(request: ApiRequest, timeout: float | None=…) -> ApiResponse

changed: function beta() → function beta() -> None
changed: function leet(path: str | None=…, pprof: str=…) -> None → function leet(ctx: click.Context) -> None
added: class DefaultCommandGroup(click.Group)
added: constructor DefaultCommandGroup(*args: Any, default_cmd: str=…, **kwargs: Any) -> None
added: function config() -> None
added: function run(path: str | None=…, pprof: str=…) -> None
added: method DefaultCommandGroup.format_usage(ctx: click.Context, formatter: click.HelpFormatter) -> None
added: method DefaultCommandGroup.parse_args(ctx: click.Context, args: list[str]) -> list[str]

added: class LaunchConfig
added: field LaunchConfig.run_file: str | None
added: field LaunchConfig.wandb_dir: str
added: function launch_config() -> Never

changed: function parse_service_config(ctx: Optional[click.Context], param: Optional[click.Parameter], value: Optional[Tuple[str, ...]]) -> Dict[str, str] → function parse_service_config(ctx: click.Context | None, param: click.Parameter | None, value: tuple[str, ...] | None) -> dict[str, str]
added: function purge_cache(age: str, force: bool)

changed: function build(tags: List[str], file: str, context_path: str, platform: Optional[str]=…) -> str → function build(tags: list[str], file: str, context_path: str, platform: str | None=…) -> str
changed: function image_id(image_name: str) -> Optional[str] → function image_id(image_name: str) -> str | None
changed: function image_id_from_registry(image_name: str) -> Optional[str] → function image_id_from_registry(image_name: str) -> str | None
changed: function login(username: str, password: str, registry: str) -> Optional[str] → function login(username: str, password: str, registry: str) -> str | None
changed: function parse(image_name: str) -> Tuple[str, str, str] → function parse(image_name: str) -> tuple[str, str, str]
changed: function parse_repository_tag(repo_name: str) -> Tuple[str, Optional[str]] → function parse_repository_tag(repo_name: str) -> tuple[str, str | None]
changed: function push(image: str, tag: str) -> Optional[str] → function push(image: str, tag: str) -> str | None
changed: function run(args: List[Any], capture_stdout: bool=…, capture_stderr: bool=…, input: Optional[bytes]=…, return_stderr: bool=…, env: Optional[Dict[str, str]]=…) -> Union[str, Tuple[str, str]] → function run(args: list[Any], capture_stdout: bool=…, capture_stderr: bool=…, input: bytes | None=…, return_stderr: bool=…, env: dict[str, str] | None=…) -> str | tuple[str, str]
changed: function shell(cmd: List[str]) -> Optional[str] → function shell(cmd: list[str]) -> str | None
changed: function tag(image_name: str, tag: str) -> Optional[str] → function tag(image_name: str, tag: str) -> str | None

changed: static method ProtobufErrorHandler.to_exception(error: pb.ErrorInfo) -> Optional[Error] → static method ProtobufErrorHandler.to_exception(error: pb.ErrorInfo) -> Error | None

removed: property DirWatcher.emitter -> Optional[wd_api.EventEmitter]
changed: constructor DirWatcher(settings: SettingsStatic, file_pusher: FilePusher, file_dir: Optional[PathStr]=…) -> None → constructor DirWatcher(settings: SettingsStatic, file_pusher: FilePusher, file_dir: PathStr | None=…) -> None
changed: constructor PolicyLive(file_path: PathStr, save_name: LogicalPath, file_pusher: FilePusher, settings: Optional[SettingsStatic]=…, *args: Any, **kwargs: Any) -> None → constructor PolicyLive(file_path: PathStr, save_name: LogicalPath, file_pusher: FilePusher, settings: SettingsStatic | None=…, *args: Any, **kwargs: Any) -> None
added: property DirWatcher.emitter -> wd_api.EventEmitter | None

changed: field RequestFinish.callback: Optional[step_upload.OnRequestFinishFn] → field RequestFinish.callback: step_upload.OnRequestFinishFn | None

changed: constructor StepPrepare(api: Api, batch_time: float, inter_event_time: float, max_batch_size: int, request_queue: Optional[queue.Queue[Request]]=…) -> None → constructor StepPrepare(api: Api, batch_time: float, inter_event_time: float, max_batch_size: int, request_queue: queue.Queue[Request] | None=…) -> None
changed: field ResponsePrepare.multipart_upload_urls: Optional[Dict[int, str]] → field ResponsePrepare.multipart_upload_urls: dict[int, str] | None
changed: field ResponsePrepare.storage_path: Optional[str] → field ResponsePrepare.storage_path: str | None
changed: field ResponsePrepare.upload_id: Optional[str] → field ResponsePrepare.upload_id: str | None
changed: field ResponsePrepare.upload_url: Optional[str] → field ResponsePrepare.upload_url: str | None
changed: function gather_batch(request_queue: queue.Queue[Request], batch_time: float, inter_event_time: float, max_batch_size: int, clock: Callable[[], float]=…) -> Tuple[bool, Sequence[RequestPrepare]] → function gather_batch(request_queue: queue.Queue[Request], batch_time: float, inter_event_time: float, max_batch_size: int, clock: Callable[[], float]=…) -> tuple[bool, Sequence[RequestPrepare]]

changed: constructor StepUpload(api: internal_api.Api, stats: stats.Stats, event_queue: queue.Queue[Event], max_threads: int, file_stream: file_stream.FileStreamApi, settings: Optional[SettingsStatic]=…) -> None → constructor StepUpload(api: internal_api.Api, stats: stats.Stats, event_queue: queue.Queue[Event], max_threads: int, file_stream: file_stream.FileStreamApi, settings: SettingsStatic | None=…) -> None
changed: field EventJobDone.exc: Optional[BaseException] → field EventJobDone.exc: BaseException | None
changed: field RequestFinish.callback: Optional[OnRequestFinishFn] → field RequestFinish.callback: OnRequestFinishFn | None
changed: field RequestUpload.artifact_id: Optional[str] → field RequestUpload.artifact_id: str | None
changed: field RequestUpload.digest: Optional[str] → field RequestUpload.digest: str | None
changed: field RequestUpload.md5: Optional[str] → field RequestUpload.md5: str | None
changed: field RequestUpload.save_fn: Optional[SaveFn] → field RequestUpload.save_fn: SaveFn | None

changed: constructor UploadJob(stats: stats.Stats, api: internal_api.Api, file_stream: file_stream.FileStreamApi, silent: bool, save_name: LogicalPath, path: dir_watcher.PathStr, artifact_id: Optional[str], md5: Optional[str], copied: bool, save_fn: Optional[step_upload.SaveFn], digest: Optional[str]) -> None → constructor UploadJob(stats: stats.Stats, api: internal_api.Api, file_stream: file_stream.FileStreamApi, silent: bool, save_name: LogicalPath, path: dir_watcher.PathStr, artifact_id: str | None, md5: str | None, copied: bool, save_fn: step_upload.SaveFn | None, digest: str | None) -> None

changed: function log_summary(model: Union[CatBoostClassifier, CatBoostRegressor], log_all_params: bool=…, save_model_checkpoint: bool=…, log_feature_importance: bool=…) -> None → function log_summary(model: CatBoostClassifier | CatBoostRegressor, log_all_params: bool=…, save_model_checkpoint: bool=…, log_feature_importance: bool=…) -> None

changed: function collect_common_keys(list_of_dicts: List[Dict[str, Any]]) -> Dict[str, List[Any]] → function collect_common_keys(list_of_dicts: list[dict[str, Any]]) -> dict[str, list[Any]]
changed: function flatten_dict(dictionary: Dict[str, Any], parent_key: str=…, sep: str=…) -> Dict[str, Any] → function flatten_dict(dictionary: dict[str, Any], parent_key: str=…, sep: str=…) -> dict[str, Any]
changed: function reorder_and_convert_dict_list_to_table(data: List[Dict[str, Any]], order: List[str]) -> Tuple[List[str], List[List[Any]]] → function reorder_and_convert_dict_list_to_table(data: list[dict[str, Any]], order: list[str]) -> tuple[list[str], list[list[Any]]]
changed: function subset_dict(original_dict: Dict[str, Any], keys_subset: Sequence[str]) -> Dict[str, Any] → function subset_dict(original_dict: dict[str, Any], keys_subset: Sequence[str]) -> dict[str, Any]

changed: method DiffusersMultiModalPipelineResolver.add_data_to_table(image: Any, loggable_kwarg_chunks: List, idx: int) -> None → method DiffusersMultiModalPipelineResolver.add_data_to_table(image: Any, loggable_kwarg_chunks: list, idx: int) -> None
changed: method DiffusersMultiModalPipelineResolver.get_output_images(response: Response) -> List → method DiffusersMultiModalPipelineResolver.get_output_images(response: Response) -> list
changed: method DiffusersMultiModalPipelineResolver.log_media(image: Any, loggable_kwarg_chunks: List, idx: int) -> None → method DiffusersMultiModalPipelineResolver.log_media(image: Any, loggable_kwarg_chunks: list, idx: int) -> None
changed: method DiffusersMultiModalPipelineResolver.prepare_loggable_dict(pipeline: Any, response: Response, kwargs: Dict[str, Any]) -> Dict[str, Any] → method DiffusersMultiModalPipelineResolver.prepare_loggable_dict(pipeline: Any, response: Response, kwargs: dict[str, Any]) -> dict[str, Any]

changed: function chunkify(input_list, chunk_size) -> List → function chunkify(input_list, chunk_size) -> list
changed: function decode_sdxl_t2i_latents(pipeline: Any, latents: torch_float_tensor) -> List → function decode_sdxl_t2i_latents(pipeline: Any, latents: torch_float_tensor) -> list
changed: function get_updated_kwargs(pipeline: Any, args: Sequence[Any], kwargs: Dict[str, Any]) -> Dict[str, Any] → function get_updated_kwargs(pipeline: Any, args: Sequence[Any], kwargs: dict[str, Any]) -> dict[str, Any]
changed: function postprocess_np_arrays_for_video(images: List[np_array], normalize: Optional[bool]=…) -> np_array → function postprocess_np_arrays_for_video(images: list[np_array], normalize: bool | None=…) -> np_array
changed: function postprocess_pils_to_np(image: List) -> np_array → function postprocess_pils_to_np(image: list) -> np_array

changed: constructor WandbCallback(learn: fastai.basic_train.Learner, log: Optional[Literal['gradients', 'parameters', 'all']]=…, save_model: bool=…, monitor: Optional[str]=…, mode: Literal['auto', 'min', 'max']=…, input_type: Optional[Literal['images']]=…, validation_data: Optional[list]=…, predictions: int=…, seed: int=…) -> None → constructor WandbCallback(learn: fastai.basic_train.Learner, log: Literal['gradients', 'parameters', 'all'] | None=…, save_model: bool=…, monitor: str | None=…, mode: Literal['auto', 'min', 'max']=…, input_type: Literal['images'] | None=…, validation_data: list | None=…, predictions: int=…, seed: int=…) -> None

changed: constructor WandbMetricsLogger(log_freq: Union[LogStrategy, int]=…, initial_global_step: int=…, *args: Any, **kwargs: Any) -> None → constructor WandbMetricsLogger(log_freq: LogStrategy | int=…, initial_global_step: int=…, *args: Any, **kwargs: Any) -> None
changed: method WandbMetricsLogger.on_batch_end(batch: int, logs: Optional[Dict[str, Any]]=…) -> None → method WandbMetricsLogger.on_batch_end(batch: int, logs: dict[str, Any] | None=…) -> None
changed: method WandbMetricsLogger.on_epoch_end(epoch: int, logs: Optional[Dict[str, Any]]=…) -> None → method WandbMetricsLogger.on_epoch_end(epoch: int, logs: dict[str, Any] | None=…) -> None
changed: method WandbMetricsLogger.on_train_batch_end(batch: int, logs: Optional[Dict[str, Any]]=…) -> None → method WandbMetricsLogger.on_train_batch_end(batch: int, logs: dict[str, Any] | None=…) -> None

removed: property WandbModelCheckpoint.is_old_tf_keras_version -> Optional[bool]
changed: constructor WandbModelCheckpoint(filepath: StrPath, monitor: str=…, verbose: int=…, save_best_only: bool=…, save_weights_only: bool=…, mode: Mode=…, save_freq: Union[SaveStrategy, int]=…, initial_value_threshold: Optional[float]=…, **kwargs: Any) -> None → constructor WandbModelCheckpoint(filepath: StrPath, monitor: str=…, verbose: int=…, save_best_only: bool=…, save_weights_only: bool=…, mode: Mode=…, save_freq: SaveStrategy | int=…, initial_value_threshold: float | None=…, **kwargs: Any) -> None
changed: method WandbModelCheckpoint.on_epoch_end(epoch: int, logs: Optional[Dict[str, float]]=…) -> None → method WandbModelCheckpoint.on_epoch_end(epoch: int, logs: dict[str, float] | None=…) -> None
changed: method WandbModelCheckpoint.on_train_batch_end(batch: int, logs: Optional[Dict[str, float]]=…) -> None → method WandbModelCheckpoint.on_train_batch_end(batch: int, logs: dict[str, float] | None=…) -> None
added: property WandbModelCheckpoint.is_old_tf_keras_version -> bool | None

changed: constructor WandbEvalCallback(data_table_columns: List[str], pred_table_columns: List[str], *args: Any, **kwargs: Any) -> None → constructor WandbEvalCallback(data_table_columns: list[str], pred_table_columns: list[str], *args: Any, **kwargs: Any) -> None
changed: method WandbEvalCallback.add_ground_truth(logs: Optional[Dict[str, float]]=…) -> None → method WandbEvalCallback.add_ground_truth(logs: dict[str, float] | None=…) -> None
changed: method WandbEvalCallback.add_model_predictions(epoch: int, logs: Optional[Dict[str, float]]=…) -> None → method WandbEvalCallback.add_model_predictions(epoch: int, logs: dict[str, float] | None=…) -> None
changed: method WandbEvalCallback.init_data_table(column_names: List[str]) -> None → method WandbEvalCallback.init_data_table(column_names: list[str]) -> None
changed: method WandbEvalCallback.init_pred_table(column_names: List[str]) -> None → method WandbEvalCallback.init_pred_table(column_names: list[str]) -> None
changed: method WandbEvalCallback.log_pred_table(type: str=…, table_name: str=…, aliases: Optional[List[str]]=…) -> None → method WandbEvalCallback.log_pred_table(type: str=…, table_name: str=…, aliases: list[str] | None=…) -> None
changed: method WandbEvalCallback.on_epoch_end(epoch: int, logs: Optional[Dict[str, float]]=…) -> None → method WandbEvalCallback.on_epoch_end(epoch: int, logs: dict[str, float] | None=…) -> None
changed: method WandbEvalCallback.on_train_begin(logs: Optional[Dict[str, float]]=…) -> None → method WandbEvalCallback.on_train_begin(logs: dict[str, float] | None=…) -> None

changed: function create_component_from_func(func: Callable, output_component_file: Optional[str]=…, base_image: Optional[str]=…, packages_to_install: Optional[List[str]]=…, annotations: Optional[Mapping[str, str]]=…) → function create_component_from_func(func: Callable, output_component_file: str | None=…, base_image: str | None=…, packages_to_install: list[str] | None=…, annotations: Mapping[str, str] | None=…)

changed: field CallbackEnv.evaluation_result_list: List[_EvalResultTuple] → field CallbackEnv.evaluation_result_list: list[_EvalResultTuple]
changed: field CallbackEnv.params: Dict → field CallbackEnv.params: dict

removed: property WandbLogger.log_dir -> Optional[str]
removed: property WandbLogger.name -> Optional[str]
removed: property WandbLogger.root_dir -> Optional[str]
removed: property WandbLogger.save_dir -> Optional[str]
removed: property WandbLogger.version -> Optional[str]
changed: constructor WandbLogger(name: Optional[str]=…, save_dir: _PATH=…, version: Optional[str]=…, offline: bool=…, dir: Optional[_PATH]=…, id: Optional[str]=…, anonymous: Optional[bool]=…, project: Optional[str]=…, log_model: Union[Literal['all'], bool]=…, experiment: Optional[wandb.Run]=…, prefix: str=…, checkpoint_name: Optional[str]=…, log_checkpoint_on: Union[Literal['success'], Literal['all']]=…,… → constructor WandbLogger(name: str | None=…, save_dir: _PATH=…, version: str | None=…, offline: bool=…, dir: _PATH | None=…, id: str | None=…, anonymous: bool | None=…, project: str | None=…, log_model: Literal['all'] | bool=…, experiment: wandb.Run | None=…, prefix: str=…, checkpoint_name: str | None=…, log_checkpoint_on: Literal['success'] | Literal['all']=…, **kwargs: Any) -> None
changed: method WandbLogger.log_audio(key: str, audios: List[Any], step: Optional[int]=…, **kwargs: Any) -> None → method WandbLogger.log_audio(key: str, audios: list[Any], step: int | None=…, **kwargs: Any) -> None
changed: method WandbLogger.log_graph(model: Module, input_array: Optional[Tensor]=…) -> None → method WandbLogger.log_graph(model: Module, input_array: Tensor | None=…) -> None
changed: method WandbLogger.log_html(key: str, htmls: List[Any], step: Optional[int]=…, **kwargs: Any) -> None → method WandbLogger.log_html(key: str, htmls: list[Any], step: int | None=…, **kwargs: Any) -> None
changed: method WandbLogger.log_hyperparams(params: Union[Dict[str, Any], Namespace]) -> None → method WandbLogger.log_hyperparams(params: dict[str, Any] | Namespace) -> None
changed: method WandbLogger.log_image(key: str, images: List[Any], step: Optional[int]=…, **kwargs: Any) -> None → method WandbLogger.log_image(key: str, images: list[Any], step: int | None=…, **kwargs: Any) -> None
changed: method WandbLogger.log_metrics(metrics: Mapping[str, float], step: Optional[int]=…) -> None → method WandbLogger.log_metrics(metrics: Mapping[str, float], step: int | None=…) -> None
changed: method WandbLogger.log_table(key: str, columns: Optional[List[str]]=…, data: Optional[List[List[Any]]]=…, dataframe: Any=…, step: Optional[int]=…) -> None → method WandbLogger.log_table(key: str, columns: list[str] | None=…, data: list[list[Any]] | None=…, dataframe: Any=…, step: int | None=…) -> None
changed: method WandbLogger.log_text(key: str, columns: Optional[List[str]]=…, data: Optional[List[List[str]]]=…, dataframe: Any=…, step: Optional[int]=…) -> None → method WandbLogger.log_text(key: str, columns: list[str] | None=…, data: list[list[str]] | None=…, dataframe: Any=…, step: int | None=…) -> None
changed: method WandbLogger.log_video(key: str, videos: List[Any], step: Optional[int]=…, **kwargs: Any) -> None → method WandbLogger.log_video(key: str, videos: list[Any], step: int | None=…, **kwargs: Any) -> None
changed: method WandbLogger.use_artifact(artifact: str, artifact_type: Optional[str]=…) -> Artifact → method WandbLogger.use_artifact(artifact: str, artifact_type: str | None=…) -> Artifact
changed: static method WandbLogger.download_artifact(artifact: str, save_dir: Optional[_PATH]=…, artifact_type: Optional[str]=…, use_artifact: Optional[bool]=…) -> str → static method WandbLogger.download_artifact(artifact: str, save_dir: _PATH | None=…, artifact_type: str | None=…, use_artifact: bool | None=…) -> str
added: property WandbLogger.log_dir -> str | None
added: property WandbLogger.name -> str | None
added: property WandbLogger.root_dir -> str | None
added: property WandbLogger.save_dir -> str | None
added: property WandbLogger.version -> str | None

changed: function wandb_log(func=…, /, datasets: bool=…, models: bool=…, others: bool=…, settings: Optional[wandb.Settings]=…) → function wandb_log(func=…, /, datasets: bool=…, models: bool=…, others: bool=…, settings: wandb.Settings | None=…)
changed: function wandb_track(name: str, data, datasets: bool=…, models: bool=…, others: bool=…, run: Optional[wandb.Run]=…, testing: bool=…) -> Optional[str] → function wandb_track(name: str, data, datasets: bool=…, models: bool=…, others: bool=…, run: wandb.Run | None=…, testing: bool=…) -> str | None
changed: function wandb_use(name: str, data, datasets: bool=…, models: bool=…, others: bool=…, run=…, testing: bool=…) -> Optional[str] → function wandb_use(name: str, data, datasets: bool=…, models: bool=…, others: bool=…, run=…, testing: bool=…) -> str | None

changed: field WandbLogger.openai_client: Optional[OpenAI] → field WandbLogger.openai_client: OpenAI | None
changed: static method WandbLogger.sanitize(input: Any) -> Union[Dict, List, str] → static method WandbLogger.sanitize(input: Any) -> dict | list | str
changed: static method WandbLogger.sync(fine_tune_job_id: Optional[str]=…, openai_client: Optional[OpenAI]=…, num_fine_tunes: Optional[int]=…, project: str=…, entity: Optional[str]=…, overwrite: bool=…, wait_for_job_success: bool=…, log_datasets: bool=…, model_artifact_name: str=…, model_artifact_type: str=…, **kwargs_wandb_init: Dict[str, Any]) -> str → static method WandbLogger.sync(fine_tune_job_id: str | None=…, openai_client: OpenAI | None=…, num_fine_tunes: int | None=…, project: str=…, entity: str | None=…, overwrite: bool=…, wait_for_job_success: bool=…, log_datasets: bool=…, model_artifact_name: str=…, model_artifact_type: str=…, **kwargs_wandb_init: dict[str, Any]) -> str

changed: static method OpenAIRequestResponseResolver.results_to_trace_tree(request: Dict[str, Any], response: Response, results: List[trace_tree.Result], time_elapsed: float) -> trace_tree.WBTraceTree → static method OpenAIRequestResponseResolver.results_to_trace_tree(request: dict[str, Any], response: Response, results: list[trace_tree.Result], time_elapsed: float) -> trace_tree.WBTraceTree

changed: constructor WandbCallback(verbose: int=…, model_save_path: Optional[str]=…, model_save_freq: int=…, gradient_save_freq: int=…, log: Optional[Literal['gradients', 'parameters', 'all']]=…) -> None → constructor WandbCallback(verbose: int=…, model_save_path: str | None=…, model_save_freq: int=…, gradient_save_freq: int=…, log: Literal['gradients', 'parameters', 'all'] | None=…) -> None

changed: function make_ndarray(tensor: Any) -> Optional[np.ndarray] → function make_ndarray(tensor: Any) -> np.ndarray | None
changed: function tf_summary_to_dict(tf_summary_str_or_pb: Any, namespace: str=…) -> Optional[Dict[str, Any]] → function tf_summary_to_dict(tf_summary_str_or_pb: Any, namespace: str=…) -> dict[str, Any] | None
changed: variable RATE_LIMIT_SECONDS: Optional[Union[float, int]] → variable RATE_LIMIT_SECONDS: float | int | None
changed: variable STEPS: Dict[str, Dict[str, Any]] → variable STEPS: dict[str, dict[str, Any]]

changed: function patch(save: bool=…, tensorboard_x: Optional[bool]=…, pytorch: Optional[bool]=…, root_logdir: str=…) -> None → function patch(save: bool=…, tensorboard_x: bool | None=…, pytorch: bool | None=…, root_logdir: str=…) -> None

changed: function log_track_init(log_freq: int) -> List[int] → function log_track_init(log_freq: int) -> list[int]

changed: function get_boxes(result: Results) -> Tuple[Dict, Dict] → function get_boxes(result: Results) -> tuple[dict, dict]
changed: function get_ground_truth_bbox_annotations(img_idx: int, image_path: str, batch: Dict, class_name_map: Dict=…) -> List[Dict[str, Any]] → function get_ground_truth_bbox_annotations(img_idx: int, image_path: str, batch: dict, class_name_map: dict=…) -> list[dict[str, Any]]
changed: function get_mean_confidence_map(classes: List, confidence: List, class_id_to_label: Dict) -> Dict[str, float] → function get_mean_confidence_map(classes: list, confidence: list, class_id_to_label: dict) -> dict[str, float]
changed: function plot_bbox_predictions(result: Results, model_name: str, table: Optional[wandb.Table]=…) -> Union[wandb.Table, Tuple[wandb.Image, Dict, Dict]] → function plot_bbox_predictions(result: Results, model_name: str, table: wandb.Table | None=…) -> wandb.Table | tuple[wandb.Image, dict, dict]
changed: function plot_detection_validation_results(dataloader: Any, class_label_map: Dict, model_name: str, predictor: DetectionPredictor, table: wandb.Table, max_validation_batches: int, epoch: Optional[int]=…) -> wandb.Table → function plot_detection_validation_results(dataloader: Any, class_label_map: dict, model_name: str, predictor: DetectionPredictor, table: wandb.Table, max_validation_batches: int, epoch: int | None=…) -> wandb.Table
changed: function scale_bounding_box_to_original_image_shape(box: torch.Tensor, resized_image_shape: Tuple, original_image_shape: Tuple, ratio_pad: bool) -> List[int] → function scale_bounding_box_to_original_image_shape(box: torch.Tensor, resized_image_shape: tuple, original_image_shape: tuple, ratio_pad: bool) -> list[int]

removed: property WandBUltralyticsCallback.callbacks -> Dict[str, Callable]
changed: function add_wandb_callback(model: YOLO, epoch_logging_interval: int=…, enable_model_checkpointing: bool=…, enable_train_validation_logging: bool=…, enable_validation_logging: bool=…, enable_prediction_logging: bool=…, max_validation_batches: Optional[int]=…, visualize_skeleton: Optional[bool]=…) → function add_wandb_callback(model: YOLO, epoch_logging_interval: int=…, enable_model_checkpointing: bool=…, enable_train_validation_logging: bool=…, enable_validation_logging: bool=…, enable_prediction_logging: bool=…, max_validation_batches: int | None=…, visualize_skeleton: bool | None=…)
added: property WandBUltralyticsCallback.callbacks -> dict[str, Callable]

changed: function plot_classification_predictions(result: Results, model_name: str, table: Optional[wandb.Table]=…, original_image: Optional[np.array]=…) → function plot_classification_predictions(result: Results, model_name: str, table: wandb.Table | None=…, original_image: np.array | None=…)
changed: function plot_classification_validation_results(dataloader: Any, model_name: str, predictor: ClassificationPredictor, table: wandb.Table, max_validation_batches: int, epoch: Optional[int]=…) -> wandb.Table → function plot_classification_validation_results(dataloader: Any, model_name: str, predictor: ClassificationPredictor, table: wandb.Table, max_validation_batches: int, epoch: int | None=…) -> wandb.Table

changed: function get_boxes_and_masks(result: Results) -> Tuple[Dict, Dict, Dict] → function get_boxes_and_masks(result: Results) -> tuple[dict, dict, dict]
changed: function plot_mask_predictions(result: Results, model_name: str, table: Optional[wandb.Table]=…) -> Tuple[wandb.Image, Dict, Dict, Dict] → function plot_mask_predictions(result: Results, model_name: str, table: wandb.Table | None=…) -> tuple[wandb.Image, dict, dict, dict]
changed: function plot_sam_predictions(result: Results, prompt: Dict, table: wandb.Table) -> wandb.Table → function plot_sam_predictions(result: Results, prompt: dict, table: wandb.Table) -> wandb.Table
changed: function plot_segmentation_validation_results(dataloader, class_label_map, model_name: str, predictor: SegmentationPredictor, table: wandb.Table, max_validation_batches: int, epoch: Optional[int]=…) → function plot_segmentation_validation_results(dataloader, class_label_map, model_name: str, predictor: SegmentationPredictor, table: wandb.Table, max_validation_batches: int, epoch: int | None=…)
changed: function structure_prompts_and_image(image: np.array, prompt: Dict) -> Dict → function structure_prompts_and_image(image: np.array, prompt: dict) -> dict

changed: function plot_pose_predictions(result: Results, model_name: str, visualize_skeleton: bool, table: Optional[wandb.Table]=…) → function plot_pose_predictions(result: Results, model_name: str, visualize_skeleton: bool, table: wandb.Table | None=…)
changed: function plot_pose_validation_results(dataloader, class_label_map, model_name: str, predictor: PosePredictor, visualize_skeleton: bool, table: wandb.Table, max_validation_batches: int, epoch: Optional[int]=…) -> wandb.Table → function plot_pose_validation_results(dataloader, class_label_map, model_name: str, predictor: PosePredictor, visualize_skeleton: bool, table: wandb.Table, max_validation_batches: int, epoch: int | None=…) -> wandb.Table

removed: property WandbCallback.callbacks -> Dict[str, Callable]
changed: constructor WandbCallback(yolo: YOLO, run_name: Optional[str]=…, project: Optional[str]=…, tags: Optional[List[str]]=…, resume: Optional[str]=…, **kwargs: Optional[Any]) -> None → constructor WandbCallback(yolo: YOLO, run_name: str | None=…, project: str | None=…, tags: list[str] | None=…, resume: str | None=…, **kwargs: Any | None) -> None
changed: function add_callbacks(yolo: YOLO, run_name: Optional[str]=…, project: Optional[str]=…, tags: Optional[List[str]]=…, resume: Optional[str]=…, **kwargs: Optional[Any]) -> YOLO → function add_callbacks(yolo: YOLO, run_name: str | None=…, project: str | None=…, tags: list[str] | None=…, resume: str | None=…, **kwargs: Any | None) -> YOLO
added: property WandbCallback.callbacks -> dict[str, Callable]

removed: variable ApiErrorResponse
removed: variable ApiRequest
removed: variable ApiResponse
removed: variable DESCRIPTOR
removed: variable DownloadRunHistory
removed: variable DownloadRunHistoryResponse
removed: variable ErrorType
removed: variable HistoryRow
removed: variable INCOMPLETE_RUN_HISTORY_ERROR
removed: variable IncompleteRunHistoryError
removed: variable ParquetHistoryItem
removed: variable ReadRunHistoryRequest
removed: variable ReadRunHistoryResponse
removed: variable RunHistoryResponse
removed: variable ScanRunHistory
removed: variable ScanRunHistoryCleanup
removed: variable ScanRunHistoryCleanupResponse
removed: variable ScanRunHistoryInit
removed: variable ScanRunHistoryInitResponse
removed: variable ServerApiInitRequest
removed: variable ServerApiInitResponse
removed: variable UNKNOWN_ERROR

removed: variable DESCRIPTOR

removed: variable ARTIFACT_COLLECTION_MEMBERSHIP_FILES
removed: variable ARTIFACT_COLLECTION_MEMBERSHIP_FILE_DOWNLOAD_HANDLER
removed: variable ARTIFACT_MEMBERSHIP_IN_LINK_ARTIFACT_RESPONSE
removed: variable ARTIFACT_REGISTRY_SEARCH
removed: variable ARTIFACT_TAGS
removed: variable AUTOMATION_ACTION_NO_OP
removed: variable AUTOMATION_EVENT_RUN_METRIC
removed: variable AUTOMATION_EVENT_RUN_METRIC_CHANGE
removed: variable AlertRecord
removed: variable AlertResult
removed: variable AppleInfo
removed: variable ArtifactInfo
removed: variable ArtifactManifest
removed: variable ArtifactManifestEntry
removed: variable ArtifactRecord
removed: variable ArtifactResult
removed: variable AttachRequest
removed: variable AttachResponse
removed: variable BranchPoint
removed: variable CLIENT_IDS
removed: variable CancelRequest
removed: variable CancelResponse
removed: variable CheckVersionRequest
removed: variable CheckVersionResponse
removed: variable ConfigItem
removed: variable ConfigRecord
removed: variable ConfigResult
removed: variable Control
removed: variable CoreWeaveInfo
removed: variable CpuInfo
removed: variable DESCRIPTOR
removed: variable DeferRequest
removed: variable DiskInfo
removed: variable DownloadArtifactRequest
removed: variable DownloadArtifactResponse
removed: variable EXPAND_DEFINED_METRIC_GLOBS
removed: variable EnvironmentRecord
removed: variable ErrorInfo
removed: variable ExtraItem
removed: variable FileCounts
removed: variable FilePusherStats
removed: variable FileTransferInfoRequest
removed: variable FilesItem
removed: variable FilesRecord
removed: variable FilesResult
removed: variable FilesUploaded
removed: variable FinalRecord
removed: variable FooterRecord
removed: variable GetSummaryRequest
removed: variable GetSummaryResponse
removed: variable GetSystemMetricsRequest
removed: variable GetSystemMetricsResponse
removed: variable GitInfo
removed: variable GitRepoRecord
removed: variable GitSource
removed: variable GpuAmdInfo
removed: variable GpuNvidiaInfo
removed: variable HeaderRecord
removed: variable HistoryAction
removed: variable HistoryItem
removed: variable HistoryRecord
removed: variable HistoryResult
removed: variable HistoryStep
removed: variable HttpResponse
removed: variable INCLUDE_ARTIFACT_TYPES_IN_REGISTRY_CREATION
removed: variable ImageSource
removed: variable InternalMessages
removed: variable InternalMessagesRequest
removed: variable InternalMessagesResponse
removed: variable JobInfoRequest
removed: variable JobInfoResponse
removed: variable JobInputPath
removed: variable JobInputRequest
removed: variable JobInputSource
removed: variable JobSource
removed: variable KeepaliveRequest
removed: variable KeepaliveResponse
removed: variable LARGE_FILENAMES
removed: variable LinkArtifactRequest
removed: variable LinkArtifactResponse
removed: variable LinkArtifactResult
removed: variable LocalInfo
removed: variable LogArtifactRequest
removed: variable LogArtifactResponse
removed: variable LoginRequest
removed: variable LoginResponse
removed: variable MemoryInfo
removed: variable MetricControl
removed: variable MetricOptions
removed: variable MetricRecord
removed: variable MetricResult
removed: variable MetricSummary
removed: variable NetworkStatusRequest
removed: variable NetworkStatusResponse
removed: variable Operation
removed: variable OperationStats
removed: variable OperationStatsRequest
removed: variable OperationStatsResponse
removed: variable OutputRawRecord
removed: variable OutputRawResult
removed: variable OutputRecord
removed: variable OutputResult
removed: variable PROJECT_ARTIFACT_COLLECTION_MEMBERSHIP
removed: variable PartialHistoryRequest
removed: variable PartialHistoryResponse
removed: variable PartialJobArtifact
removed: variable PauseRequest
removed: variable PauseResponse
removed: variable PollExitRequest
removed: variable PollExitResponse
removed: variable ProbeSystemInfoRequest
removed: variable PythonPackagesRequest
removed: variable Record
removed: variable Request
removed: variable Response
removed: variable Result
removed: variable ResumeRequest
removed: variable ResumeResponse
removed: variable RunExitRecord
removed: variable RunExitResult
removed: variable RunFinishWithoutExitRequest
removed: variable RunFinishWithoutExitResponse
removed: variable RunPreemptingRecord
removed: variable RunPreemptingResult
removed: variable RunRecord
removed: variable RunStartRequest
removed: variable RunStartResponse
removed: variable RunStatusRequest
removed: variable RunStatusResponse
removed: variable RunUpdateResult
removed: variable STRUCTURED_CONSOLE_LOGS
removed: variable SampledHistoryItem
removed: variable SampledHistoryRequest
removed: variable SampledHistoryResponse
removed: variable SenderMarkRequest
removed: variable SenderReadRequest
removed: variable ServerFeature
removed: variable ServerFeatureItem
removed: variable ServerFeatureRequest
removed: variable ServerFeatureResponse
removed: variable ServerInfoRequest
removed: variable ServerInfoResponse
removed: variable ServerMessage
removed: variable ServerMessages
removed: variable SettingsItem
removed: variable SettingsRecord
removed: variable ShutdownRequest
removed: variable ShutdownResponse
removed: variable Source
removed: variable StatsItem
removed: variable StatsRecord
removed: variable StatusReportRequest
removed: variable StatusRequest
removed: variable StatusResponse
removed: variable StopStatusRequest
removed: variable StopStatusResponse
removed: variable StoragePolicyConfigItem
removed: variable SummaryItem
removed: variable SummaryRecord
removed: variable SummaryRecordRequest
removed: variable SummaryResult
removed: variable SyncFinishRequest
removed: variable SyncResponse
removed: variable SystemMetricSample
removed: variable SystemMetricsBuffer
removed: variable TBRecord
removed: variable TBResult
removed: variable TOTAL_COUNT_IN_FILE_CONNECTION
removed: variable TPUInfo
removed: variable TelemetryRecordRequest
removed: variable TestInjectRequest
removed: variable TestInjectResponse
removed: variable TrainiumInfo
removed: variable USE_ARTIFACT_WITH_ENTITY_AND_PROJECT_INFORMATION
removed: variable UseArtifactRecord
removed: variable UseArtifactResult
removed: variable VersionInfo

removed: variable DESCRIPTOR
removed: variable ServerAuthenticateRequest
removed: variable ServerAuthenticateResponse
removed: variable ServerCancelRequest
removed: variable ServerInformAttachRequest
removed: variable ServerInformAttachResponse
removed: variable ServerInformDetachRequest
removed: variable ServerInformDetachResponse
removed: variable ServerInformFinishRequest
removed: variable ServerInformFinishResponse
removed: variable ServerInformInitRequest
removed: variable ServerInformInitResponse
removed: variable ServerInformTeardownRequest
removed: variable ServerInformTeardownResponse
removed: variable ServerRequest
removed: variable ServerResponse
removed: variable ServerShutdownRequest
removed: variable ServerShutdownResponse
removed: variable ServerStatusRequest
removed: variable ServerStatusResponse

removed: variable DESCRIPTOR
removed: variable ListIntValue
removed: variable ListStringValue
removed: variable MapStringKeyMapStringKeyStringValue
removed: variable MapStringKeyStringValue
removed: variable OpenMetricsFilters
removed: variable RunMoment
removed: variable Settings

removed: variable DESCRIPTOR
removed: variable ServerInitSyncRequest
removed: variable ServerInitSyncResponse
removed: variable ServerSyncMessage
removed: variable ServerSyncRequest
removed: variable ServerSyncResponse
removed: variable ServerSyncStatusRequest
removed: variable ServerSyncStatusResponse

removed: variable DESCRIPTOR
removed: variable Deprecated
removed: variable Env
removed: variable Feature
removed: variable Imports
removed: variable Issues
removed: variable Labels
removed: variable TelemetryRecord
removed: variable TelemetryResult

changed: constructor Audio(data_or_path: Union[str, pathlib.Path, list, np.ndarray], sample_rate: Optional[int]=…, caption: Optional[str]=…) → constructor Audio(data_or_path: str | pathlib.Path | list | np.ndarray, sample_rate: int | None=…, caption: str | None=…)
changed: method Audio.bind_to_run(run, key, step, id_=…, ignore_copy_err: Optional[bool]=…) → method Audio.bind_to_run(run, key, step, id_=…, ignore_copy_err: bool | None=…)

changed: method JSONMetadata.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method JSONMetadata.to_json(run_or_artifact: LocalRun | Artifact) -> dict

changed: constructor BatchableMedia(caption: Optional[str]=…) -> None → constructor BatchableMedia(caption: str | None=…) -> None
changed: constructor Media(caption: Optional[str]=…) -> None → constructor Media(caption: str | None=…) -> None
changed: method Media.bind_to_run(run: wandb.Run, key: Union[int, str], step: Union[int, str], id_: Optional[Union[int, str]]=…, ignore_copy_err: Optional[bool]=…) -> None → method Media.bind_to_run(run: wandb.Run, key: int | str, step: int | str, id_: int | str | None=…, ignore_copy_err: bool | None=…) -> None
changed: method Media.to_json(run: Union[wandb.Run, Artifact]) -> dict → method Media.to_json(run: wandb.Run | Artifact) -> dict
changed: static method BatchableMedia.seq_to_json(seq: Sequence[BatchableMedia], run: wandb.Run, key: str, step: Union[int, str]) -> dict → static method BatchableMedia.seq_to_json(seq: Sequence[BatchableMedia], run: wandb.Run, key: str, step: int | str) -> dict
changed: static method Media.captions(media_items: Sequence[Media]) -> Union[bool, Sequence[Optional[str]]] → static method Media.captions(media_items: Sequence[Media]) -> bool | Sequence[str | None]
changed: static method Media.path_is_reference(path: Optional[Union[str, pathlib.Path]]) -> bool → static method Media.path_is_reference(path: str | pathlib.Path | None) -> bool

changed: method WBValue.to_data_array() -> List[Any] → method WBValue.to_data_array() -> list[Any]
changed: method WBValue.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method WBValue.to_json(run_or_artifact: LocalRun | Artifact) -> dict
changed: static method WBValue.init_from_json(json_obj: dict, source_artifact: Artifact) -> Optional[WBValue] → static method WBValue.init_from_json(json_obj: dict, source_artifact: Artifact) -> WBValue | None

changed: constructor Bokeh(data_or_path: Union[str, pathlib.Path, document.Document, model.Model]) → constructor Bokeh(data_or_path: str | pathlib.Path | document.Document | model.Model)

changed: method BoundingBoxes2D.bind_to_run(run: LocalRun, key: Union[int, str], step: Union[int, str], id_: Optional[Union[int, str]]=…, ignore_copy_err: Optional[bool]=…) -> None → method BoundingBoxes2D.bind_to_run(run: LocalRun, key: int | str, step: int | str, id_: int | str | None=…, ignore_copy_err: bool | None=…) -> None
changed: method BoundingBoxes2D.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method BoundingBoxes2D.to_json(run_or_artifact: LocalRun | Artifact) -> dict

changed: method Classes.to_json(run_or_artifact: Optional[Union[LocalRun, Artifact]]) -> dict → method Classes.to_json(run_or_artifact: LocalRun | Artifact | None) -> dict
changed: static method Classes.from_json(json_obj: dict, source_artifact: Optional[Artifact]) -> Classes → static method Classes.from_json(json_obj: dict, source_artifact: Artifact | None) -> Classes

changed: method ImageMask.bind_to_run(run: LocalRun, key: Union[int, str], step: Union[int, str], id_: Optional[Union[int, str]]=…, ignore_copy_err: Optional[bool]=…) -> None → method ImageMask.bind_to_run(run: LocalRun, key: int | str, step: int | str, id_: int | str | None=…, ignore_copy_err: bool | None=…) -> None
changed: method ImageMask.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method ImageMask.to_json(run_or_artifact: LocalRun | Artifact) -> dict

changed: constructor Histogram(sequence: Optional[Sequence]=…, np_histogram: Optional[NumpyHistogram]=…, num_bins: int=…) -> None → constructor Histogram(sequence: Sequence | None=…, np_histogram: NumpyHistogram | None=…, num_bins: int=…) -> None
changed: method Histogram.to_json(run: Optional[Union[LocalRun, Artifact]]=…) -> dict → method Histogram.to_json(run: LocalRun | Artifact | None=…) -> dict

changed: constructor Html(data: Union[str, pathlib.Path, TextIO], inject: bool=…, data_is_not_path: bool=…) -> None → constructor Html(data: str | pathlib.Path | TextIO, inject: bool=…, data_is_not_path: bool=…) -> None
changed: method Html.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method Html.to_json(run_or_artifact: LocalRun | Artifact) -> dict
changed: static method Html.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: Union[int, str]) -> dict → static method Html.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: int | str) -> dict

removed: property Image.image -> Optional[PILImage]
changed: constructor Image(data_or_path: ImageDataOrPathType, mode: Optional[str]=…, caption: Optional[str]=…, grouping: Optional[int]=…, classes: Optional[Union[Classes, Sequence[dict]]]=…, boxes: Optional[Union[Dict[str, BoundingBoxes2D], Dict[str, dict]]]=…, masks: Optional[Union[Dict[str, ImageMask], Dict[str, dict]]]=…, file_type: Optional[str]=…, normalize: bool=…) -> None → constructor Image(data_or_path: ImageDataOrPathType, mode: str | None=…, caption: str | None=…, grouping: int | None=…, classes: Classes | Sequence[dict] | None=…, boxes: dict[str, BoundingBoxes2D] | dict[str, dict] | None=…, masks: dict[str, ImageMask] | dict[str, dict] | None=…, file_type: str | None=…, normalize: bool=…) -> None
changed: field Image.format: Optional[str] → field Image.format: str | None
changed: method Image.bind_to_run(run: wandb.Run, key: Union[int, str], step: Union[int, str], id_: Optional[Union[int, str]]=…, ignore_copy_err: Optional[bool]=…) -> None → method Image.bind_to_run(run: wandb.Run, key: int | str, step: int | str, id_: int | str | None=…, ignore_copy_err: bool | None=…) -> None
changed: method Image.guess_mode(data: Union[np.ndarray, torch.Tensor], file_type: Optional[str]=…) -> str → method Image.guess_mode(data: np.ndarray | torch.Tensor, file_type: str | None=…) -> str
changed: method Image.to_data_array() -> List[Any] → method Image.to_data_array() -> list[Any]
changed: method Image.to_json(run_or_artifact: Union[wandb.Run, Artifact]) -> dict → method Image.to_json(run_or_artifact: wandb.Run | Artifact) -> dict
changed: static method Image.all_boxes(images: Sequence[Image], run: wandb.Run, run_key: str, step: Union[int, str]) -> Union[List[Optional[dict]], bool] → static method Image.all_boxes(images: Sequence[Image], run: wandb.Run, run_key: str, step: int | str) -> list[dict | None] | bool
changed: static method Image.all_captions(images: Sequence[Media]) -> Union[bool, Sequence[Optional[str]]] → static method Image.all_captions(images: Sequence[Media]) -> bool | Sequence[str | None]
changed: static method Image.all_masks(images: Sequence[Image], run: wandb.Run, run_key: str, step: Union[int, str]) -> Union[List[Optional[dict]], bool] → static method Image.all_masks(images: Sequence[Image], run: wandb.Run, run_key: str, step: int | str) -> list[dict | None] | bool
changed: static method Image.seq_to_json(seq: Sequence[BatchableMedia], run: wandb.Run, key: str, step: Union[int, str]) -> dict → static method Image.seq_to_json(seq: Sequence[BatchableMedia], run: wandb.Run, key: str, step: int | str) -> dict
added: property Image.image -> PILImage | None

changed: constructor Molecule(data_or_path: Union[str, pathlib.Path, TextIO], caption: Optional[str]=…, **kwargs: str) -> None → constructor Molecule(data_or_path: str | pathlib.Path | TextIO, caption: str | None=…, **kwargs: str) -> None
changed: method Molecule.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method Molecule.to_json(run_or_artifact: LocalRun | Artifact) -> dict
changed: static method Molecule.from_rdkit(data_or_path: RDKitDataType, caption: Optional[str]=…, convert_to_3d_and_optimize: bool=…, mmff_optimize_molecule_max_iterations: int=…) -> Molecule → static method Molecule.from_rdkit(data_or_path: RDKitDataType, caption: str | None=…, convert_to_3d_and_optimize: bool=…, mmff_optimize_molecule_max_iterations: int=…) -> Molecule
changed: static method Molecule.from_smiles(data: str, caption: Optional[str]=…, sanitize: bool=…, convert_to_3d_and_optimize: bool=…, mmff_optimize_molecule_max_iterations: int=…) -> Molecule → static method Molecule.from_smiles(data: str, caption: str | None=…, sanitize: bool=…, convert_to_3d_and_optimize: bool=…, mmff_optimize_molecule_max_iterations: int=…) -> Molecule
changed: static method Molecule.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: Union[int, str]) -> dict → static method Molecule.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: int | str) -> dict

changed: constructor Object3D(data_or_path: Union[np.ndarray, str, pathlib.Path, TextIO, dict], caption: Optional[str]=…, **kwargs: Optional[Union[str, FileFormat3D]]) -> None → constructor Object3D(data_or_path: np.ndarray | str | pathlib.Path | TextIO | dict, caption: str | None=…, **kwargs: str | FileFormat3D | None) -> None
changed: field Box3D.corners: Tuple[Point3D, Point3D, Point3D, Point3D, Point3D, Point3D, Point3D, Point3D] → field Box3D.corners: tuple[Point3D, Point3D, Point3D, Point3D, Point3D, Point3D, Point3D, Point3D]
changed: field Box3D.label: Optional[str] → field Box3D.label: str | None
changed: field Box3D.score: Optional[numeric] → field Box3D.score: numeric | None
changed: field Object3D.SUPPORTED_POINT_CLOUD_TYPES: ClassVar[Set[str]] → field Object3D.SUPPORTED_POINT_CLOUD_TYPES: ClassVar[set[str]]
changed: field Object3D.SUPPORTED_TYPES: ClassVar[Set[str]] → field Object3D.SUPPORTED_TYPES: ClassVar[set[str]]
changed: function box3d(*, center: npt.ArrayLike, size: npt.ArrayLike, orientation: npt.ArrayLike, color: RGBColor, label: Optional[str]=…, score: Optional[numeric]=…) -> Box3D → function box3d(*, center: npt.ArrayLike, size: npt.ArrayLike, orientation: npt.ArrayLike, color: RGBColor, label: str | None=…, score: numeric | None=…) -> Box3D
changed: method Object3D.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method Object3D.to_json(run_or_artifact: LocalRun | Artifact) -> dict
changed: static method Object3D.from_file(data_or_path: Union[TextIO, str], file_type: Optional[FileFormat3D]=…) -> Object3D → static method Object3D.from_file(data_or_path: TextIO | str, file_type: FileFormat3D | None=…) -> Object3D
changed: static method Object3D.from_point_cloud(points: Sequence[Point], boxes: Sequence[Box3D], vectors: Optional[Sequence[Vector3D]]=…, point_cloud_type: PointCloudType=…) -> Object3D → static method Object3D.from_point_cloud(points: Sequence[Point], boxes: Sequence[Box3D], vectors: Sequence[Vector3D] | None=…, point_cloud_type: PointCloudType=…) -> Object3D
changed: static method Object3D.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: Union[int, str]) -> dict → static method Object3D.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: int | str) -> dict

changed: constructor Plotly(val: Union[plotly.Figure, matplotlib.artist.Artist]) → constructor Plotly(val: plotly.Figure | matplotlib.artist.Artist)
changed: method Plotly.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method Plotly.to_json(run_or_artifact: LocalRun | Artifact) -> dict
changed: static method Plotly.make_plot_media(val: Union[plotly.Figure, matplotlib.artist.Artist]) -> Union[Image, Plotly] → static method Plotly.make_plot_media(val: plotly.Figure | matplotlib.artist.Artist) -> Image | Plotly

changed: constructor Table(columns=…, data=…, rows=…, dataframe=…, dtype=…, optional=…, allow_mixed_types=…, log_mode: Optional[Literal['IMMUTABLE', 'MUTABLE', 'INCREMENTAL']]=…) → constructor Table(columns=…, data=…, rows=…, dataframe=…, dtype=…, optional=…, allow_mixed_types=…, log_mode: Literal['IMMUTABLE', 'MUTABLE', 'INCREMENTAL'] | None=…)

removed: property Trace.inputs -> Optional[Dict[str, str]]
removed: property Trace.kind -> Optional[str]
removed: property Trace.metadata -> Optional[Dict[str, str]]
removed: property Trace.outputs -> Optional[Dict[str, str]]
changed: constructor Trace(name: str, kind: Optional[str]=…, status_code: Optional[str]=…, status_message: Optional[str]=…, metadata: Optional[dict]=…, start_time_ms: Optional[int]=…, end_time_ms: Optional[int]=…, inputs: Optional[dict]=…, outputs: Optional[dict]=…, model_dict: Optional[dict]=…) → constructor Trace(name: str, kind: str | None=…, status_code: str | None=…, status_message: str | None=…, metadata: dict | None=…, start_time_ms: int | None=…, end_time_ms: int | None=…, inputs: dict | None=…, outputs: dict | None=…, model_dict: dict | None=…)
changed: constructor WBTraceTree(root_span: Span, model_dict: typing.Optional[dict]=…) → constructor WBTraceTree(root_span: Span, model_dict: dict | None=…)
changed: field Result.inputs: Optional[Dict[str, Any]] → field Result.inputs: dict[str, Any] | None
changed: field Result.outputs: Optional[Dict[str, Any]] → field Result.outputs: dict[str, Any] | None
changed: field Span.attributes: Optional[Dict[str, Any]] → field Span.attributes: dict[str, Any] | None
changed: field Span.child_spans: Optional[List[Span]] → field Span.child_spans: list[Span] | None
changed: field Span.end_time_ms: Optional[int] → field Span.end_time_ms: int | None
changed: field Span.name: Optional[str] → field Span.name: str | None
changed: field Span.results: Optional[List[Result]] → field Span.results: list[Result] | None
changed: field Span.span_id: Optional[str] → field Span.span_id: str | None
changed: field Span.span_kind: Optional[SpanKind] → field Span.span_kind: SpanKind | None
changed: field Span.start_time_ms: Optional[int] → field Span.start_time_ms: int | None
changed: field Span.status_code: Optional[StatusCode] → field Span.status_code: StatusCode | None
changed: field Span.status_message: Optional[str] → field Span.status_message: str | None
changed: method Span.add_named_result(inputs: Dict[str, Any], outputs: Dict[str, Any]) -> None → method Span.add_named_result(inputs: dict[str, Any], outputs: dict[str, Any]) -> None
changed: method WBTraceTree.to_json(run: Optional[Union[LocalRun, Artifact]]) -> dict → method WBTraceTree.to_json(run: LocalRun | Artifact | None) -> dict
added: property Trace.inputs -> dict[str, str] | None
added: property Trace.kind -> str | None
added: property Trace.metadata -> dict[str, str] | None
added: property Trace.outputs -> dict[str, str] | None

changed: function history_dict_to_json(run: Optional[LocalRun], payload: dict, step: Optional[int]=…, ignore_copy_err: Optional[bool]=…) -> dict → function history_dict_to_json(run: LocalRun | None, payload: dict, step: int | None=…, ignore_copy_err: bool | None=…) -> dict
changed: function val_to_json(run: Optional[LocalRun], key: str, val: ValToJsonType, namespace: Optional[Union[str, int]]=…, ignore_copy_err: Optional[bool]=…) -> Union[Sequence, dict] → function val_to_json(run: LocalRun | None, key: str, val: ValToJsonType, namespace: str | int | None=…, ignore_copy_err: bool | None=…) -> Sequence | dict

changed: constructor Video(data_or_path: Union[str, pathlib.Path, np.ndarray, TextIO, BytesIO], caption: Optional[str]=…, fps: Optional[int]=…, format: Optional[Literal['gif', 'mp4', 'webm', 'ogg']]=…) → constructor Video(data_or_path: str | pathlib.Path | np.ndarray | TextIO | BytesIO, caption: str | None=…, fps: int | None=…, format: Literal['gif', 'mp4', 'webm', 'ogg'] | None=…)
changed: function write_gif_with_image_io(clip: Any, filename: str, fps: Optional[int]=…) -> None → function write_gif_with_image_io(clip: Any, filename: str, fps: int | None=…) -> None
changed: method Video.to_json(run_or_artifact: Union[LocalRun, Artifact]) -> dict → method Video.to_json(run_or_artifact: LocalRun | Artifact) -> dict
changed: static method Video.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: Union[int, str]) -> dict → static method Video.seq_to_json(seq: Sequence[BatchableMedia], run: LocalRun, key: str, step: int | str) -> dict

changed: constructor AutologAPI(name: str, symbols: Sequence[str], resolver: ArgumentResponseResolver, telemetry_feature: Optional[str]=…) -> None → constructor AutologAPI(name: str, symbols: Sequence[str], resolver: ArgumentResponseResolver, telemetry_feature: str | None=…) -> None
changed: method Response.get(key: K, default: Optional[V]=…) -> Optional[V] → method Response.get(key: K, default: V | None=…) -> V | None

changed: constructor ValidationDataLogger(inputs: Union[Sequence, Dict[str, Sequence]], targets: Optional[Union[Sequence, Dict[str, Sequence]]]=…, indexes: Optional[List[_TableIndex]]=…, validation_row_processor: Optional[Callable]=…, prediction_row_processor: Optional[Callable]=…, input_col_name: str=…, target_col_name: str=…, table_name: str=…, artifact_type: str=…, class_labels: Optional[List[str]]=…,… → constructor ValidationDataLogger(inputs: Sequence | dict[str, Sequence], targets: Sequence | dict[str, Sequence] | None=…, indexes: list[_TableIndex] | None=…, validation_row_processor: Callable | None=…, prediction_row_processor: Callable | None=…, input_col_name: str=…, target_col_name: str=…, table_name: str=…, artifact_type: str=…, class_labels: list[str] | None=…, infer_missing_processors: b…
changed: field ValidationDataLogger.class_labels_table: Optional[wandb.Table] → field ValidationDataLogger.class_labels_table: wandb.Table | None
changed: field ValidationDataLogger.prediction_row_processor: Optional[Callable] → field ValidationDataLogger.prediction_row_processor: Callable | None
changed: field ValidationDataLogger.validation_indexes: List[_TableIndex] → field ValidationDataLogger.validation_indexes: list[_TableIndex]
changed: field ValidationDataLogger.validation_inputs: Union[Sequence, Dict[str, Sequence]] → field ValidationDataLogger.validation_inputs: Sequence | dict[str, Sequence]
changed: field ValidationDataLogger.validation_targets: Optional[Union[Sequence, Dict[str, Sequence]]] → field ValidationDataLogger.validation_targets: Sequence | dict[str, Sequence] | None
changed: method ValidationDataLogger.log_predictions(predictions: Union[Sequence, Dict[str, Sequence]], prediction_col_name: str=…, val_ndx_col_name: str=…, table_name: str=…, commit: bool=…) -> wandb.data_types.Table → method ValidationDataLogger.log_predictions(predictions: Sequence | dict[str, Sequence], prediction_col_name: str=…, val_ndx_col_name: str=…, table_name: str=…, commit: bool=…) -> wandb.data_types.Table
changed: method ValidationDataLogger.make_predictions(predict_fn: Callable) -> Union[Sequence, Dict[str, Sequence]] → method ValidationDataLogger.make_predictions(predict_fn: Callable) -> Sequence | dict[str, Sequence]

changed: field SummaryItem.key: t.Tuple[str] → field SummaryItem.key: tuple[str]
changed: field SummaryRecord.remove: t.List[SummaryItem] → field SummaryRecord.remove: list[SummaryItem]
changed: field SummaryRecord.update: t.List[SummaryItem] → field SummaryRecord.update: list[SummaryItem]

changed: method ContextKeeper.add_from_record(record: Record) -> Optional[Context] → method ContextKeeper.add_from_record(record: Record) -> Context | None
changed: method ContextKeeper.get(context_id: str) -> Optional[Context] → method ContextKeeper.get(context_id: str) -> Context | None

changed: method DataStore.write(obj: Record) -> Tuple[int, int, int] → method DataStore.write(obj: Record) -> tuple[int, int, int]

changed: constructor FilePusher(api: internal_api.Api, file_stream: file_stream.FileStreamApi, settings: Optional[SettingsStatic]=…) -> None → constructor FilePusher(api: internal_api.Api, file_stream: file_stream.FileStreamApi, settings: SettingsStatic | None=…) -> None
changed: method FilePusher.finish(callback: Optional[step_upload.OnRequestFinishFn]=…) → method FilePusher.finish(callback: step_upload.OnRequestFinishFn | None=…)
changed: method FilePusher.get_status() -> Tuple[bool, stats.Summary] → method FilePusher.get_status() -> tuple[bool, stats.Summary]

removed: property FileStreamApi.heartbeat_seconds -> Union[int, float]
changed: constructor FileStreamApi(api: internal_api.Api, run_id: str, start_time: float, timeout: float=…, settings: Optional[dict]=…) -> None → constructor FileStreamApi(api: internal_api.Api, run_id: str, start_time: float, timeout: float=…, settings: dict | None=…) -> None
changed: field ProcessedChunk.content: List[str] → field ProcessedChunk.content: list[str]
changed: field StreamCRState.cr: Optional[int] → field StreamCRState.cr: int | None
changed: field StreamCRState.last_normal: Optional[int] → field StreamCRState.last_normal: int | None
changed: function request_with_retry(func: Callable, *args: Any, **kwargs: Any) -> Union[requests.Response, requests.RequestException] → function request_with_retry(func: Callable, *args: Any, **kwargs: Any) -> requests.Response | requests.RequestException
changed: method CRDedupeFilePolicy.process_chunks(chunks: List[Chunk]) -> List[ProcessedChunk] → method CRDedupeFilePolicy.process_chunks(chunks: list[Chunk]) -> list[ProcessedChunk]
changed: method DefaultFilePolicy.process_chunks(chunks: List[Chunk]) -> Union[bool, ProcessedChunk, ProcessedBinaryChunk, List[ProcessedChunk]] → method DefaultFilePolicy.process_chunks(chunks: list[Chunk]) -> bool | ProcessedChunk | ProcessedBinaryChunk | list[ProcessedChunk]
changed: method FileStreamApi.rate_limit_seconds() -> Union[int, float] → method FileStreamApi.rate_limit_seconds() -> int | float
changed: method JsonlFilePolicy.process_chunks(chunks: List[Chunk]) -> ProcessedChunk → method JsonlFilePolicy.process_chunks(chunks: list[Chunk]) -> ProcessedChunk
changed: method SummaryFilePolicy.process_chunks(chunks: List[Chunk]) -> Union[bool, ProcessedChunk] → method SummaryFilePolicy.process_chunks(chunks: list[Chunk]) -> bool | ProcessedChunk
changed: static method CRDedupeFilePolicy.get_consecutive_offsets(console: Dict[int, str]) -> List[List[int]] → static method CRDedupeFilePolicy.get_consecutive_offsets(console: dict[int, str]) -> list[list[int]]
changed: static method CRDedupeFilePolicy.split_chunk(chunk: Chunk) -> Tuple[str, str] → static method CRDedupeFilePolicy.split_chunk(chunk: Chunk) -> tuple[str, str]
added: property FileStreamApi.heartbeat_seconds -> int | float

removed: property JobBuilder.input_types -> Dict[str, Any]
removed: property JobBuilder.output_types -> Dict[str, Any]
changed: field ArtifactSourceDict.build_context: Optional[str] → field ArtifactSourceDict.build_context: str | None
changed: field ArtifactSourceDict.dockerfile: Optional[str] → field ArtifactSourceDict.dockerfile: str | None
changed: field ArtifactSourceDict.entrypoint: List[str] → field ArtifactSourceDict.entrypoint: list[str]
changed: field GitSourceDict.build_context: Optional[str] → field GitSourceDict.build_context: str | None
changed: field GitSourceDict.dockerfile: Optional[str] → field GitSourceDict.dockerfile: str | None
changed: field GitSourceDict.entrypoint: List[str] → field GitSourceDict.entrypoint: list[str]
changed: field JobSourceDict.input_types: Dict[str, Any] → field JobSourceDict.input_types: dict[str, Any]
changed: field JobSourceDict.output_types: Dict[str, Any] → field JobSourceDict.output_types: dict[str, Any]
changed: field JobSourceDict.runtime: Optional[str] → field JobSourceDict.runtime: str | None
changed: field JobSourceDict.services: Dict[str, str] → field JobSourceDict.services: dict[str, str]
changed: field JobSourceDict.source: Union[GitSourceDict, ArtifactSourceDict, ImageSourceDict] → field JobSourceDict.source: GitSourceDict | ArtifactSourceDict | ImageSourceDict
changed: function get_min_supported_for_source_dict(source: Union[GitSourceDict, ArtifactSourceDict, ImageSourceDict]) -> Optional[Version] → function get_min_supported_for_source_dict(source: GitSourceDict | ArtifactSourceDict | ImageSourceDict) -> Version | None
changed: method JobBuilder.build(api: Api, build_context: Optional[str]=…, dockerfile: Optional[str]=…, base_image: Optional[str]=…) -> Optional[Artifact] → method JobBuilder.build(api: Api, build_context: str | None=…, dockerfile: str | None=…, base_image: str | None=…) -> Artifact | None
changed: method JobBuilder.set_config(config: Dict[str, Any]) -> None → method JobBuilder.set_config(config: dict[str, Any]) -> None
changed: method JobBuilder.set_summary(summary: Dict[str, Any]) -> None → method JobBuilder.set_summary(summary: dict[str, Any]) -> None
added: property JobBuilder.input_types -> dict[str, Any]
added: property JobBuilder.output_types -> dict[str, Any]

changed: constructor Progress(file: IO[bytes], callback: Optional[ProgressFn]=…) -> None → constructor Progress(file: IO[bytes], callback: ProgressFn | None=…) -> None

changed: field ResumeState.config: Optional[Dict[str, Any]] → field ResumeState.config: dict[str, Any] | None
changed: field ResumeState.summary: Optional[Dict[str, Any]] → field ResumeState.summary: dict[str, Any] | None
changed: field ResumeState.tags: Optional[List[str]] → field ResumeState.tags: list[str] | None
changed: field ResumeState.wandb_runtime: Optional[int] → field ResumeState.wandb_runtime: int | None
changed: method SendManager.get_server_info() -> Dict[str, Any] → method SendManager.get_server_info() -> dict[str, Any]
changed: method SendManager.get_viewer_info() -> Dict[str, Any] → method SendManager.get_viewer_info() -> dict[str, Any]
changed: method SendManager.send_run(record: Record, file_dir: Optional[str]=…) -> None → method SendManager.send_run(record: Record, file_dir: str | None=…) -> None
changed: static method SendManager.setup(root_dir: str, resume: Union[None, bool, str]) -> SendManager → static method SendManager.setup(root_dir: str, resume: None | bool | str) -> SendManager

changed: constructor ConfigState(tree: Optional[Dict[str, Any]]=…) -> None → constructor ConfigState(tree: dict[str, Any] | None=…) -> None
changed: method ConfigState.merge_resumed_config(old_config_tree: Dict[str, Any]) -> None → method ConfigState.merge_resumed_config(old_config_tree: dict[str, Any]) -> None
changed: method ConfigState.non_internal_config() -> Dict[str, Any] → method ConfigState.non_internal_config() -> dict[str, Any]
changed: method ConfigState.to_backend_dict(telemetry_record: telemetry.TelemetryRecord, framework: Optional[str], start_time_millis: int, metric_pbdicts: Sequence[Dict[int, Any]], environment_record: wandb_internal_pb2.EnvironmentRecord) -> BackendConfigDict → method ConfigState.to_backend_dict(telemetry_record: telemetry.TelemetryRecord, framework: str | None, start_time_millis: int, metric_pbdicts: Sequence[dict[int, Any]], environment_record: wandb_internal_pb2.EnvironmentRecord) -> BackendConfigDict

changed: constructor Event(event: ProtoEvent, namespace: Optional[str]) → constructor Event(event: ProtoEvent, namespace: str | None)
changed: constructor TBDirWatcher(tbwatcher: TBWatcher, logdir: str, save: bool, namespace: Optional[str], queue: PriorityQueue, force: bool=…) -> None → constructor TBDirWatcher(tbwatcher: TBWatcher, logdir: str, save: bool, namespace: str | None, queue: PriorityQueue, force: bool=…) -> None
changed: function is_tfevents_file_created_by(path: str, hostname: Optional[str], start_time: Optional[float]) -> bool → function is_tfevents_file_created_by(path: str, hostname: str | None, start_time: float | None) -> bool

removed: property LaunchAgent.thread_ids -> List[int]
changed: async method LaunchAgent.check_sweep_state(launch_spec: Dict[str, Any], api: Api) -> None → async method LaunchAgent.check_sweep_state(launch_spec: dict[str, Any], api: Api) -> None
changed: async method LaunchAgent.fail_run_queue_item(run_queue_item_id: str, message: str, phase: str, files: Optional[List[str]]=…) -> None → async method LaunchAgent.fail_run_queue_item(run_queue_item_id: str, message: str, phase: str, files: list[str] | None=…) -> None
changed: async method LaunchAgent.finish_thread_id(thread_id: int, exception: Optional[Union[Exception, LaunchDockerError]]=…) -> None → async method LaunchAgent.finish_thread_id(thread_id: int, exception: Exception | LaunchDockerError | None=…) -> None
changed: async method LaunchAgent.get_job_and_queue() -> Optional[JobSpecAndQueue] → async method LaunchAgent.get_job_and_queue() -> JobSpecAndQueue | None
changed: async method LaunchAgent.run_job(job: Dict[str, Any], queue: str, file_saver: RunQueueItemFileSaver) -> None → async method LaunchAgent.run_job(job: dict[str, Any], queue: str, file_saver: RunQueueItemFileSaver) -> None
changed: async method LaunchAgent.task_run_job(launch_spec: Dict[str, Any], job: Dict[str, Any], default_config: Dict[str, Any], api: Api, job_tracker: JobAndRunStatusTracker) -> None → async method LaunchAgent.task_run_job(launch_spec: dict[str, Any], job: dict[str, Any], default_config: dict[str, Any], api: Api, job_tracker: JobAndRunStatusTracker) -> None
changed: constructor LaunchAgent(api: Api, config: Dict[str, Any]) → constructor LaunchAgent(api: Api, config: dict[str, Any])
changed: field JobSpecAndQueue.job: Dict[str, Any] → field JobSpecAndQueue.job: dict[str, Any]
changed: function construct_agent_configs(launch_config: Optional[Dict]=…, build_config: Optional[Dict]=…) -> Tuple[Optional[Dict[str, Any]], Dict[str, Any], Dict[str, Any]] → function construct_agent_configs(launch_config: dict | None=…, build_config: dict | None=…) -> tuple[dict[str, Any] | None, dict[str, Any], dict[str, Any]]
added: property LaunchAgent.thread_ids -> list[int]

changed: field AgentConfig.builder: Optional[BuilderConfig] → field AgentConfig.builder: BuilderConfig | None
changed: field AgentConfig.entity: Optional[str] → field AgentConfig.entity: str | None
changed: field AgentConfig.environment: Optional[EnvironmentConfig] → field AgentConfig.environment: EnvironmentConfig | None
changed: field AgentConfig.max_jobs: Optional[int] → field AgentConfig.max_jobs: int | None
changed: field AgentConfig.max_schedulers: Optional[int] → field AgentConfig.max_schedulers: int | None
changed: field AgentConfig.queues: List[str] → field AgentConfig.queues: list[str]
changed: field AgentConfig.registry: Optional[RegistryConfig] → field AgentConfig.registry: RegistryConfig | None
changed: field AgentConfig.secure_mode: Optional[bool] → field AgentConfig.secure_mode: bool | None
changed: field AgentConfig.stopped_run_timeout: Optional[int] → field AgentConfig.stopped_run_timeout: int | None
changed: field AgentConfig.verbosity: Optional[int] → field AgentConfig.verbosity: int | None

changed: field JobAndRunStatusTracker.completed_status: Optional[str] → field JobAndRunStatusTracker.completed_status: str | None
changed: field JobAndRunStatusTracker.entity: Optional[str] → field JobAndRunStatusTracker.entity: str | None
changed: field JobAndRunStatusTracker.project: Optional[str] → field JobAndRunStatusTracker.project: str | None
changed: field JobAndRunStatusTracker.run: Optional[AbstractRun] → field JobAndRunStatusTracker.run: AbstractRun | None
changed: field JobAndRunStatusTracker.run_id: Optional[str] → field JobAndRunStatusTracker.run_id: str | None

changed: constructor RunQueueItemFileSaver(agent_run: Optional[wandb.Run], run_queue_item_id: str) → constructor RunQueueItemFileSaver(agent_run: wandb.Run | None, run_queue_item_id: str)
changed: method RunQueueItemFileSaver.save_contents(contents: str, fname: str, file_sub_type: FileSubtypes) -> Optional[List[str]] → method RunQueueItemFileSaver.save_contents(contents: str, fname: str, file_sub_type: FileSubtypes) -> list[str] | None

changed: async method AbstractBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: Optional[JobAndRunStatusTracker]=…) -> str → async method AbstractBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: JobAndRunStatusTracker | None=…) -> str
changed: field AbstractBuilder.builder_config: Dict[str, Any] → field AbstractBuilder.builder_config: dict[str, Any]

changed: async function build_image_from_project(launch_project: LaunchProject, api: Api, launch_config: Dict[str, Any]) -> str → async function build_image_from_project(launch_project: LaunchProject, api: Api, launch_config: dict[str, Any]) -> str
changed: function get_docker_user(launch_project: LaunchProject, runner_type: str) -> Tuple[str, int] → function get_docker_user(launch_project: LaunchProject, runner_type: str) -> tuple[str, int]
changed: function join(split_command: List[str]) -> str → function join(split_command: list[str]) -> str

changed: method BuildContextManager.create_build_context(builder_type: str) -> Tuple[str, str] → method BuildContextManager.create_build_context(builder_type: str) -> tuple[str, str]

changed: async method DockerBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: Optional[JobAndRunStatusTracker]=…) -> str → async method DockerBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: JobAndRunStatusTracker | None=…) -> str
changed: constructor DockerBuilder(environment: AbstractEnvironment, registry: AbstractRegistry, config: Dict[str, Any]) → constructor DockerBuilder(environment: AbstractEnvironment, registry: AbstractRegistry, config: dict[str, Any])
changed: static method DockerBuilder.from_config(config: Dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> DockerBuilder → static method DockerBuilder.from_config(config: dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> DockerBuilder

changed: async method KanikoBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: Optional[JobAndRunStatusTracker]=…) -> str → async method KanikoBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: JobAndRunStatusTracker | None=…) -> str
changed: constructor KanikoBuilder(environment: AbstractEnvironment, registry: AbstractRegistry, build_job_name: str=…, build_context_store: str=…, secret_name: str=…, secret_key: str=…, image: str=…, config: Optional[dict]=…) → constructor KanikoBuilder(environment: AbstractEnvironment, registry: AbstractRegistry, build_job_name: str=…, build_context_store: str=…, secret_name: str=…, secret_key: str=…, image: str=…, config: dict | None=…)
changed: field KanikoBuilder.secret_key: Optional[str] → field KanikoBuilder.secret_key: str | None
changed: field KanikoBuilder.secret_name: Optional[str] → field KanikoBuilder.secret_name: str | None

changed: async method NoOpBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: Optional[JobAndRunStatusTracker]=…) -> str → async method NoOpBuilder.build_image(launch_project: LaunchProject, entrypoint: EntryPoint, job_tracker: JobAndRunStatusTracker | None=…) -> str
changed: constructor NoOpBuilder(builder_config: Dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> None → constructor NoOpBuilder(builder_config: dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> None

changed: function create_job(path: str, job_type: str, entity: Optional[str]=…, project: Optional[str]=…, name: Optional[str]=…, description: Optional[str]=…, aliases: Optional[List[str]]=…, runtime: Optional[str]=…, entrypoint: Optional[str]=…, git_hash: Optional[str]=…, build_context: Optional[str]=…, dockerfile: Optional[str]=…) -> Optional[Artifact] → function create_job(path: str, job_type: str, entity: str | None=…, project: str | None=…, name: str | None=…, description: str | None=…, aliases: list[str] | None=…, runtime: str | None=…, entrypoint: str | None=…, git_hash: str | None=…, build_context: str | None=…, dockerfile: str | None=…) -> Artifact | None

changed: static method AwsEnvironment.from_config(config: Dict[str, str]) -> AwsEnvironment → static method AwsEnvironment.from_config(config: dict[str, str]) -> AwsEnvironment
changed: static method AwsEnvironment.from_default(region: Optional[str]=…) -> AwsEnvironment → static method AwsEnvironment.from_default(region: str | None=…) -> AwsEnvironment

changed: static method AzureEnvironment.from_config(config: dict, verify: bool=…) -> AzureEnvironment → static method AzureEnvironment.from_config(config: dict, verify: bool=…) -> Self
changed: static method AzureEnvironment.parse_uri(uri: str) -> Tuple[str, str, str] → static method AzureEnvironment.parse_uri(uri: str) -> tuple[str, str, str]

changed: function get_default_region() -> Optional[str] → function get_default_region() -> str | None
changed: function get_gcloud_config_value(config_name: str) -> Optional[str] → function get_gcloud_config_value(config_name: str) -> str | None

changed: static method LocalEnvironment.from_config(config: Dict[str, Union[Dict[str, Any], str]]) -> LocalEnvironment → static method LocalEnvironment.from_config(config: dict[str, dict[str, Any] | str]) -> LocalEnvironment

removed: property GitReference.url -> Optional[str]
changed: constructor GitReference(remote: str, ref: Optional[str]=…) -> None → constructor GitReference(remote: str, ref: str | None=…) -> None
added: property GitReference.url -> str | None

changed: constructor JobInputArguments(include: Optional[List[str]]=…, exclude: Optional[List[str]]=…, schema: Optional[dict]=…, file_path: Optional[str]=…, run_config: Optional[bool]=…) → constructor JobInputArguments(include: list[str] | None=…, exclude: list[str] | None=…, schema: dict | None=…, file_path: str | None=…, run_config: bool | None=…)
changed: function handle_config_file_input(path: str, include: Optional[List[str]]=…, exclude: Optional[List[str]]=…, schema: Optional[Any]=…) → function handle_config_file_input(path: str, include: list[str] | None=…, exclude: list[str] | None=…, schema: Any | None=…)
changed: function handle_run_config_input(include: Optional[List[str]]=…, exclude: Optional[List[str]]=…, schema: Optional[Any]=…) → function handle_run_config_input(include: list[str] | None=…, exclude: list[str] | None=…, schema: Any | None=…)

changed: function manage_config_file(path: str, include: Optional[List[str]]=…, exclude: Optional[List[str]]=…, schema: Optional[Any]=…) → function manage_config_file(path: str, include: list[str] | None=…, exclude: list[str] | None=…, schema: Any | None=…)
changed: function manage_wandb_config(include: Optional[List[str]]=…, exclude: Optional[List[str]]=…, schema: Optional[Any]=…) → function manage_wandb_config(include: list[str] | None=…, exclude: list[str] | None=…, schema: Any | None=…)

changed: function builder_from_config(config: Optional[Dict[str, Any]], environment: AbstractEnvironment, registry: AbstractRegistry) -> AbstractBuilder → function builder_from_config(config: dict[str, Any] | None, environment: AbstractEnvironment, registry: AbstractRegistry) -> AbstractBuilder
changed: function environment_from_config(config: Optional[Dict[str, Any]]) -> AbstractEnvironment → function environment_from_config(config: dict[str, Any] | None) -> AbstractEnvironment
changed: function registry_from_config(config: Optional[Dict[str, Any]], environment: AbstractEnvironment) -> AbstractRegistry → function registry_from_config(config: dict[str, Any] | None, environment: AbstractEnvironment) -> AbstractRegistry
changed: function runner_from_config(runner_name: str, api: Api, runner_config: Dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> AbstractRunner → function runner_from_config(runner_name: str, api: Api, runner_config: dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> AbstractRunner

changed: async method AbstractRegistry.get_username_password() -> Tuple[str, str] → async method AbstractRegistry.get_username_password() -> tuple[str, str]
changed: static method AbstractRegistry.from_config(config: dict) -> AbstractRegistry → static method AbstractRegistry.from_config(config: dict) -> Self

changed: async method AnonynmousRegistry.get_username_password() -> Tuple[str, str] → async method AnonynmousRegistry.get_username_password() -> tuple[str, str]
changed: static method AnonynmousRegistry.from_config(config: dict) -> AbstractRegistry → static method AnonynmousRegistry.from_config(config: dict) -> Self

changed: async method AzureContainerRegistry.get_username_password() -> Tuple[str, str] → async method AzureContainerRegistry.get_username_password() -> tuple[str, str]
changed: constructor AzureContainerRegistry(uri: Optional[str]=…, registry_name: Optional[str]=…, repo_name: Optional[str]=…) → constructor AzureContainerRegistry(uri: str | None=…, registry_name: str | None=…, repo_name: str | None=…)

changed: async method ElasticContainerRegistry.get_username_password() -> Tuple[str, str] → async method ElasticContainerRegistry.get_username_password() -> tuple[str, str]
changed: constructor ElasticContainerRegistry(uri: Optional[str]=…, account_id: Optional[str]=…, region: Optional[str]=…, repo_name: Optional[str]=…) -> None → constructor ElasticContainerRegistry(uri: str | None=…, account_id: str | None=…, region: str | None=…, repo_name: str | None=…) -> None
changed: static method ElasticContainerRegistry.from_config(config: Dict[str, str]) -> ElasticContainerRegistry → static method ElasticContainerRegistry.from_config(config: dict[str, str]) -> ElasticContainerRegistry

changed: async method GoogleArtifactRegistry.get_username_password() -> Tuple[str, str] → async method GoogleArtifactRegistry.get_username_password() -> tuple[str, str]
changed: constructor GoogleArtifactRegistry(uri: Optional[str]=…, repository: Optional[str]=…, image_name: Optional[str]=…, project: Optional[str]=…, region: Optional[str]=…) -> None → constructor GoogleArtifactRegistry(uri: str | None=…, repository: str | None=…, image_name: str | None=…, project: str | None=…, region: str | None=…) -> None

changed: async method LocalRegistry.get_username_password() -> Tuple[str, str] → async method LocalRegistry.get_username_password() -> tuple[str, str]
changed: static method LocalRegistry.from_config(config: dict) -> LocalRegistry → static method LocalRegistry.from_config(config: dict) -> Self

removed: property AbstractRun.id -> Optional[str]
changed: async method AbstractRun.get_logs() -> Optional[str] → async method AbstractRun.get_logs() -> str | None
changed: async method AbstractRunner.run(launch_project: LaunchProject, image_uri: str) -> Optional[AbstractRun] → async method AbstractRunner.run(launch_project: LaunchProject, image_uri: str) -> AbstractRun | None
changed: constructor AbstractRunner(api: Api, backend_config: Dict[str, Any]) -> None → constructor AbstractRunner(api: Api, backend_config: dict[str, Any]) -> None
changed: constructor Status(state: State=…, messages: List[str]=…) → constructor Status(state: State=…, messages: list[str]=…)
changed: method AbstractRunner.find_executable(cmd: str) -> Union[str, None] → method AbstractRunner.find_executable(cmd: str) -> str | None
added: property AbstractRun.id -> str | None

changed: static method LaunchKubernetesMonitor.monitor_namespace(namespace: str, custom_resource: Optional[CustomResource]=…) -> None → static method LaunchKubernetesMonitor.monitor_namespace(namespace: str, custom_resource: CustomResource | None=…) -> None
changed: static method LaunchKubernetesMonitor.status_count() -> Dict[State, int] → static method LaunchKubernetesMonitor.status_count() -> dict[State, int]
changed: variable CRD_STATE_DICT: Dict[str, State] → variable CRD_STATE_DICT: dict[str, State]

changed: async function maybe_create_imagepull_secret(core_api: CoreV1Api, registry: AbstractRegistry, run_id: str, namespace: str) -> Optional[V1Secret] → async function maybe_create_imagepull_secret(core_api: CoreV1Api, registry: AbstractRegistry, run_id: str, namespace: str) -> V1Secret | None
changed: async method CrdSubmittedRun.get_logs() -> Optional[str] → async method CrdSubmittedRun.get_logs() -> str | None
changed: async method KubernetesRunner.run(launch_project: LaunchProject, image_uri: str) -> Optional[AbstractRun] → async method KubernetesRunner.run(launch_project: LaunchProject, image_uri: str) -> AbstractRun | None
changed: async method KubernetesSubmittedRun.get_logs() -> Optional[str] → async method KubernetesSubmittedRun.get_logs() -> str | None
changed: constructor KubernetesRunner(api: Api, backend_config: Dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> None → constructor KubernetesRunner(api: Api, backend_config: dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> None
changed: constructor KubernetesSubmittedRun(batch_api: BatchV1Api, core_api: CoreV1Api, apps_api: AppsV1Api, network_api: NetworkingV1Api, name: str, namespace: Optional[str]=…, secret: Optional[V1Secret]=…, auxiliary_resource_label_key: Optional[str]=…) -> None → constructor KubernetesSubmittedRun(batch_api: BatchV1Api, core_api: CoreV1Api, apps_api: AppsV1Api, network_api: NetworkingV1Api, name: str, namespace: str | None=…, secret: V1Secret | None=…, auxiliary_resource_label_key: str | None=…) -> None
changed: function add_entrypoint_args_overrides(manifest: Union[dict, list], overrides: dict) -> None → function add_entrypoint_args_overrides(manifest: dict | list, overrides: dict) -> None
changed: function add_label_to_pods(manifest: Union[dict, list], label_key: str, label_value: str) -> None → function add_label_to_pods(manifest: dict | list, label_key: str, label_value: str) -> None
changed: function add_wandb_env(root: Union[dict, list], env_vars: Dict[str, str]) -> None → function add_wandb_env(root: dict | list, env_vars: dict[str, str]) -> None
changed: function apply_code_mount_configuration(manifest: Union[Dict, list], project: LaunchProject) -> None → function apply_code_mount_configuration(manifest: dict | list, project: LaunchProject) -> None
changed: function inject_entrypoint_and_args(containers: List[dict], entry_point: Optional[EntryPoint], override_args: List[str], should_override_entrypoint: bool) -> None → function inject_entrypoint_and_args(containers: list[dict], entry_point: EntryPoint | None, override_args: list[str], should_override_entrypoint: bool) -> None
changed: method KubernetesRunner.get_namespace(resource_args: Dict[str, Any], context: Dict[str, Any]) -> str → method KubernetesRunner.get_namespace(resource_args: dict[str, Any], context: dict[str, Any]) -> str

removed: property LocalSubmittedRun.id -> Optional[str]
changed: async method LocalContainerRunner.run(launch_project: LaunchProject, image_uri: str) -> Optional[AbstractRun] → async method LocalContainerRunner.run(launch_project: LaunchProject, image_uri: str) -> AbstractRun | None
changed: async method LocalSubmittedRun.get_logs() -> Optional[str] → async method LocalSubmittedRun.get_logs() -> str | None
changed: constructor LocalContainerRunner(api: Api, backend_config: Dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> None → constructor LocalContainerRunner(api: Api, backend_config: dict[str, Any], environment: AbstractEnvironment, registry: AbstractRegistry) -> None
changed: function get_docker_command(image: str, env_vars: Dict[str, str], entry_cmd: Optional[List[str]]=…, docker_args: Optional[Dict[str, Any]]=…, additional_args: Optional[List[str]]=…) -> List[str] → function get_docker_command(image: str, env_vars: dict[str, str], entry_cmd: list[str] | None=…, docker_args: dict[str, Any] | None=…, additional_args: list[str] | None=…) -> list[str]
changed: function join(split_command: List[str]) -> str → function join(split_command: list[str]) -> str
added: property LocalSubmittedRun.id -> str | None

changed: async method LocalProcessRunner.run(launch_project: LaunchProject, *args, **kwargs) -> Optional[AbstractRun] → async method LocalProcessRunner.run(launch_project: LaunchProject, *args, **kwargs) -> AbstractRun | None

changed: async function launch_sagemaker_job(launch_project: LaunchProject, sagemaker_args: Dict[str, Any], sagemaker_client: boto3.Client, log_client: Optional[boto3.Client]=…) -> SagemakerSubmittedRun → async function launch_sagemaker_job(launch_project: LaunchProject, sagemaker_args: dict[str, Any], sagemaker_client: boto3.Client, log_client: boto3.Client | None=…) -> SagemakerSubmittedRun
changed: async method SageMakerRunner.run(launch_project: LaunchProject, image_uri: str) -> Optional[AbstractRun] → async method SageMakerRunner.run(launch_project: LaunchProject, image_uri: str) -> AbstractRun | None
changed: async method SagemakerSubmittedRun.get_logs() -> Optional[str] → async method SagemakerSubmittedRun.get_logs() -> str | None
changed: constructor SageMakerRunner(api: Api, backend_config: Dict[str, Any], environment: AwsEnvironment, registry: AbstractRegistry) -> None → constructor SageMakerRunner(api: Api, backend_config: dict[str, Any], environment: AwsEnvironment, registry: AbstractRegistry) -> None
changed: constructor SagemakerSubmittedRun(training_job_name: str, client: boto3.Client, log_client: Optional[boto3.Client]=…) -> None → constructor SagemakerSubmittedRun(training_job_name: str, client: boto3.Client, log_client: boto3.Client | None=…) -> None
changed: function build_sagemaker_args(launch_project: LaunchProject, api: Api, role_arn: str, entry_point: Optional[EntryPoint], args: Optional[List[str]], max_env_length: int, image_uri: str, default_output_path: Optional[str]=…) -> Dict[str, Any] → function build_sagemaker_args(launch_project: LaunchProject, api: Api, role_arn: str, entry_point: EntryPoint | None, args: list[str] | None, max_env_length: int, image_uri: str, default_output_path: str | None=…) -> dict[str, Any]
changed: function get_role_arn(sagemaker_args: Dict[str, Any], backend_config: Dict[str, Any], account_id: str, partition: str) -> str → function get_role_arn(sagemaker_args: dict[str, Any], backend_config: dict[str, Any], account_id: str, partition: str) -> str
changed: function merge_image_uri_with_algorithm_specification(algorithm_specification: Optional[Dict[str, Any]], image_uri: Optional[str], entrypoint_command: List[str], args: Optional[List[str]]) -> Dict[str, Any] → function merge_image_uri_with_algorithm_specification(algorithm_specification: dict[str, Any] | None, image_uri: str | None, entrypoint_command: list[str], args: list[str] | None) -> dict[str, Any]

changed: async function launch_vertex_job(launch_project: LaunchProject, spec_args: Dict[str, Any], run_args: Dict[str, Any], environment: GcpEnvironment, synchronous: bool=…) -> VertexSubmittedRun → async function launch_vertex_job(launch_project: LaunchProject, spec_args: dict[str, Any], run_args: dict[str, Any], environment: GcpEnvironment, synchronous: bool=…) -> VertexSubmittedRun
changed: async method VertexRunner.run(launch_project: LaunchProject, image_uri: str) -> Optional[AbstractRun] → async method VertexRunner.run(launch_project: LaunchProject, image_uri: str) -> AbstractRun | None
changed: async method VertexSubmittedRun.get_logs() -> Optional[str] → async method VertexSubmittedRun.get_logs() -> str | None
changed: constructor VertexRunner(api: Api, backend_config: Dict[str, Any], environment: GcpEnvironment, registry: AbstractRegistry) -> None → constructor VertexRunner(api: Api, backend_config: dict[str, Any], environment: GcpEnvironment, registry: AbstractRegistry) -> None

added: class SchedulerError(Exception)
added: class SweepNotFoundError(Exception)

removed: property Scheduler.available_workers -> Dict[int, _Worker]
removed: property Scheduler.busy_workers -> Dict[int, _Worker]
changed: constructor Scheduler(api: Api, *args: Optional[Any], polling_sleep: Optional[float]=…, sweep_id: Optional[str]=…, entity: Optional[str]=…, project: Optional[str]=…, project_queue: Optional[str]=…, num_workers: Optional[Union[int, str]]=…, **kwargs: Optional[Any]) → constructor Scheduler(api: Api, *args: Any | None, polling_sleep: float | None=…, sweep_id: str | None=…, entity: str | None=…, project: str | None=…, project_queue: str | None=…, num_workers: int | str | None=…, **kwargs: Any | None)
changed: field SweepRun.args: Optional[Dict[str, Any]] → field SweepRun.args: dict[str, Any] | None
changed: field SweepRun.logs: Optional[List[str]] → field SweepRun.logs: list[str] | None
changed: field SweepRun.queued_run: Optional[public.QueuedRun] → field SweepRun.queued_run: public.QueuedRun | None
changed: method Scheduler.fail_sweep(err: Optional[str]) -> None → method Scheduler.fail_sweep(err: str | None) -> None
added: property Scheduler.available_workers -> dict[int, _Worker]
added: property Scheduler.busy_workers -> dict[int, _Worker]

changed: function check_job_exists(public_api: PublicApi, job: Optional[str]) -> bool → function check_job_exists(public_api: PublicApi, job: str | None) -> bool
changed: function construct_scheduler_args(sweep_config: Dict[str, Any], queue: str, project: str, author: Optional[str]=…, return_job: bool=…) -> Union[List[str], Dict[str, str], None] → function construct_scheduler_args(sweep_config: dict[str, Any], queue: str, project: str, author: str | None=…, return_job: bool=…) -> list[str] | dict[str, str] | None
changed: function create_sweep_command(command: Optional[List]=…) -> List → function create_sweep_command(command: list | None=…) -> list
changed: function create_sweep_command_args(command: Dict) -> Dict[str, Any] → function create_sweep_command_args(command: dict) -> dict[str, Any]
changed: function get_previous_args(run_spec: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]] → function get_previous_args(run_spec: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]
changed: function handle_sweep_config_violations(warnings: List[str]) -> None → function handle_sweep_config_violations(warnings: list[str]) -> None
changed: function load_launch_sweep_config(config: Optional[str]) -> Any → function load_launch_sweep_config(config: str | None) -> Any
changed: function load_sweep_config(sweep_config_path: str) -> Optional[Dict[str, Any]] → function load_sweep_config(sweep_config_path: str) -> dict[str, Any] | None
changed: function make_launch_sweep_entrypoint(args: Dict[str, Any], command: Optional[List[str]]) -> Tuple[Optional[List[str]], Any] → function make_launch_sweep_entrypoint(args: dict[str, Any], command: list[str] | None) -> tuple[list[str] | None, Any]
changed: function parse_sweep_id(parts_dict: dict) -> Optional[str] → function parse_sweep_id(parts_dict: dict) -> str | None
changed: function sweep_config_err_text_from_jsonschema_violations(violations: List[str]) -> str → function sweep_config_err_text_from_jsonschema_violations(violations: list[str]) -> str
changed: variable DEFAULT_SWEEP_COMMAND: List[str] → variable DEFAULT_SWEEP_COMMAND: list[str]

changed: async function get_kube_context_and_api_client(kubernetes: Any, resource_args: Dict[str, Any]) -> Tuple[Any, Any] → async function get_kube_context_and_api_client(kubernetes: Any, resource_args: dict[str, Any]) -> tuple[Any, Any]
changed: function construct_launch_spec(uri: Optional[str], job: Optional[str], api: Api, name: Optional[str], project: Optional[str], entity: Optional[str], docker_image: Optional[str], resource: Optional[str], entry_point: Optional[List[str]], version: Optional[str], resource_args: Optional[Dict[str, Any]], launch_config: Optional[Dict[str, Any]], run_id: Optional[str], repository: Optional[str], author… → function construct_launch_spec(uri: str | None, job: str | None, api: Api, name: str | None, project: str | None, entity: str | None, docker_image: str | None, resource: str | None, entry_point: list[str] | None, version: str | None, resource_args: dict[str, Any] | None, launch_config: dict[str, Any] | None, run_id: str | None, repository: str | None, author: str | None, sweep_id: str | None=…) -…
changed: function diff_pip_requirements(req_1: List[str], req_2: List[str]) -> Dict[str, str] → function diff_pip_requirements(req_1: list[str], req_2: list[str]) -> dict[str, str]
changed: function fetch_and_validate_template_variables(runqueue: Any, fields: dict) -> Dict[str, Any] → function fetch_and_validate_template_variables(runqueue: Any, fields: dict) -> dict[str, Any]
changed: function get_current_python_version() -> Tuple[str, str] → function get_current_python_version() -> tuple[str, str]
changed: function get_default_entity(api: Api, launch_config: Optional[Dict[str, Any]]) → function get_default_entity(api: Api, launch_config: dict[str, Any] | None)
changed: function get_entrypoint_file(entrypoint: List[str]) -> Optional[str] → function get_entrypoint_file(entrypoint: list[str]) -> str | None
changed: function get_local_python_deps(dir: str, filename: str=…) -> Optional[str] → function get_local_python_deps(dir: str, filename: str=…) -> str | None
changed: function get_project_from_job(job: str) -> Optional[str] → function get_project_from_job(job: str) -> str | None
changed: function macro_sub(original: str, sub_dict: Dict[str, Optional[str]]) -> str → function macro_sub(original: str, sub_dict: dict[str, str | None]) -> str
changed: function parse_wandb_uri(uri: str) -> Tuple[str, str, str] → function parse_wandb_uri(uri: str) -> tuple[str, str, str]
changed: function recursive_macro_sub(source: Any, sub_dict: Dict[str, Optional[str]]) -> Any → function recursive_macro_sub(source: Any, sub_dict: dict[str, str | None]) -> Any
changed: function resolve_build_and_registry_config(default_launch_config: Optional[Dict[str, Any]], build_config: Optional[Dict[str, Any]], registry_config: Optional[Dict[str, Any]]) -> Tuple[Dict[str, Any], Dict[str, Any]] → function resolve_build_and_registry_config(default_launch_config: dict[str, Any] | None, build_config: dict[str, Any] | None, registry_config: dict[str, Any] | None) -> tuple[dict[str, Any], dict[str, Any]]
changed: function set_project_entity_defaults(uri: Optional[str], job: Optional[str], api: Api, project: Optional[str], entity: Optional[str], launch_config: Optional[Dict[str, Any]]) -> Tuple[Optional[str], str] → function set_project_entity_defaults(uri: str | None, job: str | None, api: Api, project: str | None, entity: str | None, launch_config: dict[str, Any] | None) -> tuple[str | None, str]
changed: function strip_resource_args_and_template_vars(launch_spec: Dict[str, Any]) -> None → function strip_resource_args_and_template_vars(launch_spec: dict[str, Any]) -> None
changed: function validate_build_and_registry_configs(build_config: Dict[str, Any], registry_config: Dict[str, Any]) -> None → function validate_build_and_registry_configs(build_config: dict[str, Any], registry_config: dict[str, Any]) -> None
changed: function validate_launch_spec_source(launch_spec: Dict[str, Any]) -> None → function validate_launch_spec_source(launch_spec: dict[str, Any]) -> None
changed: function validate_wandb_python_deps(requirements_file: Optional[str], dir: str) -> None → function validate_wandb_python_deps(requirements_file: str | None, dir: str) -> None
changed: function warn_failed_packages_from_build_logs(log: str, image_uri: str, api: Api, job_tracker: Optional[JobAndRunStatusTracker]) -> None → function warn_failed_packages_from_build_logs(log: str, image_uri: str, api: Api, job_tracker: JobAndRunStatusTracker | None) -> None
changed: function yield_containers(root: Union[dict, list]) -> Iterator[dict] → function yield_containers(root: dict | list) -> Iterator[dict]
changed: variable MAX_ENV_LENGTHS: Dict[str, int] → variable MAX_ENV_LENGTHS: dict[str, int]

changed: field WandbReference.entity: Optional[str] → field WandbReference.entity: str | None
changed: field WandbReference.host: Optional[str] → field WandbReference.host: str | None
changed: field WandbReference.job_name: Optional[str] → field WandbReference.job_name: str | None
changed: field WandbReference.path: Optional[str] → field WandbReference.path: str | None
changed: field WandbReference.project: Optional[str] → field WandbReference.project: str | None
changed: field WandbReference.ref_type: Optional[ReferenceType] → field WandbReference.ref_type: ReferenceType | None
changed: field WandbReference.run_id: Optional[str] → field WandbReference.run_id: str | None
changed: static method WandbReference.parse(uri: str) -> Optional[WandbReference] → static method WandbReference.parse(uri: str) -> WandbReference | None

changed: constructor CappedDict(max_size: Optional[int]=…) -> None → constructor CappedDict(max_size: int | None=…) -> None

changed: function dict_from_config_file(filename: str, must_exist: bool=…) -> Optional[Dict[str, Any]] → function dict_from_config_file(filename: str, must_exist: bool=…) -> dict[str, Any] | None

changed: field ExitHooks.exception: Optional[BaseException] → field ExitHooks.exception: BaseException | None
changed: method ExitHooks.exc_handler(exc_type: Type[BaseException], exc: BaseException, tb: TracebackType) -> None → method ExitHooks.exc_handler(exc_type: type[BaseException], exc: BaseException, tb: TracebackType) -> None

changed: function split_files(files: Dict[str, Any], max_bytes: int=…) -> Iterable[Dict[str, Dict]] → function split_files(files: dict[str, Any], max_bytes: int=…) -> Iterable[dict[str, dict]]

changed: function filtered_dir(root: str, include_fn: Union[Callable[[str, str], bool], Callable[[str], bool]], exclude_fn: Union[Callable[[str, str], bool], Callable[[str], bool]]) -> Generator[str, None, None] → function filtered_dir(root: str, include_fn: Callable[[str, str], bool] | Callable[[str], bool], exclude_fn: Callable[[str, str], bool] | Callable[[str], bool]) -> Generator[str, None, None]

changed: field FsmEntry.action: Optional[Callable[[T_FsmInputs], None]] → field FsmEntry.action: Callable[[T_FsmInputs], None] | None
changed: field FsmEntry.target_state: Type[FsmState[T_FsmInputs, T_FsmContext]] → field FsmEntry.target_state: type[FsmState[T_FsmInputs, T_FsmContext]]

removed: property GitRepo.email -> Optional[str]
removed: property GitRepo.repo -> Optional[Repo]
removed: variable Repo
changed: constructor GitRepo(root: Optional[str]=…, remote: str=…, lazy: bool=…, remote_url: Optional[str]=…, commit: Optional[str]=…) -> None → constructor GitRepo(root: str | None=…, remote: str=…, lazy: bool=…, remote_url: str | None=…, commit: str | None=…) -> None
changed: method GitRepo.is_untracked(file_name: str) -> Optional[bool] → method GitRepo.is_untracked(file_name: str) -> bool | None
changed: method GitRepo.tag(name: str, message: Optional[str]) -> Any → method GitRepo.tag(name: str, message: str | None) -> Any
added: property GitRepo.email -> str | None
added: property GitRepo.repo -> Repo | None

changed: function register_post_import_hook(hook: Union[str, Callable], hook_id: str, name: str) -> None → function register_post_import_hook(hook: str | Callable, hook_id: str, name: str) -> None
changed: function unregister_post_import_hook(name: str, hook_id: Optional[str]) -> None → function unregister_post_import_hook(name: str, hook_id: str | None) -> None
changed: method ImportHookFinder.find_module(fullname: str, path: Optional[str]=…) -> Optional[_ImportHookChainedLoader] → method ImportHookFinder.find_module(fullname: str, path: str | None=…) -> _ImportHookChainedLoader | None
changed: method ImportHookFinder.find_spec(fullname: str, path: Optional[str]=…, target: Any=…) -> Any → method ImportHookFinder.find_spec(fullname: str, path: str | None=…, target: Any=…) -> Any

changed: function jupyter_progress_bar(min: float=…, max: float=…) -> Optional[ProgressWidget] → function jupyter_progress_bar(min: float=…, max: float=…) -> ProgressWidget | None

changed: function loads(obj: Union[str, bytes]) -> Any → function loads(obj: str | bytes) -> Any

changed: constructor PreInitObject(name: str, destination: Optional[Any]=…) -> None → constructor PreInitObject(name: str, destination: Any | None=…) -> None
changed: function PreInitCallable(name: str, destination: Optional[Any]=…) -> Callable → function PreInitCallable(name: str, destination: Any | None=…) -> Callable

changed: function dict_from_proto_list(obj_list: RepeatedCompositeFieldContainer) -> Dict[str, Any] → function dict_from_proto_list(obj_list: RepeatedCompositeFieldContainer) -> dict[str, Any]
changed: function message_to_dict(message: Message) -> Dict[str, Any] → function message_to_dict(message: Message) -> dict[str, Any]
changed: function proto_encode_to_dict(pb_obj: Union[tpb.TelemetryRecord, pb.MetricRecord]) -> Dict[int, Any] → function proto_encode_to_dict(pb_obj: tpb.TelemetryRecord | pb.MetricRecord) -> dict[int, Any]

changed: async function retry_async(backoff: Backoff, fn: Callable[..., Awaitable[_R]], *args: Any, on_exc: Optional[Callable[[Exception], None]]=…, **kwargs: Any) -> _R → async function retry_async(backoff: Backoff, fn: Callable[..., Awaitable[_R]], *args: Any, on_exc: Callable[[Exception], None] | None=…, **kwargs: Any) -> _R
changed: constructor ExponentialBackoff(initial_sleep: datetime.timedelta, max_sleep: datetime.timedelta, max_retries: Optional[int]=…, timeout_at: Optional[datetime.datetime]=…) -> None → constructor ExponentialBackoff(initial_sleep: datetime.timedelta, max_sleep: datetime.timedelta, max_retries: int | None=…, timeout_at: datetime.datetime | None=…) -> None
changed: constructor Retry(call_fn: Callable[..., _R], retry_timedelta: Optional[datetime.timedelta]=…, retry_cancel_event: Optional[threading.Event]=…, num_retries: Optional[int]=…, check_retry_fn: CheckRetryFnType=…, retryable_exceptions: Optional[Tuple[Type[Exception], ...]]=…, error_prefix: str=…, retry_callback: Optional[Callable[[int, str], Any]]=…) -> None → constructor Retry(call_fn: Callable[..., _R], retry_timedelta: datetime.timedelta | None=…, retry_cancel_event: threading.Event | None=…, num_retries: int | None=…, check_retry_fn: CheckRetryFnType=…, retryable_exceptions: tuple[type[Exception], ...] | None=…, error_prefix: str=…, retry_callback: Callable[[int, str], Any] | None=…) -> None
changed: constructor TransientError(msg: Optional[str]=…, exc: Optional[BaseException]=…) -> None → constructor TransientError(msg: str | None=…, exc: BaseException | None=…) -> None

changed: method ServiceConnection.api_init_request(settings: wandb_settings_pb2.Settings) -> None → method ServiceConnection.api_init_request(settings: wandb_settings_pb2.Settings) -> wandb_api_pb2.ServerApiInitResponse
added: async method ServiceConnection.api_request_async(api_request: wandb_api_pb2.ApiRequest) -> MailboxHandle[wandb_api_pb2.ApiResponse]
added: method ServiceConnection.api_cleanup_request(api_id: str) -> None

changed: function sparkify(series: List[Union[float, int]]) -> str → function sparkify(series: list[float | int]) -> str

changed: function context(run: Optional[wandb_run.Run]=…, obj: Optional[TelemetryRecord]=…) -> ContextManager[TelemetryRecord] → function context(run: wandb_run.Run | None=…, obj: TelemetryRecord | None=…) -> AbstractContextManager[TelemetryRecord]
changed: function list_telemetry_imports(only_imported: bool=…) -> Set[str] → function list_telemetry_imports(only_imported: bool=…) -> set[str]

added: class ServerResponseError(Exception)

changed: function artifact_with_path_or_paths(name: str, verify_dir: Optional[str]=…, singular: bool=…) -> Artifact → function artifact_with_path_or_paths(name: str, verify_dir: str | None=…, singular: bool=…) -> Artifact
changed: function check_graphql_put(api: Api, host: str) -> Tuple[bool, Optional[str]] → function check_graphql_put(api: Api, host: str) -> tuple[bool, str | None]
changed: function log_use_download_artifact(artifact: Artifact, alias: str, name: str, download_dir: str, failed_test_strings: List[str], add_extra_file: bool) -> Tuple[bool, Optional[Artifact], List[str]] → function log_use_download_artifact(artifact: Artifact, alias: str, name: str, download_dir: str, failed_test_strings: list[str], add_extra_file: bool) -> tuple[bool, Artifact | None, list[str]]
changed: function print_results(failed_test_or_tests: Optional[Union[str, List[str]]], warning: bool) -> None → function print_results(failed_test_or_tests: str | list[str] | None, warning: bool) -> None
changed: function verify_digest(downloaded: Artifact, computed: Artifact, fails_list: List[str]) -> None → function verify_digest(downloaded: Artifact, computed: Artifact, fails_list: list[str]) -> None
changed: function verify_manifest(downloaded_manifest: Dict[str, Any], computed_manifest: Dict[str, Any], fails_list: List[str]) -> None → function verify_manifest(downloaded_manifest: dict[str, Any], computed_manifest: dict[str, Any], fails_list: list[str]) -> None

removed: property Metric.goal -> Optional[str]
removed: property Metric.hidden -> Optional[bool]
removed: property Metric.step_metric -> Optional[str]
removed: property Metric.step_sync -> Optional[bool]
removed: property Metric.summary -> Optional[Tuple[str, ...]]
changed: constructor Metric(name: str, step_metric: Optional[str]=…, step_sync: Optional[bool]=…, hidden: Optional[bool]=…, summary: Optional[Sequence[str]]=…, goal: Optional[str]=…, overwrite: Optional[bool]=…) -> None → constructor Metric(name: str, step_metric: str | None=…, step_sync: bool | None=…, hidden: bool | None=…, summary: Sequence[str] | None=…, goal: str | None=…, overwrite: bool | None=…) -> None
added: property Metric.goal -> str | None
added: property Metric.hidden -> bool | None
added: property Metric.step_metric -> str | None
added: property Metric.step_sync -> bool | None
added: property Metric.summary -> tuple[str, ...] | None

changed: variable requirement_env_var_mapping: Dict[str, str] → variable requirement_env_var_mapping: dict[str, str]

changed: method SummaryDict.update(d: t.Dict) → method SummaryDict.update(d: dict)

changed: function controller(sweep_id_or_config: Optional[Union[str, Dict]]=…, entity: Optional[str]=…, project: Optional[str]=…) -> _WandbController → function controller(sweep_id_or_config: str | dict | None=…, entity: str | None=…, project: str | None=…) -> _WandbController
changed: function sweep(sweep: Union[dict, Callable], entity: Optional[str]=…, project: Optional[str]=…, prior_runs: Optional[List[str]]=…) -> str → function sweep(sweep: dict | Callable, entity: str | None=…, project: str | None=…, prior_runs: list[str] | None=…) -> str

changed: function get_runs(include_offline: bool=…, include_online: bool=…, include_synced: bool=…, include_unsynced: bool=…, exclude_globs: Optional[List[str]]=…, include_globs: Optional[List[str]]=…) → function get_runs(include_offline: bool=…, include_online: bool=…, include_synced: bool=…, include_unsynced: bool=…, exclude_globs: list[str] | None=…, include_globs: list[str] | None=…)

added: function time_string_to_seconds(time_str: str) -> int

changed: field Agent.DEFAULT_SWEEP_COMMAND: List[str] → field Agent.DEFAULT_SWEEP_COMMAND: list[str]
changed: function agent(sweep_id: str, function: Optional[Callable]=…, entity: Optional[str]=…, project: Optional[str]=…, count: Optional[int]=…, forward_signals: bool=…) -> None → function agent(sweep_id: str, function: Callable | None=…, entity: str | None=…, project: str | None=…, count: int | None=…, forward_signals: bool=…) -> None