Add files using upload-large-folder tool

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_autocast_to_reduced_precision_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor _autocast_to_reduced_precision(const at::Tensor & self, bool cuda_enabled, bool cpu_enabled, at::ScalarType cuda_dtype, at::ScalarType cpu_dtype);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cast_Float.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_cast_Float_ops.h>
+
+namespace at {
+
+
+// aten::_cast_Float(Tensor self, bool non_blocking=False) -> Tensor
+inline at::Tensor _cast_Float(const at::Tensor & self, bool non_blocking=false) {
+    return at::_ops::_cast_Float::call(self, non_blocking);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_rowwise_prune_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _rowwise_prune {
+  using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, const at::Tensor &, at::ScalarType);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_rowwise_prune")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_rowwise_prune(Tensor weight, Tensor mask, ScalarType compressed_indices_dtype) -> (Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & weight, const at::Tensor & mask, at::ScalarType compressed_indices_dtype);
+  static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & weight, const at::Tensor & mask, at::ScalarType compressed_indices_dtype);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_softmax_backward_data_native.h

@@ -0,0 +1,23 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor & _sparse_softmax_backward_data_out(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor softmax_backward_sparse_cpu(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self);
+TORCH_API at::Tensor softmax_backward_sparse_cuda(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_use_cudnn_ctc_loss_cuda_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API bool _use_cudnn_ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank);
+TORCH_API bool _use_cudnn_ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank);
+
+} // namespace cuda
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_validate_sparse_csr_tensor_args_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _validate_sparse_csr_tensor_args {
+  using schema = void (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_validate_sparse_csr_tensor_args")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_validate_sparse_csr_tensor_args(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size) -> ()")
+  static void call(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size);
+  static void redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/atan2_meta_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor atan2(const at::Tensor & self, const at::Tensor & other);
+TORCH_API at::Tensor & atan2_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other);
+TORCH_API at::Tensor & atan2_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+TORCH_API at::Tensor & atan2_(at::Tensor & self, const at::Tensor & other);
+
+} // namespace meta
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/col_indices_copy_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & col_indices_copy_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & col_indices_copy_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exponential_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API exponential_ {
+  using schema = at::Tensor & (at::Tensor &, double, c10::optional<at::Generator>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::exponential_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "exponential_(Tensor(a!) self, float lambd=1, *, Generator? generator=None) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, double lambd, c10::optional<at::Generator> generator);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, double lambd, c10::optional<at::Generator> generator);
+};
+
+struct TORCH_API exponential_out {
+  using schema = at::Tensor & (const at::Tensor &, double, c10::optional<at::Generator>, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::exponential")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "exponential.out(Tensor self, float lambd=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, double lambd, c10::optional<at::Generator> generator, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double lambd, c10::optional<at::Generator> generator, at::Tensor & out);
+};
+
+struct TORCH_API exponential {
+  using schema = at::Tensor (const at::Tensor &, double, c10::optional<at::Generator>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::exponential")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "exponential(Tensor self, float lambd=1, *, Generator? generator=None) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, double lambd, c10::optional<at::Generator> generator);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double lambd, c10::optional<at::Generator> generator);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/int_repr_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & int_repr_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & int_repr_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/log1p_meta_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor log1p(const at::Tensor & self);
+TORCH_API at::Tensor & log1p_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & log1p_outf(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor & log1p_(at::Tensor & self);
+
+} // namespace meta
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logdet_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor logdet(const at::Tensor & self);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/max_pool2d_with_indices_cpu_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> max_pool2d_with_indices(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride={}, at::IntArrayRef padding=0, at::IntArrayRef dilation=1, bool ceil_mode=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> max_pool2d_with_indices_out(at::Tensor & out, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride={}, at::IntArrayRef padding=0, at::IntArrayRef dilation=1, bool ceil_mode=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> max_pool2d_with_indices_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out, at::Tensor & indices);
+
+} // namespace cpu
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/neg_meta_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor neg(const at::Tensor & self);
+TORCH_API at::Tensor & neg_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & neg_outf(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor & neg_(at::Tensor & self);
+
+} // namespace meta
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/norm_cpu_dispatch.h

@@ -0,0 +1,28 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor norm(const at::Tensor & self, const c10::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype);
+TORCH_API at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const c10::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype);
+TORCH_API at::Tensor & norm_outf(const at::Tensor & self, const c10::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype, at::Tensor & out);
+TORCH_API at::Tensor norm(const at::Tensor & self, const c10::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim=false);
+TORCH_API at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const c10::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim=false);
+TORCH_API at::Tensor & norm_outf(const at::Tensor & self, const c10::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, at::Tensor & out);
+
+} // namespace cpu
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/norm_except_dim_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor norm_except_dim(const at::Tensor & v, int64_t pow=2, int64_t dim=0);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/row_indices_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API row_indices {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::row_indices")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "row_indices(Tensor(a) self) -> Tensor(a)")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_modified_bessel_k1_compositeexplicitautogradnonfunctional_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautogradnonfunctional {
+
+TORCH_API at::Tensor special_modified_bessel_k1(const at::Tensor & self);
+
+} // namespace compositeexplicitautogradnonfunctional
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,28 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor special_shifted_chebyshev_polynomial_t(const at::Scalar & x, const at::Tensor & n);
+TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_t_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n);
+TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_t_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out);
+TORCH_API at::Tensor special_shifted_chebyshev_polynomial_t(const at::Tensor & x, const at::Scalar & n);
+TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_t_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n);
+TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_t_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/_validators.py

@@ -0,0 +1,121 @@
+"""Internal validation utilities that are specific to artifacts."""
+
+from __future__ import annotations
+
+import re
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, cast, overload
+
+from wandb.sdk.artifacts.exceptions import (
+    ArtifactFinalizedError,
+    ArtifactNotLoggedError,
+)
+
+if TYPE_CHECKING:
+    from typing import Collection, Final, Iterable, Union
+
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    ArtifactT = TypeVar("ArtifactT", bound=Artifact)
+    T = TypeVar("T")
+    ClassInfo = Union[type[T], tuple[type[T], ...]]
+
+
+REGISTRY_PREFIX: Final[str] = "wandb-registry-"
+
+
+# For mypy checks
+@overload
+def always_list(obj: Iterable[T], base_type: ClassInfo = ...) -> list[T]: ...
+@overload
+def always_list(obj: T, base_type: ClassInfo = ...) -> list[T]: ...
+
+
+def always_list(obj: Any, base_type: Any = (str, bytes)) -> list[T]:
+    """Return a guaranteed list of objects from a single instance OR iterable of such objects.
+
+    By default, assume the returned list should have string-like elements (i.e. `str`/`bytes`).
+
+    Adapted from `more_itertools.always_iterable`, but simplified for internal use.  See:
+    https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_iterable
+    """
+    return [obj] if isinstance(obj, base_type) else list(obj)
+
+
+def validate_aliases(aliases: Collection[str] | str) -> list[str]:
+    """Validate the artifact aliases and return them as a list.
+
+    Raises:
+        ValueError: If any of the aliases contain invalid characters.
+    """
+    aliases_list = always_list(aliases)
+
+    invalid_chars = ("/", ":")
+    if any(char in alias for alias in aliases_list for char in invalid_chars):
+        raise ValueError(
+            f"Aliases must not contain any of the following characters: {', '.join(invalid_chars)}"
+        )
+    return aliases_list
+
+
+_VALID_TAG_PATTERN: re.Pattern[str] = re.compile(r"^[-\w]+( +[-\w]+)*$")
+
+
+def validate_tags(tags: Collection[str] | str) -> list[str]:
+    """Validate the artifact tag names and return them as a deduped list.
+
+    In the case of duplicates, only keep the first tag, and otherwise maintain the order of appearance.
+
+    Raises:
+        ValueError: If any of the tags contain invalid characters.
+    """
+    tags_list = always_list(tags)
+
+    if any(not _VALID_TAG_PATTERN.match(tag) for tag in tags_list):
+        raise ValueError(
+            "Invalid tag(s).  "
+            "Tags must only contain alphanumeric characters separated by hyphens, underscores, and/or spaces."
+        )
+    return list(dict.fromkeys(tags_list))
+
+
+DecoratedF = TypeVar("DecoratedF", bound=Callable[..., Any])
+"""Type hint for a decorated function that'll preserve its signature (e.g. for arg autocompletion in IDEs)."""
+
+
+def ensure_logged(method: DecoratedF) -> DecoratedF:
+    """Decorator to ensure that an Artifact method can only be called if the artifact has been logged.
+
+    If the method is called on an artifact that's not logged, `ArtifactNotLoggedError` is raised.
+    """
+    # For clarity, use the qualified (full) name of the method
+    method_fullname = method.__qualname__
+
+    @wraps(method)
+    def wrapper(self: ArtifactT, *args: Any, **kwargs: Any) -> Any:
+        if self.is_draft():
+            raise ArtifactNotLoggedError(fullname=method_fullname, obj=self)
+        return method(self, *args, **kwargs)
+
+    return cast(DecoratedF, wrapper)
+
+
+def ensure_not_finalized(method: DecoratedF) -> DecoratedF:
+    """Decorator to ensure that an `Artifact` method can only be called if the artifact isn't finalized.
+
+    If the method is called on an artifact that's not logged, `ArtifactFinalizedError` is raised.
+    """
+    # For clarity, use the qualified (full) name of the method
+    method_fullname = method.__qualname__
+
+    @wraps(method)
+    def wrapper(self: ArtifactT, *args: Any, **kwargs: Any) -> Any:
+        if self._final:
+            raise ArtifactFinalizedError(fullname=method_fullname, obj=self)
+        return method(self, *args, **kwargs)
+
+    return cast(DecoratedF, wrapper)
+
+
+def is_artifact_registry_project(project: str) -> bool:
+    return project.startswith(REGISTRY_PREFIX)

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact.py

@@ -0,0 +1,2358 @@
+"""Artifact class."""
+
+from __future__ import annotations
+
+import atexit
+import concurrent.futures
+import contextlib
+import json
+import logging
+import multiprocessing.dummy
+import os
+import re
+import shutil
+import stat
+import tempfile
+import time
+from copy import copy
+from datetime import datetime, timedelta
+from functools import partial
+from pathlib import PurePosixPath
+from typing import IO, TYPE_CHECKING, Any, Dict, Iterator, Literal, Sequence, Type, cast
+from urllib.parse import urlparse
+
+import requests
+
+import wandb
+from wandb import data_types, env, util
+from wandb.apis.normalize import normalize_exceptions
+from wandb.apis.public import ArtifactCollection, ArtifactFiles, RetryingClient, Run
+from wandb.data_types import WBValue
+from wandb.errors.term import termerror, termlog, termwarn
+from wandb.sdk.artifacts._validators import (
+    ensure_logged,
+    ensure_not_finalized,
+    validate_aliases,
+    validate_tags,
+)
+from wandb.sdk.artifacts.artifact_download_logger import ArtifactDownloadLogger
+from wandb.sdk.artifacts.artifact_instance_cache import artifact_instance_cache
+from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
+from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+from wandb.sdk.artifacts.artifact_manifests.artifact_manifest_v1 import (
+    ArtifactManifestV1,
+)
+from wandb.sdk.artifacts.artifact_state import ArtifactState
+from wandb.sdk.artifacts.artifact_ttl import ArtifactTTL
+from wandb.sdk.artifacts.exceptions import ArtifactNotLoggedError, WaitTimeoutError
+from wandb.sdk.artifacts.staging import get_staging_dir
+from wandb.sdk.artifacts.storage_handlers.gcs_handler import _GCSIsADirectoryError
+from wandb.sdk.artifacts.storage_layout import StorageLayout
+from wandb.sdk.artifacts.storage_policies import WANDB_STORAGE_POLICY
+from wandb.sdk.artifacts.storage_policy import StoragePolicy
+from wandb.sdk.data_types._dtypes import Type as WBType
+from wandb.sdk.data_types._dtypes import TypeRegistry
+from wandb.sdk.internal.internal_api import Api as InternalApi
+from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
+from wandb.sdk.lib import filesystem, retry, runid, telemetry
+from wandb.sdk.lib.deprecate import Deprecated, deprecate
+from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, md5_file_b64
+from wandb.sdk.lib.mailbox import Mailbox
+from wandb.sdk.lib.paths import FilePathStr, LogicalPath, StrPath, URIStr
+from wandb.sdk.lib.runid import generate_id
+
+reset_path = util.vendor_setup()
+
+from wandb_gql import gql  # noqa: E402
+
+reset_path()
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from wandb.sdk.interface.message_future import MessageFuture
+
+
+class Artifact:
+    """Flexible and lightweight building block for dataset and model versioning.
+
+    Construct an empty W&B Artifact. Populate an artifacts contents with methods that
+    begin with `add`. Once the artifact has all the desired files, you can call
+    `wandb.log_artifact()` to log it.
+
+    Args:
+        name: A human-readable name for the artifact. Use the name to identify
+            a specific artifact in the W&B App UI or programmatically. You can
+            interactively reference an artifact with the `use_artifact` Public API.
+            A name can contain letters, numbers, underscores, hyphens, and dots.
+            The name must be unique across a project.
+        type: The artifact's type. Use the type of an artifact to both organize
+            and differentiate artifacts. You can use any string that contains letters,
+            numbers, underscores, hyphens, and dots. Common types include `dataset` or `model`.
+            Include `model` within your type string if you want to link the artifact
+            to the W&B Model Registry.
+        description: A description of the artifact. For Model or Dataset Artifacts,
+            add documentation for your standardized team model or dataset card. View
+            an artifact's description programmatically with the `Artifact.description`
+            attribute or programmatically with the W&B App UI. W&B renders the
+            description as markdown in the W&B App.
+        metadata: Additional information about an artifact. Specify metadata as a
+            dictionary of key-value pairs. You can specify no more than 100 total keys.
+
+    Returns:
+        An `Artifact` object.
+    """
+
+    _TMP_DIR = tempfile.TemporaryDirectory("wandb-artifacts")
+    atexit.register(_TMP_DIR.cleanup)
+
+    def __init__(
+        self,
+        name: str,
+        type: str,
+        description: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        incremental: bool = False,
+        use_as: str | None = None,
+    ) -> None:
+        if not re.match(r"^[a-zA-Z0-9_\-.]+$", name):
+            raise ValueError(
+                f"Artifact name may only contain alphanumeric characters, dashes, "
+                f"underscores, and dots. Invalid name: {name}"
+            )
+        if type == "job" or type.startswith("wandb-"):
+            raise ValueError(
+                "Artifact types 'job' and 'wandb-*' are reserved for internal use. "
+                "Please use a different type."
+            )
+        if incremental:
+            termwarn("Using experimental arg `incremental`")
+
+        # Internal.
+        self._client: RetryingClient | None = None
+
+        storage_policy_cls = StoragePolicy.lookup_by_name(WANDB_STORAGE_POLICY)
+        layout = StorageLayout.V1 if env.get_use_v1_artifacts() else StorageLayout.V2
+        policy_config = {"storageLayout": layout}
+        self._storage_policy = storage_policy_cls.from_config(config=policy_config)
+
+        self._tmp_dir: tempfile.TemporaryDirectory | None = None
+        self._added_objs: dict[int, tuple[WBValue, ArtifactManifestEntry]] = {}
+        self._added_local_paths: dict[str, ArtifactManifestEntry] = {}
+        self._save_future: MessageFuture | None = None
+        self._download_roots: set[str] = set()
+        # Set by new_draft(), otherwise the latest artifact will be used as the base.
+        self._base_id: str | None = None
+        # Properties.
+        self._id: str | None = None
+        self._client_id: str = runid.generate_id(128)
+        self._sequence_client_id: str = runid.generate_id(128)
+        self._entity: str | None = None
+        self._project: str | None = None
+        self._name: str = name  # includes version after saving
+        self._version: str | None = None
+        self._source_entity: str | None = None
+        self._source_project: str | None = None
+        self._source_name: str = name  # includes version after saving
+        self._source_version: str | None = None
+        self._type: str = type
+        self._description: str | None = description
+        self._metadata: dict = self._normalize_metadata(metadata)
+        self._ttl_duration_seconds: int | None = None
+        self._ttl_is_inherited: bool = True
+        self._ttl_changed: bool = False
+        self._aliases: list[str] = []
+        self._saved_aliases: list[str] = []
+        self._tags: list[str] = []
+        self._saved_tags: list[str] = []
+        self._distributed_id: str | None = None
+        self._incremental: bool = incremental
+        self._use_as: str | None = use_as
+        self._state: ArtifactState = ArtifactState.PENDING
+        self._manifest: ArtifactManifest | None = ArtifactManifestV1(
+            self._storage_policy
+        )
+        self._commit_hash: str | None = None
+        self._file_count: int | None = None
+        self._created_at: str | None = None
+        self._updated_at: str | None = None
+        self._final: bool = False
+
+        # Cache.
+        artifact_instance_cache[self._client_id] = self
+
+    def __repr__(self) -> str:
+        return f"<Artifact {self.id or self.name}>"
+
+    @classmethod
+    def _from_id(cls, artifact_id: str, client: RetryingClient) -> Artifact | None:
+        artifact = artifact_instance_cache.get(artifact_id)
+        if artifact is not None:
+            return artifact
+
+        query = gql(
+            """
+            query ArtifactByID($id: ID!) {
+                artifact(id: $id) {
+                    ...ArtifactFragment
+                }
+            }
+            """
+            + _gql_artifact_fragment()
+        )
+        response = client.execute(
+            query,
+            variable_values={"id": artifact_id},
+        )
+        attrs = response.get("artifact")
+        if attrs is None:
+            return None
+
+        src_collection = attrs["artifactSequence"]
+        src_project = src_collection["project"]
+
+        entity_name = src_project["entityName"] if src_project else ""
+        project_name = src_project["name"] if src_project else ""
+
+        name = "{}:v{}".format(src_collection["name"], attrs["versionIndex"])
+        return cls._from_attrs(entity_name, project_name, name, attrs, client)
+
+    @classmethod
+    def _from_name(
+        cls,
+        *,
+        entity: str,
+        project: str,
+        name: str,
+        client: RetryingClient,
+        enable_tracking: bool = False,
+    ) -> Artifact:
+        server_supports_enabling_artifact_usage_tracking = (
+            InternalApi().server_project_type_introspection()
+        )
+        query_vars = ["$entityName: String!", "$projectName: String!", "$name: String!"]
+        query_args = ["name: $name"]
+        if server_supports_enabling_artifact_usage_tracking:
+            query_vars.append("$enableTracking: Boolean")
+            query_args.append("enableTracking: $enableTracking")
+
+        vars_str = ", ".join(query_vars)
+        args_str = ", ".join(query_args)
+
+        query = gql(
+            f"""
+            query ArtifactByName({vars_str}) {{
+                project(name: $projectName, entityName: $entityName) {{
+                    artifact({args_str}) {{
+                        ...ArtifactFragment
+                    }}
+                }}
+            }}
+            {_gql_artifact_fragment()}
+            """
+        )
+        query_variable_values: dict[str, Any] = {
+            "entityName": entity,
+            "projectName": project,
+            "name": name,
+        }
+        if server_supports_enabling_artifact_usage_tracking:
+            query_variable_values["enableTracking"] = enable_tracking
+
+        response = client.execute(
+            query,
+            variable_values=query_variable_values,
+        )
+        project_attrs = response.get("project")
+        if not project_attrs:
+            raise ValueError(f"project '{project}' not found under entity '{entity}'")
+        attrs = project_attrs.get("artifact")
+        if not attrs:
+            raise ValueError(f"artifact '{name}' not found in '{entity}/{project}'")
+        return cls._from_attrs(entity, project, name, attrs, client)
+
+    @classmethod
+    def _from_attrs(
+        cls,
+        entity: str,
+        project: str,
+        name: str,
+        attrs: dict[str, Any],
+        client: RetryingClient,
+    ) -> Artifact:
+        # Placeholder is required to skip validation.
+        artifact = cls("placeholder", type="placeholder")
+        artifact._client = client
+        artifact._entity = entity
+        artifact._project = project
+        artifact._name = name
+        artifact._assign_attrs(attrs)
+
+        artifact.finalize()
+
+        # Cache.
+        assert artifact.id is not None
+        artifact_instance_cache[artifact.id] = artifact
+        return artifact
+
+    def _assign_attrs(self, attrs: dict[str, Any]) -> None:
+        """Update this Artifact's attributes using the server response."""
+        self._id = attrs["id"]
+
+        src_version = f"v{attrs['versionIndex']}"
+        src_collection = attrs["artifactSequence"]
+        src_project = src_collection["project"]
+
+        self._source_entity = src_project["entityName"] if src_project else ""
+        self._source_project = src_project["name"] if src_project else ""
+        self._source_name = f"{src_collection['name']}:{src_version}"
+        self._source_version = src_version
+
+        if self._entity is None:
+            self._entity = self._source_entity
+        if self._project is None:
+            self._project = self._source_project
+
+        if self._name is None:
+            self._name = self._source_name
+
+        self._type = attrs["artifactType"]["name"]
+        self._description = attrs["description"]
+
+        entity = self._entity
+        project = self._project
+        collection, *_ = self._name.split(":")
+        aliases = [
+            obj["alias"]
+            for obj in attrs["aliases"]
+            if obj["artifactCollection"]
+            and obj["artifactCollection"]["project"]
+            and obj["artifactCollection"]["project"]["entityName"] == entity
+            and obj["artifactCollection"]["project"]["name"] == project
+            and obj["artifactCollection"]["name"] == collection
+        ]
+
+        version_aliases = [
+            alias for alias in aliases if util.alias_is_version_index(alias)
+        ]
+        other_aliases = [
+            alias for alias in aliases if not util.alias_is_version_index(alias)
+        ]
+        if version_aliases:
+            try:
+                [version] = version_aliases
+            except ValueError:
+                raise ValueError(
+                    f"Expected at most one version alias, got {len(version_aliases)}: {version_aliases!r}"
+                )
+        else:
+            version = src_version
+
+        self._version = version
+
+        if ":" not in self._name:
+            self._name = f"{self._name}:{version}"
+
+        self._aliases = other_aliases
+        self._saved_aliases = copy(other_aliases)
+
+        tags = [obj["name"] for obj in attrs.get("tags", [])]
+        self._tags = tags
+        self._saved_tags = copy(tags)
+
+        metadata_str = attrs["metadata"]
+        self.metadata = self._normalize_metadata(
+            json.loads(metadata_str) if metadata_str else {}
+        )
+
+        self._ttl_duration_seconds = _ttl_duration_seconds_from_gql(
+            attrs.get("ttlDurationSeconds")
+        )
+        self._ttl_is_inherited = (
+            True if (attrs.get("ttlIsInherited") is None) else attrs["ttlIsInherited"]
+        )
+
+        self._state = ArtifactState(attrs["state"])
+
+        try:
+            manifest_url = attrs["currentManifest"]["file"]["directUrl"]
+        except (LookupError, TypeError):
+            self._manifest = None
+        else:
+            self._manifest = self._load_manifest(manifest_url)
+
+        self._commit_hash = attrs["commitHash"]
+        self._file_count = attrs["fileCount"]
+        self._created_at = attrs["createdAt"]
+        self._updated_at = attrs["updatedAt"]
+
+    @ensure_logged
+    def new_draft(self) -> Artifact:
+        """Create a new draft artifact with the same content as this committed artifact.
+
+        The artifact returned can be extended or modified and logged as a new version.
+
+        Returns:
+            An `Artifact` object.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        # Name, _entity and _project are set to the *source* name/entity/project:
+        # if this artifact is saved it must be saved to the source sequence.
+        artifact = Artifact(self.source_name.split(":")[0], self.type)
+        artifact._entity = self._source_entity
+        artifact._project = self._source_project
+        artifact._source_entity = self._source_entity
+        artifact._source_project = self._source_project
+
+        # This artifact's parent is the one we are making a draft from.
+        artifact._base_id = self.id
+
+        # We can reuse the client, and copy over all the attributes that aren't
+        # version-dependent and don't depend on having been logged.
+        artifact._client = self._client
+        artifact._description = self.description
+        artifact._metadata = self.metadata
+        artifact._manifest = ArtifactManifest.from_manifest_json(
+            self.manifest.to_manifest_json()
+        )
+        return artifact
+
+    # Properties (Python Class managed attributes).
+
+    @property
+    def id(self) -> str | None:
+        """The artifact's ID."""
+        if self.is_draft():
+            return None
+        assert self._id is not None
+        return self._id
+
+    @property
+    @ensure_logged
+    def entity(self) -> str:
+        """The name of the entity of the secondary (portfolio) artifact collection."""
+        assert self._entity is not None
+        return self._entity
+
+    @property
+    @ensure_logged
+    def project(self) -> str:
+        """The name of the project of the secondary (portfolio) artifact collection."""
+        assert self._project is not None
+        return self._project
+
+    @property
+    def name(self) -> str:
+        """The artifact name and version in its secondary (portfolio) collection.
+
+        A string with the format `{collection}:{alias}`. Before the artifact is saved,
+        contains only the name since the version is not yet known.
+        """
+        return self._name
+
+    @property
+    def qualified_name(self) -> str:
+        """The entity/project/name of the secondary (portfolio) collection."""
+        return f"{self.entity}/{self.project}/{self.name}"
+
+    @property
+    @ensure_logged
+    def version(self) -> str:
+        """The artifact's version in its secondary (portfolio) collection."""
+        assert self._version is not None
+        return self._version
+
+    @property
+    @ensure_logged
+    def collection(self) -> ArtifactCollection:
+        """The collection this artifact was retrieved from.
+
+        A collection is an ordered group of artifact versions.
+        If this artifact was retrieved from a portfolio / linked collection, that
+        collection will be returned rather than the collection
+        that an artifact version originated from. The collection
+        that an artifact originates from is known as the source sequence.
+        """
+        base_name = self.name.split(":")[0]
+        return ArtifactCollection(
+            self._client, self.entity, self.project, base_name, self.type
+        )
+
+    @property
+    @ensure_logged
+    def source_entity(self) -> str:
+        """The name of the entity of the primary (sequence) artifact collection."""
+        assert self._source_entity is not None
+        return self._source_entity
+
+    @property
+    @ensure_logged
+    def source_project(self) -> str:
+        """The name of the project of the primary (sequence) artifact collection."""
+        assert self._source_project is not None
+        return self._source_project
+
+    @property
+    def source_name(self) -> str:
+        """The artifact name and version in its primary (sequence) collection.
+
+        A string with the format `{collection}:{alias}`. Before the artifact is saved,
+        contains only the name since the version is not yet known.
+        """
+        return self._source_name
+
+    @property
+    def source_qualified_name(self) -> str:
+        """The entity/project/name of the primary (sequence) collection."""
+        return f"{self.source_entity}/{self.source_project}/{self.source_name}"
+
+    @property
+    @ensure_logged
+    def source_version(self) -> str:
+        """The artifact's version in its primary (sequence) collection.
+
+        A string with the format `v{number}`.
+        """
+        assert self._source_version is not None
+        return self._source_version
+
+    @property
+    @ensure_logged
+    def source_collection(self) -> ArtifactCollection:
+        """The artifact's primary (sequence) collection."""
+        base_name = self.source_name.split(":")[0]
+        return ArtifactCollection(
+            self._client, self.source_entity, self.source_project, base_name, self.type
+        )
+
+    @property
+    def type(self) -> str:
+        """The artifact's type. Common types include `dataset` or `model`."""
+        return self._type
+
+    @property
+    def description(self) -> str | None:
+        """A description of the artifact."""
+        return self._description
+
+    @description.setter
+    def description(self, description: str | None) -> None:
+        """Set the description of the artifact.
+
+        For model or dataset Artifacts, add documentation for your
+        standardized team model or dataset card. In the W&B UI the
+        description is rendered as markdown.
+
+        Args:
+            description: Free text that offers a description of the artifact.
+        """
+        self._description = description
+
+    @property
+    def metadata(self) -> dict:
+        """User-defined artifact metadata.
+
+        Structured data associated with the artifact.
+        """
+        return self._metadata
+
+    @metadata.setter
+    def metadata(self, metadata: dict) -> None:
+        """User-defined artifact metadata.
+
+        Metadata set this way will eventually be queryable and plottable in the UI; e.g.
+        the class distribution of a dataset.
+
+        Note: There is currently a limit of 100 total keys.
+
+        Args:
+            metadata: Structured data associated with the artifact.
+        """
+        self._metadata = self._normalize_metadata(metadata)
+
+    @property
+    def ttl(self) -> timedelta | None:
+        """The time-to-live (TTL) policy of an artifact.
+
+        Artifacts are deleted shortly after a TTL policy's duration passes.
+        If set to `None`, the artifact deactivates TTL policies and will be not
+        scheduled for deletion, even if there is a team default TTL.
+        An artifact inherits a TTL policy from
+        the team default if the team administrator defines a default
+        TTL and there is no custom policy set on an artifact.
+
+        Raises:
+            ArtifactNotLoggedError: Unable to fetch inherited TTL if the artifact has not been logged or saved
+        """
+        if self._ttl_is_inherited and (self.is_draft() or self._ttl_changed):
+            raise ArtifactNotLoggedError(f"{type(self).__name__}.ttl", self)
+        if self._ttl_duration_seconds is None:
+            return None
+        return timedelta(seconds=self._ttl_duration_seconds)
+
+    @ttl.setter
+    def ttl(self, ttl: timedelta | ArtifactTTL | None) -> None:
+        """The time-to-live (TTL) policy of an artifact.
+
+        Artifacts are deleted shortly after a TTL policy's duration passes.
+        If set to `None`, the artifact has no TTL policy set and it is not
+        scheduled for deletion. An artifact inherits a TTL policy from
+        the team default if the team administrator defines a default
+        TTL and there is no custom policy set on an artifact.
+
+        Args:
+            ttl: The duration as a positive Python `datetime.timedelta` Type
+                that represents how long the artifact will remain active from its creation.
+
+        """
+        if self.type == "wandb-history":
+            raise ValueError("Cannot set artifact TTL for type wandb-history")
+
+        self._ttl_changed = True
+        if isinstance(ttl, ArtifactTTL):
+            if ttl == ArtifactTTL.INHERIT:
+                self._ttl_is_inherited = True
+            else:
+                raise ValueError(f"Unhandled ArtifactTTL enum {ttl}")
+        else:
+            self._ttl_is_inherited = False
+            if ttl is None:
+                self._ttl_duration_seconds = None
+            else:
+                if ttl.total_seconds() <= 0:
+                    raise ValueError(
+                        f"Artifact TTL Duration has to be positive. ttl: {ttl.total_seconds()}"
+                    )
+                self._ttl_duration_seconds = int(ttl.total_seconds())
+
+    @property
+    @ensure_logged
+    def aliases(self) -> list[str]:
+        """List of one or more semantically-friendly references or identifying "nicknames" assigned to an artifact version.
+
+        Aliases are mutable references that you can programmatically reference.
+        Change an artifact's alias with the W&B App UI or programmatically.
+        See [Create new artifact versions](https://docs.wandb.ai/guides/artifacts/create-a-new-artifact-version)
+        for more information.
+        """
+        return self._aliases
+
+    @aliases.setter
+    @ensure_logged
+    def aliases(self, aliases: list[str]) -> None:
+        """Set the aliases associated with this artifact."""
+        self._aliases = validate_aliases(aliases)
+
+    @property
+    @ensure_logged
+    def tags(self) -> list[str]:
+        """List of one or more tags assigned to this artifact version."""
+        return self._tags
+
+    @tags.setter
+    @ensure_logged
+    def tags(self, tags: list[str]) -> None:
+        """Set the tags associated with this artifact."""
+        self._tags = validate_tags(tags)
+
+    @property
+    def distributed_id(self) -> str | None:
+        return self._distributed_id
+
+    @distributed_id.setter
+    def distributed_id(self, distributed_id: str | None) -> None:
+        self._distributed_id = distributed_id
+
+    @property
+    def incremental(self) -> bool:
+        return self._incremental
+
+    @property
+    def use_as(self) -> str | None:
+        return self._use_as
+
+    @property
+    def state(self) -> str:
+        """The status of the artifact. One of: "PENDING", "COMMITTED", or "DELETED"."""
+        return self._state.value
+
+    @property
+    def manifest(self) -> ArtifactManifest:
+        """The artifact's manifest.
+
+        The manifest lists all of its contents, and can't be changed once the artifact
+        has been logged.
+        """
+        if self._manifest is None:
+            query = gql(
+                """
+                query ArtifactManifest(
+                    $entityName: String!,
+                    $projectName: String!,
+                    $name: String!
+                ) {
+                    project(entityName: $entityName, name: $projectName) {
+                        artifact(name: $name) {
+                            currentManifest {
+                                file {
+                                    directUrl
+                                }
+                            }
+                        }
+                    }
+                }
+                """
+            )
+            assert self._client is not None
+            response = self._client.execute(
+                query,
+                variable_values={
+                    "entityName": self._entity,
+                    "projectName": self._project,
+                    "name": self._name,
+                },
+            )
+            attrs = response["project"]["artifact"]
+            self._manifest = self._load_manifest(
+                attrs["currentManifest"]["file"]["directUrl"]
+            )
+        return self._manifest
+
+    @property
+    def digest(self) -> str:
+        """The logical digest of the artifact.
+
+        The digest is the checksum of the artifact's contents. If an artifact has the
+        same digest as the current `latest` version, then `log_artifact` is a no-op.
+        """
+        return self.manifest.digest()
+
+    @property
+    def size(self) -> int:
+        """The total size of the artifact in bytes.
+
+        Includes any references tracked by this artifact.
+        """
+        total_size: int = 0
+        for entry in self.manifest.entries.values():
+            if entry.size is not None:
+                total_size += entry.size
+        return total_size
+
+    @property
+    @ensure_logged
+    def commit_hash(self) -> str:
+        """The hash returned when this artifact was committed."""
+        assert self._commit_hash is not None
+        return self._commit_hash
+
+    @property
+    @ensure_logged
+    def file_count(self) -> int:
+        """The number of files (including references)."""
+        assert self._file_count is not None
+        return self._file_count
+
+    @property
+    @ensure_logged
+    def created_at(self) -> str:
+        """Timestamp when the artifact was created."""
+        assert self._created_at is not None
+        return self._created_at
+
+    @property
+    @ensure_logged
+    def updated_at(self) -> str:
+        """The time when the artifact was last updated."""
+        assert self._created_at is not None
+        return self._updated_at or self._created_at
+
+    # State management.
+
+    def finalize(self) -> None:
+        """Finalize the artifact version.
+
+        You cannot modify an artifact version once it is finalized because the artifact
+        is logged as a specific artifact version. Create a new artifact version
+        to log more data to an artifact. An artifact is automatically finalized
+        when you log the artifact with `log_artifact`.
+        """
+        self._final = True
+
+    def is_draft(self) -> bool:
+        """Check if artifact is not saved.
+
+        Returns: Boolean. `False` if artifact is saved. `True` if artifact is not saved.
+        """
+        return self._state == ArtifactState.PENDING
+
+    def _is_draft_save_started(self) -> bool:
+        return self._save_future is not None
+
+    def save(
+        self,
+        project: str | None = None,
+        settings: wandb.Settings | None = None,
+    ) -> None:
+        """Persist any changes made to the artifact.
+
+        If currently in a run, that run will log this artifact. If not currently in a
+        run, a run of type "auto" is created to track this artifact.
+
+        Args:
+            project: A project to use for the artifact in the case that a run is not
+                already in context.
+            settings: A settings object to use when initializing an automatic run. Most
+                commonly used in testing harness.
+        """
+        if self._state != ArtifactState.PENDING:
+            return self._update()
+
+        if self._incremental:
+            with telemetry.context() as tel:
+                tel.feature.artifact_incremental = True
+
+        if wandb.run is None:
+            if settings is None:
+                settings = wandb.Settings(silent="true")
+            with wandb.init(  # type: ignore
+                entity=self._source_entity,
+                project=project or self._source_project,
+                job_type="auto",
+                settings=settings,
+            ) as run:
+                # redoing this here because in this branch we know we didn't
+                # have the run at the beginning of the method
+                if self._incremental:
+                    with telemetry.context(run=run) as tel:
+                        tel.feature.artifact_incremental = True
+                run.log_artifact(self)
+        else:
+            wandb.run.log_artifact(self)
+
+    def _set_save_future(
+        self, save_future: MessageFuture, client: RetryingClient
+    ) -> None:
+        self._save_future = save_future
+        self._client = client
+
+    def wait(self, timeout: int | None = None) -> Artifact:
+        """If needed, wait for this artifact to finish logging.
+
+        Args:
+            timeout: The time, in seconds, to wait.
+
+        Returns:
+            An `Artifact` object.
+        """
+        if self.is_draft():
+            if self._save_future is None:
+                raise ArtifactNotLoggedError(type(self).wait.__qualname__, self)
+            result = self._save_future.get(timeout)
+            if not result:
+                raise WaitTimeoutError(
+                    "Artifact upload wait timed out, failed to fetch Artifact response"
+                )
+            response = result.response.log_artifact_response
+            if response.error_message:
+                raise ValueError(response.error_message)
+            self._populate_after_save(response.artifact_id)
+        return self
+
+    def _populate_after_save(self, artifact_id: str) -> None:
+        query_template = """
+            query ArtifactByIDShort($id: ID!) {
+                artifact(id: $id) {
+                    ...ArtifactFragment
+                }
+            }
+        """ + _gql_artifact_fragment()
+
+        query = gql(query_template)
+
+        assert self._client is not None
+        response = self._client.execute(
+            query,
+            variable_values={"id": artifact_id},
+        )
+
+        try:
+            attrs = response["artifact"]
+        except LookupError:
+            raise ValueError(f"Unable to fetch artifact with id: {artifact_id!r}")
+        else:
+            self._assign_attrs(attrs)
+
+    @normalize_exceptions
+    def _update(self) -> None:
+        """Persists artifact changes to the wandb backend."""
+        aliases = None
+        introspect_query = gql(
+            """
+            query ProbeServerAddAliasesInput {
+               AddAliasesInputInfoType: __type(name: "AddAliasesInput") {
+                   name
+                   inputFields {
+                       name
+                   }
+                }
+            }
+            """
+        )
+        assert self._client is not None
+        response = self._client.execute(introspect_query)
+        if response.get("AddAliasesInputInfoType"):  # wandb backend version >= 0.13.0
+            aliases_to_add = set(self._aliases) - set(self._saved_aliases)
+            aliases_to_delete = set(self._saved_aliases) - set(self._aliases)
+            if aliases_to_add:
+                add_mutation = gql(
+                    """
+                    mutation addAliases(
+                        $artifactID: ID!,
+                        $aliases: [ArtifactCollectionAliasInput!]!,
+                    ) {
+                        addAliases(
+                            input: {artifactID: $artifactID, aliases: $aliases}
+                        ) {
+                            success
+                        }
+                    }
+                    """
+                )
+                assert self._client is not None
+                self._client.execute(
+                    add_mutation,
+                    variable_values={
+                        "artifactID": self.id,
+                        "aliases": [
+                            {
+                                "entityName": self._entity,
+                                "projectName": self._project,
+                                "artifactCollectionName": self._name.split(":")[0],
+                                "alias": alias,
+                            }
+                            for alias in aliases_to_add
+                        ],
+                    },
+                )
+            if aliases_to_delete:
+                delete_mutation = gql(
+                    """
+                    mutation deleteAliases(
+                        $artifactID: ID!,
+                        $aliases: [ArtifactCollectionAliasInput!]!,
+                    ) {
+                        deleteAliases(
+                            input: {artifactID: $artifactID, aliases: $aliases}
+                        ) {
+                            success
+                        }
+                    }
+                    """
+                )
+                assert self._client is not None
+                self._client.execute(
+                    delete_mutation,
+                    variable_values={
+                        "artifactID": self.id,
+                        "aliases": [
+                            {
+                                "entityName": self._entity,
+                                "projectName": self._project,
+                                "artifactCollectionName": self._name.split(":")[0],
+                                "alias": alias,
+                            }
+                            for alias in aliases_to_delete
+                        ],
+                    },
+                )
+            self._saved_aliases = copy(self._aliases)
+        else:  # wandb backend version < 0.13.0
+            aliases = [
+                {
+                    "artifactCollectionName": self._name.split(":")[0],
+                    "alias": alias,
+                }
+                for alias in self._aliases
+            ]
+
+        mutation_template = """
+            mutation updateArtifact(
+                $artifactID: ID!
+                $description: String
+                $metadata: JSONString
+                _TTL_DURATION_SECONDS_TYPE_
+                _TAGS_TO_ADD_TYPE_
+                _TAGS_TO_DELETE_TYPE_
+                $aliases: [ArtifactAliasInput!]
+            ) {
+                updateArtifact(
+                    input: {
+                        artifactID: $artifactID,
+                        description: $description,
+                        metadata: $metadata,
+                        _TTL_DURATION_SECONDS_VALUE_
+                        _TAGS_TO_ADD_VALUE_
+                        _TAGS_TO_DELETE_VALUE_
+                        aliases: $aliases
+                    }
+                ) {
+                    artifact {
+                        ...ArtifactFragment
+                    }
+                }
+            }
+        """ + _gql_artifact_fragment()
+
+        fields = InternalApi().server_artifact_introspection()
+        if "ttlIsInherited" in fields:
+            mutation_template = (
+                mutation_template.replace(
+                    "_TTL_DURATION_SECONDS_TYPE_",
+                    "$ttlDurationSeconds: Int64",
+                )
+                .replace(
+                    "_TTL_DURATION_SECONDS_VALUE_",
+                    "ttlDurationSeconds: $ttlDurationSeconds",
+                )
+                .replace(
+                    "_TTL_DURATION_SECONDS_FIELDS_",
+                    "ttlDurationSeconds ttlIsInherited",
+                )
+            )
+        else:
+            if self._ttl_changed:
+                termwarn(
+                    "Server not compatible with setting Artifact TTLs, please upgrade the server to use Artifact TTL"
+                )
+            mutation_template = (
+                mutation_template.replace("_TTL_DURATION_SECONDS_TYPE_", "")
+                .replace("_TTL_DURATION_SECONDS_VALUE_", "")
+                .replace("_TTL_DURATION_SECONDS_FIELDS_", "")
+            )
+
+        tags_to_add = validate_tags(set(self._tags) - set(self._saved_tags))
+        tags_to_delete = validate_tags(set(self._saved_tags) - set(self._tags))
+        if "tags" in fields:
+            mutation_template = (
+                mutation_template.replace(
+                    "_TAGS_TO_ADD_TYPE_", "$tagsToAdd: [TagInput!]"
+                )
+                .replace("_TAGS_TO_DELETE_TYPE_", "$tagsToDelete: [TagInput!]")
+                .replace("_TAGS_TO_ADD_VALUE_", "tagsToAdd: $tagsToAdd")
+                .replace("_TAGS_TO_DELETE_VALUE_", "tagsToDelete: $tagsToDelete")
+            )
+        else:
+            if tags_to_add or tags_to_delete:
+                termwarn(
+                    "Server not compatible with Artifact tags. "
+                    "To use Artifact tags, please upgrade the server to v0.85 or higher."
+                )
+            mutation_template = (
+                mutation_template.replace("_TAGS_TO_ADD_TYPE_", "")
+                .replace("_TAGS_TO_DELETE_TYPE_", "")
+                .replace("_TAGS_TO_ADD_VALUE_", "")
+                .replace("_TAGS_TO_DELETE_VALUE_", "")
+            )
+
+        mutation = gql(mutation_template)
+        assert self._client is not None
+
+        ttl_duration_input = self._ttl_duration_seconds_to_gql()
+        response = self._client.execute(
+            mutation,
+            variable_values={
+                "artifactID": self.id,
+                "description": self.description,
+                "metadata": util.json_dumps_safer(self.metadata),
+                "ttlDurationSeconds": ttl_duration_input,
+                "aliases": aliases,
+                "tagsToAdd": [{"tagName": tag_name} for tag_name in tags_to_add],
+                "tagsToDelete": [{"tagName": tag_name} for tag_name in tags_to_delete],
+            },
+        )
+        attrs = response["updateArtifact"]["artifact"]
+        self._assign_attrs(attrs)
+
+        self._ttl_changed = False  # Reset after updating artifact
+
+    # Adding, removing, getting entries.
+
+    def __getitem__(self, name: str) -> WBValue | None:
+        """Get the WBValue object located at the artifact relative `name`.
+
+        Args:
+            name: The artifact relative name to get.
+
+        Returns:
+            W&B object that can be logged with `wandb.log()` and visualized in the W&B UI.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact isn't logged or the run is offline.
+        """
+        return self.get(name)
+
+    def __setitem__(self, name: str, item: WBValue) -> ArtifactManifestEntry:
+        """Add `item` to the artifact at path `name`.
+
+        Args:
+            name: The path within the artifact to add the object.
+            item: The object to add.
+
+        Returns:
+            The added manifest entry
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+        """
+        return self.add(item, name)
+
+    @contextlib.contextmanager
+    @ensure_not_finalized
+    def new_file(
+        self, name: str, mode: str = "x", encoding: str | None = None
+    ) -> Iterator[IO]:
+        """Open a new temporary file and add it to the artifact.
+
+        Args:
+            name: The name of the new file to add to the artifact.
+            mode: The file access mode to use to open the new file.
+            encoding: The encoding used to open the new file.
+
+        Returns:
+            A new file object that can be written to. Upon closing, the file will be
+            automatically added to the artifact.
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+        """
+        overwrite: bool = "x" not in mode
+
+        if self._tmp_dir is None:
+            self._tmp_dir = tempfile.TemporaryDirectory()
+        path = os.path.join(self._tmp_dir.name, name.lstrip("/"))
+
+        filesystem.mkdir_exists_ok(os.path.dirname(path))
+        try:
+            with util.fsync_open(path, mode, encoding) as f:
+                yield f
+        except FileExistsError:
+            raise ValueError(f"File with name {name!r} already exists at {path!r}")
+        except UnicodeEncodeError as e:
+            termerror(
+                f"Failed to open the provided file ({type(e).__name__}: {e}). Please "
+                f"provide the proper encoding."
+            )
+            raise e
+
+        self.add_file(
+            path, name=name, policy="immutable", skip_cache=True, overwrite=overwrite
+        )
+
+    @ensure_not_finalized
+    def add_file(
+        self,
+        local_path: str,
+        name: str | None = None,
+        is_tmp: bool | None = False,
+        skip_cache: bool | None = False,
+        policy: Literal["mutable", "immutable"] | None = "mutable",
+        overwrite: bool = False,
+    ) -> ArtifactManifestEntry:
+        """Add a local file to the artifact.
+
+        Args:
+            local_path: The path to the file being added.
+            name: The path within the artifact to use for the file being added. Defaults
+                to the basename of the file.
+            is_tmp: If true, then the file is renamed deterministically to avoid
+                collisions.
+            skip_cache: If `True`, W&B will not copy files to the cache after uploading.
+            policy: By default, set to "mutable". If set to "mutable", create a temporary copy of the
+                file to prevent corruption during upload. If set to "immutable", disable
+                protection and rely on the user not to delete or change the file.
+            overwrite: If `True`, overwrite the file if it already exists.
+
+        Returns:
+            The added manifest entry.
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+            ValueError: Policy must be "mutable" or "immutable"
+        """
+        if not os.path.isfile(local_path):
+            raise ValueError(f"Path is not a file: {local_path!r}")
+
+        name = LogicalPath(name or os.path.basename(local_path))
+        digest = md5_file_b64(local_path)
+
+        if is_tmp:
+            file_path, file_name = os.path.split(name)
+            file_name_parts = file_name.split(".")
+            file_name_parts[0] = b64_to_hex_id(digest)[:20]
+            name = os.path.join(file_path, ".".join(file_name_parts))
+
+        return self._add_local_file(
+            name,
+            local_path,
+            digest=digest,
+            skip_cache=skip_cache,
+            policy=policy,
+            overwrite=overwrite,
+        )
+
+    @ensure_not_finalized
+    def add_dir(
+        self,
+        local_path: str,
+        name: str | None = None,
+        skip_cache: bool | None = False,
+        policy: Literal["mutable", "immutable"] | None = "mutable",
+    ) -> None:
+        """Add a local directory to the artifact.
+
+        Args:
+            local_path: The path of the local directory.
+            name: The subdirectory name within an artifact. The name you specify appears
+                in the W&B App UI nested by artifact's `type`.
+                Defaults to the root of the artifact.
+            skip_cache: If set to `True`, W&B will not copy/move files to the cache while uploading
+            policy: "mutable" | "immutable". By default, "mutable"
+                "mutable": Create a temporary copy of the file to prevent corruption during upload.
+                "immutable": Disable protection, rely on the user not to delete or change the file.
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+            ValueError: Policy must be "mutable" or "immutable"
+        """
+        if not os.path.isdir(local_path):
+            raise ValueError("Path is not a directory: {}".format(local_path))
+
+        termlog(
+            "Adding directory to artifact ({})... ".format(
+                os.path.join(".", os.path.normpath(local_path))
+            ),
+            newline=False,
+        )
+        start_time = time.time()
+
+        paths = []
+        for dirpath, _, filenames in os.walk(local_path, followlinks=True):
+            for fname in filenames:
+                physical_path = os.path.join(dirpath, fname)
+                logical_path = os.path.relpath(physical_path, start=local_path)
+                if name is not None:
+                    logical_path = os.path.join(name, logical_path)
+                paths.append((logical_path, physical_path))
+
+        def add_manifest_file(log_phy_path: tuple[str, str]) -> None:
+            logical_path, physical_path = log_phy_path
+            self._add_local_file(
+                name=logical_path,
+                path=physical_path,
+                skip_cache=skip_cache,
+                policy=policy,
+            )
+
+        num_threads = 8
+        pool = multiprocessing.dummy.Pool(num_threads)
+        pool.map(add_manifest_file, paths)
+        pool.close()
+        pool.join()
+
+        termlog("Done. %.1fs" % (time.time() - start_time), prefix=False)
+
+    @ensure_not_finalized
+    def add_reference(
+        self,
+        uri: ArtifactManifestEntry | str,
+        name: StrPath | None = None,
+        checksum: bool = True,
+        max_objects: int | None = None,
+    ) -> Sequence[ArtifactManifestEntry]:
+        """Add a reference denoted by a URI to the artifact.
+
+        Unlike files or directories that you add to an artifact, references are not
+        uploaded to W&B. For more information,
+        see [Track external files](https://docs.wandb.ai/guides/artifacts/track-external-files).
+
+        By default, the following schemes are supported:
+
+        - http(s): The size and digest of the file will be inferred by the
+          `Content-Length` and the `ETag` response headers returned by the server.
+        - s3: The checksum and size are pulled from the object metadata. If bucket
+          versioning is enabled, then the version ID is also tracked.
+        - gs: The checksum and size are pulled from the object metadata. If bucket
+          versioning is enabled, then the version ID is also tracked.
+        - https, domain matching `*.blob.core.windows.net` (Azure): The checksum and size
+          are be pulled from the blob metadata. If storage account versioning is
+          enabled, then the version ID is also tracked.
+        - file: The checksum and size are pulled from the file system. This scheme
+          is useful if you have an NFS share or other externally mounted volume
+          containing files you wish to track but not necessarily upload.
+
+        For any other scheme, the digest is just a hash of the URI and the size is left
+        blank.
+
+        Args:
+            uri: The URI path of the reference to add. The URI path can be an object
+                returned from `Artifact.get_entry` to store a reference to another
+                artifact's entry.
+            name: The path within the artifact to place the contents of this reference.
+            checksum: Whether or not to checksum the resource(s) located at the
+                reference URI. Checksumming is strongly recommended as it enables
+                automatic integrity validation. Disabling checksumming will speed up
+                artifact creation but reference directories will not iterated through so the
+                objects in the directory will not be saved to the artifact. We recommend
+                setting `checksum=False` when adding reference objects, in which case
+                a new version will only be created if the reference URI changes.
+            max_objects: The maximum number of objects to consider when adding a
+                reference that points to directory or bucket store prefix. By default,
+                the maximum number of objects allowed for Amazon S3,
+                GCS, Azure, and local files is 10,000,000. Other URI schemas do not have a maximum.
+
+        Returns:
+            The added manifest entries.
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+        """
+        if name is not None:
+            name = LogicalPath(name)
+
+        # This is a bit of a hack, we want to check if the uri is a of the type
+        # ArtifactManifestEntry. If so, then recover the reference URL.
+        if isinstance(uri, ArtifactManifestEntry):
+            uri_str = uri.ref_url()
+        elif isinstance(uri, str):
+            uri_str = uri
+        url = urlparse(str(uri_str))
+        if not url.scheme:
+            raise ValueError(
+                "References must be URIs. To reference a local file, use file://"
+            )
+
+        manifest_entries = self._storage_policy.store_reference(
+            self,
+            URIStr(uri_str),
+            name=name,
+            checksum=checksum,
+            max_objects=max_objects,
+        )
+        for entry in manifest_entries:
+            self.manifest.add_entry(entry)
+
+        return manifest_entries
+
+    @ensure_not_finalized
+    def add(
+        self, obj: WBValue, name: StrPath, overwrite: bool = False
+    ) -> ArtifactManifestEntry:
+        """Add wandb.WBValue `obj` to the artifact.
+
+        Args:
+            obj: The object to add. Currently support one of Bokeh, JoinedTable,
+                PartitionedTable, Table, Classes, ImageMask, BoundingBoxes2D, Audio,
+                Image, Video, Html, Object3D
+            name: The path within the artifact to add the object.
+            overwrite: If True, overwrite existing objects with the same file path (if applicable).
+
+        Returns:
+            The added manifest entry
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+        """
+        name = LogicalPath(name)
+
+        # This is a "hack" to automatically rename tables added to
+        # the wandb /media/tables directory to their sha-based name.
+        # TODO: figure out a more appropriate convention.
+        is_tmp_name = name.startswith("media/tables")
+
+        # Validate that the object is one of the correct wandb.Media types
+        # TODO: move this to checking subclass of wandb.Media once all are
+        # generally supported
+        allowed_types = (
+            data_types.Bokeh,
+            data_types.JoinedTable,
+            data_types.PartitionedTable,
+            data_types.Table,
+            data_types.Classes,
+            data_types.ImageMask,
+            data_types.BoundingBoxes2D,
+            data_types.Audio,
+            data_types.Image,
+            data_types.Video,
+            data_types.Html,
+            data_types.Object3D,
+            data_types.Molecule,
+            data_types._SavedModel,
+        )
+        if not isinstance(obj, allowed_types):
+            raise ValueError(
+                f"Found object of type {obj.__class__}, expected one of: {allowed_types}"
+            )
+
+        obj_id = id(obj)
+        if obj_id in self._added_objs:
+            return self._added_objs[obj_id][1]
+
+        # If the object is coming from another artifact, save it as a reference
+        ref_path = obj._get_artifact_entry_ref_url()
+        if ref_path is not None:
+            return self.add_reference(ref_path, type(obj).with_suffix(name))[0]
+
+        val = obj.to_json(self)
+        name = obj.with_suffix(name)
+        entry = self.manifest.get_entry_by_path(name)
+        if (not overwrite) and (entry is not None):
+            return entry
+
+        if is_tmp_name:
+            file_path = os.path.join(self._TMP_DIR.name, str(id(self)), name)
+            folder_path, _ = os.path.split(file_path)
+            os.makedirs(folder_path, exist_ok=True)
+            with open(file_path, "w", encoding="utf-8") as tmp_f:
+                json.dump(val, tmp_f, sort_keys=True)
+        else:
+            filemode = "w" if overwrite else "x"
+            with self.new_file(name, mode=filemode, encoding="utf-8") as f:
+                json.dump(val, f, sort_keys=True)
+                file_path = f.name
+
+        # Note, we add the file from our temp directory.
+        # It will be added again later on finalize, but succeed since
+        # the checksum should match
+        entry = self.add_file(file_path, name, is_tmp_name)
+        # We store a reference to the obj so that its id doesn't get reused.
+        self._added_objs[obj_id] = (obj, entry)
+        if obj._artifact_target is None:
+            obj._set_artifact_target(self, entry.path)
+
+        if is_tmp_name:
+            with contextlib.suppress(FileNotFoundError):
+                os.remove(file_path)
+
+        return entry
+
+    def _add_local_file(
+        self,
+        name: StrPath,
+        path: StrPath,
+        digest: B64MD5 | None = None,
+        skip_cache: bool | None = False,
+        policy: Literal["mutable", "immutable"] | None = "mutable",
+        overwrite: bool = False,
+    ) -> ArtifactManifestEntry:
+        policy = policy or "mutable"
+        if policy not in ["mutable", "immutable"]:
+            raise ValueError(
+                f"Invalid policy {policy!r}. Policy may only be `mutable` or `immutable`."
+            )
+        upload_path = path
+        if policy == "mutable":
+            with tempfile.NamedTemporaryFile(dir=get_staging_dir(), delete=False) as f:
+                staging_path = f.name
+                shutil.copyfile(path, staging_path)
+                # Set as read-only to prevent changes to the file during upload process
+                os.chmod(staging_path, stat.S_IRUSR)
+                upload_path = staging_path
+
+        entry = ArtifactManifestEntry(
+            path=name,
+            digest=digest or md5_file_b64(upload_path),
+            size=os.path.getsize(upload_path),
+            local_path=upload_path,
+            skip_cache=skip_cache,
+        )
+        self.manifest.add_entry(entry, overwrite=overwrite)
+        self._added_local_paths[os.fspath(path)] = entry
+        return entry
+
+    @ensure_not_finalized
+    def remove(self, item: StrPath | ArtifactManifestEntry) -> None:
+        """Remove an item from the artifact.
+
+        Args:
+            item: The item to remove. Can be a specific manifest entry or the name of an
+                artifact-relative path. If the item matches a directory all items in
+                that directory will be removed.
+
+        Raises:
+            ArtifactFinalizedError: You cannot make changes to the current artifact
+            version because it is finalized. Log a new artifact version instead.
+            FileNotFoundError: If the item isn't found in the artifact.
+        """
+        if isinstance(item, ArtifactManifestEntry):
+            self.manifest.remove_entry(item)
+            return
+
+        path = str(PurePosixPath(item))
+        entry = self.manifest.get_entry_by_path(path)
+        if entry:
+            self.manifest.remove_entry(entry)
+            return
+
+        entries = self.manifest.get_entries_in_directory(path)
+        if not entries:
+            raise FileNotFoundError(f"No such file or directory: {path}")
+        for entry in entries:
+            self.manifest.remove_entry(entry)
+
+    def get_path(self, name: StrPath) -> ArtifactManifestEntry:
+        """Deprecated. Use `get_entry(name)`."""
+        deprecate(
+            field_name=Deprecated.artifact__get_path,
+            warning_message="Artifact.get_path(name) is deprecated, use Artifact.get_entry(name) instead.",
+        )
+        return self.get_entry(name)
+
+    @ensure_logged
+    def get_entry(self, name: StrPath) -> ArtifactManifestEntry:
+        """Get the entry with the given name.
+
+        Args:
+            name: The artifact relative name to get
+
+        Returns:
+            A `W&B` object.
+
+        Raises:
+            ArtifactNotLoggedError: if the artifact isn't logged or the run is offline.
+            KeyError: if the artifact doesn't contain an entry with the given name.
+        """
+        name = LogicalPath(name)
+        entry = self.manifest.entries.get(name) or self._get_obj_entry(name)[0]
+        if entry is None:
+            raise KeyError("Path not contained in artifact: {}".format(name))
+        entry._parent_artifact = self
+        return entry
+
+    @ensure_logged
+    def get(self, name: str) -> WBValue | None:
+        """Get the WBValue object located at the artifact relative `name`.
+
+        Args:
+            name: The artifact relative name to retrieve.
+
+        Returns:
+            W&B object that can be logged with `wandb.log()` and visualized in the W&B UI.
+
+        Raises:
+            ArtifactNotLoggedError: if the artifact isn't logged or the run is offline
+        """
+        entry, wb_class = self._get_obj_entry(name)
+        if entry is None or wb_class is None:
+            return None
+
+        # If the entry is a reference from another artifact, then get it directly from
+        # that artifact.
+        referenced_id = entry._referenced_artifact_id()
+        if referenced_id:
+            assert self._client is not None
+            artifact = self._from_id(referenced_id, client=self._client)
+            assert artifact is not None
+            return artifact.get(util.uri_from_path(entry.ref))
+
+        # Special case for wandb.Table. This is intended to be a short term
+        # optimization. Since tables are likely to download many other assets in
+        # artifact(s), we eagerly download the artifact using the parallelized
+        # `artifact.download`. In the future, we should refactor the deserialization
+        # pattern such that this special case is not needed.
+        if wb_class == wandb.Table:
+            self.download()
+
+        # Get the ArtifactManifestEntry
+        item = self.get_entry(entry.path)
+        item_path = item.download()
+
+        # Load the object from the JSON blob
+        result = None
+        json_obj = {}
+        with open(item_path) as file:
+            json_obj = json.load(file)
+        result = wb_class.from_json(json_obj, self)
+        result._set_artifact_source(self, name)
+        return result
+
+    def get_added_local_path_name(self, local_path: str) -> str | None:
+        """Get the artifact relative name of a file added by a local filesystem path.
+
+        Args:
+            local_path: The local path to resolve into an artifact relative name.
+
+        Returns:
+            The artifact relative name.
+        """
+        entry = self._added_local_paths.get(local_path, None)
+        if entry is None:
+            return None
+        return entry.path
+
+    def _get_obj_entry(
+        self, name: str
+    ) -> tuple[ArtifactManifestEntry, Type[WBValue]] | tuple[None, None]:  # noqa: UP006  # `type` shadows `Artifact.type`
+        """Return an object entry by name, handling any type suffixes.
+
+        When objects are added with `.add(obj, name)`, the name is typically changed to
+        include the suffix of the object type when serializing to JSON. So we need to be
+        able to resolve a name, without tasking the user with appending .THING.json.
+        This method returns an entry if it exists by a suffixed name.
+
+        Args:
+            name: name used when adding
+        """
+        for wb_class in WBValue.type_mapping().values():
+            wandb_file_name = wb_class.with_suffix(name)
+            entry = self.manifest.entries.get(wandb_file_name)
+            if entry is not None:
+                return entry, wb_class
+        return None, None
+
+    # Downloading.
+
+    @ensure_logged
+    def download(
+        self,
+        root: StrPath | None = None,
+        allow_missing_references: bool = False,
+        skip_cache: bool | None = None,
+        path_prefix: StrPath | None = None,
+    ) -> FilePathStr:
+        """Download the contents of the artifact to the specified root directory.
+
+        Existing files located within `root` are not modified. Explicitly delete `root`
+        before you call `download` if you want the contents of `root` to exactly match
+        the artifact.
+
+        Args:
+            root: The directory W&B stores the artifact's files.
+            allow_missing_references: If set to `True`, any invalid reference paths
+                will be ignored while downloading referenced files.
+            skip_cache: If set to `True`, the artifact cache will be skipped when
+                downloading and W&B will download each file into the default root or
+                specified download directory.
+            path_prefix: If specified, only files with a path that starts with the given
+                prefix will be downloaded. Uses unix format (forward slashes).
+
+        Returns:
+            The path to the downloaded contents.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+            RuntimeError: If the artifact is attempted to be downloaded in offline mode.
+        """
+        root = FilePathStr(str(root or self._default_root()))
+        self._add_download_root(root)
+
+        # TODO: we need a better way to check for offline mode across the app, as this is an anti-pattern
+        if env.is_offline() or util._is_offline():
+            raise RuntimeError("Cannot download artifacts in offline mode.")
+
+        # TODO: download artifacts using core when implemented
+        # if is_require_core():
+        #     return self._download_using_core(
+        #         root=root,
+        #         allow_missing_references=allow_missing_references,
+        #         skip_cache=bool(skip_cache),
+        #         path_prefix=path_prefix,
+        #     )
+        return self._download(
+            root=root,
+            allow_missing_references=allow_missing_references,
+            skip_cache=skip_cache,
+            path_prefix=path_prefix,
+        )
+
+    def _download_using_core(
+        self,
+        root: str,
+        allow_missing_references: bool = False,
+        skip_cache: bool = False,
+        path_prefix: StrPath | None = None,
+    ) -> FilePathStr:
+        import pathlib
+
+        from wandb.sdk.backend.backend import Backend
+
+        if wandb.run is None:
+            wl = wandb.setup()
+
+            stream_id = generate_id()
+
+            settings = wl.settings.to_proto()
+            # TODO: remove this
+            tmp_dir = pathlib.Path(tempfile.mkdtemp())
+
+            settings.sync_dir.value = str(tmp_dir)
+            settings.sync_file.value = str(tmp_dir / f"{stream_id}.wandb")
+            settings.files_dir.value = str(tmp_dir / "files")
+            settings.run_id.value = stream_id
+
+            service = wl.ensure_service()
+            service.inform_init(settings=settings, run_id=stream_id)
+
+            mailbox = Mailbox()
+            backend = Backend(
+                settings=wl.settings,
+                service=service,
+                mailbox=mailbox,
+            )
+            backend.ensure_launched()
+
+            assert backend.interface
+            backend.interface._stream_id = stream_id  # type: ignore
+
+            mailbox.enable_keepalive()
+        else:
+            assert wandb.run._backend
+            backend = wandb.run._backend
+
+        assert backend.interface
+        handle = backend.interface.deliver_download_artifact(
+            self.id,  # type: ignore
+            root,
+            allow_missing_references,
+            skip_cache,
+            path_prefix,  # type: ignore
+        )
+        # TODO: Start the download process in the user process too, to handle reference downloads
+        self._download(
+            root=root,
+            allow_missing_references=allow_missing_references,
+            skip_cache=skip_cache,
+            path_prefix=path_prefix,
+        )
+        result = handle.wait(timeout=-1)
+
+        if result is None:
+            handle.abandon()
+        assert result is not None
+        response = result.response.download_artifact_response
+        if response.error_message:
+            raise ValueError(f"Error downloading artifact: {response.error_message}")
+
+        return FilePathStr(root)
+
+    def _download(
+        self,
+        root: str,
+        allow_missing_references: bool = False,
+        skip_cache: bool | None = None,
+        path_prefix: StrPath | None = None,
+    ) -> FilePathStr:
+        nfiles = len(self.manifest.entries)
+        size = sum(e.size or 0 for e in self.manifest.entries.values())
+        log = False
+        if nfiles > 5000 or size > 50 * 1024 * 1024:
+            log = True
+            termlog(
+                "Downloading large artifact {}, {:.2f}MB. {} files... ".format(
+                    self.name, size / (1024 * 1024), nfiles
+                ),
+            )
+            start_time = datetime.now()
+        download_logger = ArtifactDownloadLogger(nfiles=nfiles)
+
+        def _download_entry(
+            entry: ArtifactManifestEntry,
+            api_key: str | None,
+            cookies: dict | None,
+            headers: dict | None,
+        ) -> None:
+            _thread_local_api_settings.api_key = api_key
+            _thread_local_api_settings.cookies = cookies
+            _thread_local_api_settings.headers = headers
+
+            try:
+                entry.download(root, skip_cache=skip_cache)
+            except FileNotFoundError as e:
+                if allow_missing_references:
+                    wandb.termwarn(str(e))
+                    return
+                raise
+            except _GCSIsADirectoryError as e:
+                logger.debug(str(e))
+                return
+            download_logger.notify_downloaded()
+
+        download_entry = partial(
+            _download_entry,
+            api_key=_thread_local_api_settings.api_key,
+            cookies=_thread_local_api_settings.cookies,
+            headers=_thread_local_api_settings.headers,
+        )
+
+        with concurrent.futures.ThreadPoolExecutor(64) as executor:
+            active_futures = set()
+            has_next_page = True
+            cursor = None
+            while has_next_page:
+                fetch_url_batch_size = env.get_artifact_fetch_file_url_batch_size()
+                attrs = self._fetch_file_urls(cursor, fetch_url_batch_size)
+                has_next_page = attrs["pageInfo"]["hasNextPage"]
+                cursor = attrs["pageInfo"]["endCursor"]
+                for edge in attrs["edges"]:
+                    entry = self.get_entry(edge["node"]["name"])
+                    # TODO: uncomment once artifact downloads are supported in core
+                    # if require_core and entry.ref is None:
+                    #     # Handled by core
+                    #     continue
+                    entry._download_url = edge["node"]["directUrl"]
+                    if (not path_prefix) or entry.path.startswith(str(path_prefix)):
+                        active_futures.add(executor.submit(download_entry, entry))
+                # Wait for download threads to catch up.
+                max_backlog = fetch_url_batch_size
+                if len(active_futures) > max_backlog:
+                    for future in concurrent.futures.as_completed(active_futures):
+                        future.result()  # check for errors
+                        active_futures.remove(future)
+                        if len(active_futures) <= max_backlog:
+                            break
+            # Check for errors.
+            for future in concurrent.futures.as_completed(active_futures):
+                future.result()
+
+        if log:
+            now = datetime.now()
+            delta = abs((now - start_time).total_seconds())
+            hours = int(delta // 3600)
+            minutes = int((delta - hours * 3600) // 60)
+            seconds = delta - hours * 3600 - minutes * 60
+            termlog(
+                f"Done. {hours}:{minutes}:{seconds:.1f}",
+                prefix=False,
+            )
+        return FilePathStr(root)
+
+    @retry.retriable(
+        retry_timedelta=timedelta(minutes=3),
+        retryable_exceptions=(requests.RequestException),
+    )
+    def _fetch_file_urls(self, cursor: str | None, per_page: int | None = 5000) -> Any:
+        query = gql(
+            """
+            query ArtifactFileURLs($id: ID!, $cursor: String, $perPage: Int) {
+                artifact(id: $id) {
+                    files(after: $cursor, first: $perPage) {
+                        pageInfo {
+                            hasNextPage
+                            endCursor
+                        }
+                        edges {
+                            node {
+                                name
+                                directUrl
+                            }
+                        }
+                    }
+                }
+            }
+            """
+        )
+        assert self._client is not None
+        response = self._client.execute(
+            query,
+            variable_values={"id": self.id, "cursor": cursor, "perPage": per_page},
+            timeout=60,
+        )
+        return response["artifact"]["files"]
+
+    @ensure_logged
+    def checkout(self, root: str | None = None) -> str:
+        """Replace the specified root directory with the contents of the artifact.
+
+        WARNING: This will delete all files in `root` that are not included in the
+        artifact.
+
+        Args:
+            root: The directory to replace with this artifact's files.
+
+        Returns:
+           The path of the checked out contents.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        root = root or self._default_root(include_version=False)
+
+        for dirpath, _, files in os.walk(root):
+            for file in files:
+                full_path = os.path.join(dirpath, file)
+                artifact_path = os.path.relpath(full_path, start=root)
+                try:
+                    self.get_entry(artifact_path)
+                except KeyError:
+                    # File is not part of the artifact, remove it.
+                    os.remove(full_path)
+
+        return self.download(root=root)
+
+    @ensure_logged
+    def verify(self, root: str | None = None) -> None:
+        """Verify that the contents of an artifact match the manifest.
+
+        All files in the directory are checksummed and the checksums are then
+        cross-referenced against the artifact's manifest. References are not verified.
+
+        Args:
+            root: The directory to verify. If None artifact will be downloaded to
+                './artifacts/self.name/'
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+            ValueError: If the verification fails.
+        """
+        root = root or self._default_root()
+
+        for dirpath, _, files in os.walk(root):
+            for file in files:
+                full_path = os.path.join(dirpath, file)
+                artifact_path = os.path.relpath(full_path, start=root)
+                try:
+                    self.get_entry(artifact_path)
+                except KeyError:
+                    raise ValueError(
+                        "Found file {} which is not a member of artifact {}".format(
+                            full_path, self.name
+                        )
+                    )
+
+        ref_count = 0
+        for entry in self.manifest.entries.values():
+            if entry.ref is None:
+                if md5_file_b64(os.path.join(root, entry.path)) != entry.digest:
+                    raise ValueError("Digest mismatch for file: {}".format(entry.path))
+            else:
+                ref_count += 1
+        if ref_count > 0:
+            termwarn(f"skipped verification of {ref_count} refs")
+
+    @ensure_logged
+    def file(self, root: str | None = None) -> StrPath:
+        """Download a single file artifact to the directory you specify with `root`.
+
+        Args:
+            root: The root directory to store the file. Defaults to
+                './artifacts/self.name/'.
+
+        Returns:
+            The full path of the downloaded file.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+            ValueError: If the artifact contains more than one file.
+        """
+        if root is None:
+            root = os.path.join(".", "artifacts", self.name)
+
+        if len(self.manifest.entries) > 1:
+            raise ValueError(
+                "This artifact contains more than one file, call `.download()` to get "
+                'all files or call .get_entry("filename").download()'
+            )
+
+        return self.get_entry(list(self.manifest.entries)[0]).download(root)
+
+    @ensure_logged
+    def files(
+        self, names: list[str] | None = None, per_page: int = 50
+    ) -> ArtifactFiles:
+        """Iterate over all files stored in this artifact.
+
+        Args:
+            names: The filename paths relative to the root of the artifact you wish to
+                list.
+            per_page: The number of files to return per request.
+
+        Returns:
+            An iterator containing `File` objects.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        return ArtifactFiles(self._client, self, names, per_page)
+
+    def _default_root(self, include_version: bool = True) -> FilePathStr:
+        name = self.source_name if include_version else self.source_name.split(":")[0]
+        root = os.path.join(env.get_artifact_dir(), name)
+        # In case we're on a system where the artifact dir has a name corresponding to
+        # an unexpected filesystem, we'll check for alternate roots. If one exists we'll
+        # use that, otherwise we'll fall back to the system-preferred path.
+        path = filesystem.check_exists(root) or filesystem.system_preferred_path(root)
+        return FilePathStr(str(path))
+
+    def _add_download_root(self, dir_path: str) -> None:
+        self._download_roots.add(os.path.abspath(dir_path))
+
+    def _local_path_to_name(self, file_path: str) -> str | None:
+        """Convert a local file path to a path entry in the artifact."""
+        abs_file_path = os.path.abspath(file_path)
+        abs_file_parts = abs_file_path.split(os.sep)
+        for i in range(len(abs_file_parts) + 1):
+            if os.path.join(os.sep, *abs_file_parts[:i]) in self._download_roots:
+                return os.path.join(*abs_file_parts[i:])
+        return None
+
+    # Others.
+
+    @ensure_logged
+    def delete(self, delete_aliases: bool = False) -> None:
+        """Delete an artifact and its files.
+
+        If called on a linked artifact (i.e. a member of a portfolio collection): only the link is deleted, and the
+        source artifact is unaffected.
+
+        Args:
+            delete_aliases: If set to `True`, deletes all aliases associated with the artifact.
+                Otherwise, this raises an exception if the artifact has existing
+                aliases.
+                This parameter is ignored if the artifact is linked (i.e. a member of a portfolio collection).
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        if self.collection.is_sequence():
+            self._delete(delete_aliases)
+        else:
+            self._unlink()
+
+    @normalize_exceptions
+    def _delete(self, delete_aliases: bool = False) -> None:
+        mutation = gql(
+            """
+            mutation DeleteArtifact($artifactID: ID!, $deleteAliases: Boolean) {
+                deleteArtifact(input: {
+                    artifactID: $artifactID
+                    deleteAliases: $deleteAliases
+                }) {
+                    artifact {
+                        id
+                    }
+                }
+            }
+            """
+        )
+        assert self._client is not None
+        self._client.execute(
+            mutation,
+            variable_values={
+                "artifactID": self.id,
+                "deleteAliases": delete_aliases,
+            },
+        )
+
+    @normalize_exceptions
+    def link(self, target_path: str, aliases: list[str] | None = None) -> None:
+        """Link this artifact to a portfolio (a promoted collection of artifacts).
+
+        Args:
+            target_path: The path to the portfolio inside a project.
+                The target path must adhere to one of the following
+                schemas `{portfolio}`, `{project}/{portfolio}` or
+                `{entity}/{project}/{portfolio}`.
+                To link the artifact to the Model Registry, rather than to a generic
+                portfolio inside a project, set `target_path` to the following
+                schema `{"model-registry"}/{Registered Model Name}` or
+                `{entity}/{"model-registry"}/{Registered Model Name}`.
+            aliases: A list of strings that uniquely identifies the artifact inside the
+                specified portfolio.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        if wandb.run is None:
+            with wandb.init(  # type: ignore
+                entity=self._source_entity,
+                project=self._source_project,
+                job_type="auto",
+                settings=wandb.Settings(silent="true"),
+            ) as run:
+                run.link_artifact(self, target_path, aliases)
+        else:
+            wandb.run.link_artifact(self, target_path, aliases)
+
+    @ensure_logged
+    def unlink(self) -> None:
+        """Unlink this artifact if it is currently a member of a portfolio (a promoted collection of artifacts).
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+            ValueError: If the artifact is not linked, i.e. it is not a member of a portfolio collection.
+        """
+        # Fail early if this isn't a linked artifact to begin with
+        if self.collection.is_sequence():
+            raise ValueError(
+                f"Artifact {self.qualified_name!r} is not a linked artifact and cannot be unlinked.  "
+                f"To delete it, use {self.delete.__qualname__!r} instead."
+            )
+
+        self._unlink()
+
+    @normalize_exceptions
+    def _unlink(self) -> None:
+        mutation = gql(
+            """
+            mutation UnlinkArtifact($artifactID: ID!, $artifactPortfolioID: ID!) {
+                unlinkArtifact(
+                    input: { artifactID: $artifactID, artifactPortfolioID: $artifactPortfolioID }
+                ) {
+                    artifactID
+                    success
+                    clientMutationId
+                }
+            }
+            """
+        )
+        assert self._client is not None
+        self._client.execute(
+            mutation,
+            variable_values={
+                "artifactID": self.id,
+                "artifactPortfolioID": self.collection.id,
+            },
+        )
+
+    @ensure_logged
+    def used_by(self) -> list[Run]:
+        """Get a list of the runs that have used this artifact.
+
+        Returns:
+            A list of `Run` objects.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        query = gql(
+            """
+            query ArtifactUsedBy(
+                $id: ID!,
+            ) {
+                artifact(id: $id) {
+                    usedBy {
+                        edges {
+                            node {
+                                name
+                                project {
+                                    name
+                                    entityName
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            """
+        )
+        assert self._client is not None
+        response = self._client.execute(
+            query,
+            variable_values={"id": self.id},
+        )
+        return [
+            Run(
+                self._client,
+                edge["node"]["project"]["entityName"],
+                edge["node"]["project"]["name"],
+                edge["node"]["name"],
+            )
+            for edge in response.get("artifact", {}).get("usedBy", {}).get("edges", [])
+        ]
+
+    @ensure_logged
+    def logged_by(self) -> Run | None:
+        """Get the W&B run that originally logged the artifact.
+
+        Returns:
+            The name of the W&B run that originally logged the artifact.
+
+        Raises:
+            ArtifactNotLoggedError: If the artifact is not logged.
+        """
+        query = gql(
+            """
+            query ArtifactCreatedBy(
+                $id: ID!
+            ) {
+                artifact(id: $id) {
+                    createdBy {
+                        ... on Run {
+                            name
+                            project {
+                                name
+                                entityName
+                            }
+                        }
+                    }
+                }
+            }
+        """
+        )
+        assert self._client is not None
+        response = self._client.execute(
+            query,
+            variable_values={"id": self.id},
+        )
+        creator = response.get("artifact", {}).get("createdBy", {})
+        if creator.get("name") is None:
+            return None
+        return Run(
+            self._client,
+            creator["project"]["entityName"],
+            creator["project"]["name"],
+            creator["name"],
+        )
+
+    @ensure_logged
+    def json_encode(self) -> dict[str, Any]:
+        """Returns the artifact encoded to the JSON format.
+
+        Returns:
+            A `dict` with `string` keys representing attributes of the artifact.
+        """
+        return util.artifact_to_json(self)
+
+    @staticmethod
+    def _expected_type(
+        entity_name: str, project_name: str, name: str, client: RetryingClient
+    ) -> str | None:
+        """Returns the expected type for a given artifact name and project."""
+        query = gql(
+            """
+            query ArtifactType(
+                $entityName: String,
+                $projectName: String,
+                $name: String!
+            ) {
+                project(name: $projectName, entityName: $entityName) {
+                    artifact(name: $name) {
+                        artifactType {
+                            name
+                        }
+                    }
+                }
+            }
+            """
+        )
+        if ":" not in name:
+            name += ":latest"
+        response = client.execute(
+            query,
+            variable_values={
+                "entityName": entity_name,
+                "projectName": project_name,
+                "name": name,
+            },
+        )
+        return (
+            ((response.get("project") or {}).get("artifact") or {}).get("artifactType")
+            or {}
+        ).get("name")
+
+    @staticmethod
+    def _normalize_metadata(metadata: dict[str, Any] | None) -> dict[str, Any]:
+        if metadata is None:
+            return {}
+        if not isinstance(metadata, dict):
+            raise TypeError(f"metadata must be dict, not {type(metadata)}")
+        return cast(
+            Dict[str, Any], json.loads(json.dumps(util.json_friendly_val(metadata)))
+        )
+
+    def _load_manifest(self, url: str) -> ArtifactManifest:
+        with requests.get(url) as response:
+            response.raise_for_status()
+            return ArtifactManifest.from_manifest_json(response.json())
+
+    def _ttl_duration_seconds_to_gql(self) -> int | None:
+        # Set artifact ttl value to ttl_duration_seconds if the user set a value
+        # otherwise use ttl_status to indicate the backend INHERIT(-1) or DISABLED(-2) when the TTL is None
+        # When ttl_change = None its a no op since nothing changed
+        INHERIT = -1  # noqa: N806
+        DISABLED = -2  # noqa: N806
+
+        if not self._ttl_changed:
+            return None
+        if self._ttl_is_inherited:
+            return INHERIT
+        return self._ttl_duration_seconds or DISABLED
+
+
+def _ttl_duration_seconds_from_gql(gql_ttl_duration_seconds: int | None) -> int | None:
+    # If gql_ttl_duration_seconds is not positive, its indicating that TTL is DISABLED(-2)
+    # gql_ttl_duration_seconds only returns None if the server is not compatible with setting Artifact TTLs
+    if gql_ttl_duration_seconds and gql_ttl_duration_seconds > 0:
+        return gql_ttl_duration_seconds
+    return None
+
+
+def _gql_artifact_fragment() -> str:
+    """Return a GraphQL query fragment with all parseable Artifact attributes."""
+    allowed_fields = set(InternalApi().server_artifact_introspection())
+
+    supports_ttl = "ttlIsInherited" in allowed_fields
+    supports_tags = "tags" in allowed_fields
+
+    ttl_duration_seconds = "ttlDurationSeconds" if supports_ttl else ""
+    ttl_is_inherited = "ttlIsInherited" if supports_ttl else ""
+
+    tags = "tags {name}" if supports_tags else ""
+
+    return f"""
+        fragment ArtifactFragment on Artifact {{
+            id
+            artifactSequence {{
+                project {{
+                    entityName
+                    name
+                }}
+                name
+            }}
+            versionIndex
+            artifactType {{
+                name
+            }}
+            description
+            metadata
+            {ttl_duration_seconds}
+            {ttl_is_inherited}
+            aliases {{
+                artifactCollection {{
+                    project {{
+                        entityName
+                        name
+                    }}
+                    name
+                }}
+                alias
+            }}
+            {tags}
+            state
+            currentManifest {{
+                file {{
+                    directUrl
+                }}
+            }}
+            commitHash
+            fileCount
+            createdAt
+            updatedAt
+        }}
+    """
+
+
+class _ArtifactVersionType(WBType):
+    name = "artifactVersion"
+    types = [Artifact]
+
+
+TypeRegistry.add(_ArtifactVersionType)

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_instance_cache.py

@@ -0,0 +1,17 @@
+"""Recent Artifact storage.
+
+Artifacts are registered in the cache to ensure they won't be immediately garbage
+collected and can be retrieved by their ID.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wandb.sdk.lib.capped_dict import CappedDict
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact import Artifact
+
+# There is nothing special about the artifact cache, it's just a global capped dict.
+artifact_instance_cache: dict[str, Artifact] = CappedDict(100)

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_manifest.py

@@ -0,0 +1,75 @@
+"""Artifact manifest."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping
+
+from wandb.sdk.internal.internal_api import Api as InternalApi
+from wandb.sdk.lib.hashutil import HexMD5
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+    from wandb.sdk.artifacts.storage_policy import StoragePolicy
+
+
+class ArtifactManifest:
+    entries: dict[str, ArtifactManifestEntry]
+
+    @classmethod
+    def from_manifest_json(
+        cls, manifest_json: dict, api: InternalApi | None = None
+    ) -> ArtifactManifest:
+        if "version" not in manifest_json:
+            raise ValueError("Invalid manifest format. Must contain version field.")
+        version = manifest_json["version"]
+        for sub in cls.__subclasses__():
+            if sub.version() == version:
+                return sub.from_manifest_json(manifest_json, api=api)
+        raise ValueError("Invalid manifest version.")
+
+    @classmethod
+    def version(cls) -> int:
+        raise NotImplementedError
+
+    def __init__(
+        self,
+        storage_policy: StoragePolicy,
+        entries: Mapping[str, ArtifactManifestEntry] | None = None,
+    ) -> None:
+        self.storage_policy = storage_policy
+        self.entries = dict(entries) if entries else {}
+
+    def __len__(self) -> int:
+        return len(self.entries)
+
+    def to_manifest_json(self) -> dict:
+        raise NotImplementedError
+
+    def digest(self) -> HexMD5:
+        raise NotImplementedError
+
+    def add_entry(self, entry: ArtifactManifestEntry, overwrite: bool = False) -> None:
+        path = entry.path
+        if not overwrite:
+            prev_entry = self.entries.get(path)
+            if prev_entry and (entry.digest != prev_entry.digest):
+                raise ValueError(f"Cannot add the same path twice: {path!r}")
+        self.entries[path] = entry
+
+    def remove_entry(self, entry: ArtifactManifestEntry) -> None:
+        try:
+            del self.entries[entry.path]
+        except LookupError:
+            raise FileNotFoundError(f"Cannot remove missing entry: '{entry.path}'")
+
+    def get_entry_by_path(self, path: str) -> ArtifactManifestEntry | None:
+        return self.entries.get(path)
+
+    def get_entries_in_directory(self, directory: str) -> list[ArtifactManifestEntry]:
+        return [
+            self.entries[entry_key]
+            for entry_key in self.entries
+            if entry_key.startswith(
+                directory + "/"
+            )  # entries use forward slash even for windows
+        ]

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_manifest_entry.py

@@ -0,0 +1,249 @@
+"""Artifact manifest entry."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+from urllib.parse import urlparse
+
+from wandb.sdk.lib import filesystem
+from wandb.sdk.lib.deprecate import Deprecated, deprecate
+from wandb.sdk.lib.hashutil import (
+    B64MD5,
+    ETag,
+    b64_to_hex_id,
+    hex_to_b64_id,
+    md5_file_b64,
+)
+from wandb.sdk.lib.paths import FilePathStr, LogicalPath, StrPath, URIStr
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    class ArtifactManifestEntryDict(TypedDict, total=False):
+        path: str
+        digest: str
+        skip_cache: bool
+        ref: str
+        birthArtifactID: str
+        size: int
+        extra: dict
+        local_path: str
+
+
+class ArtifactManifestEntry:
+    """A single entry in an artifact manifest."""
+
+    path: LogicalPath
+    digest: B64MD5 | URIStr | FilePathStr | ETag
+    skip_cache: bool
+    ref: FilePathStr | URIStr | None
+    birth_artifact_id: str | None
+    size: int | None
+    extra: dict
+    local_path: str | None
+
+    _parent_artifact: Artifact | None = None
+    _download_url: str | None = None
+
+    def __init__(
+        self,
+        path: StrPath,
+        digest: B64MD5 | URIStr | FilePathStr | ETag,
+        skip_cache: bool | None = False,
+        ref: FilePathStr | URIStr | None = None,
+        birth_artifact_id: str | None = None,
+        size: int | None = None,
+        extra: dict | None = None,
+        local_path: StrPath | None = None,
+    ) -> None:
+        self.path = LogicalPath(path)
+        self.digest = digest
+        self.ref = ref
+        self.birth_artifact_id = birth_artifact_id
+        self.size = size
+        self.extra = extra or {}
+        self.local_path = str(local_path) if local_path else None
+        if self.local_path and self.size is None:
+            self.size = Path(self.local_path).stat().st_size
+        self.skip_cache = skip_cache or False
+
+    def __repr__(self) -> str:
+        cls = self.__class__.__name__
+        ref = f", ref={self.ref!r}" if self.ref is not None else ""
+        birth_artifact_id = (
+            f", birth_artifact_id={self.birth_artifact_id!r}"
+            if self.birth_artifact_id is not None
+            else ""
+        )
+        size = f", size={self.size}" if self.size is not None else ""
+        extra = f", extra={json.dumps(self.extra)}" if self.extra else ""
+        local_path = f", local_path={self.local_path!r}" if self.local_path else ""
+        skip_cache = f", skip_cache={self.skip_cache}"
+        others = ref + birth_artifact_id + size + extra + local_path + skip_cache
+        return f"{cls}(path={self.path!r}, digest={self.digest!r}{others})"
+
+    def __eq__(self, other: object) -> bool:
+        """Strict equality, comparing all public fields.
+
+        ArtifactManifestEntries for the same file may not compare equal if they were
+        added in different ways or created for different parent artifacts.
+        """
+        if not isinstance(other, ArtifactManifestEntry):
+            return False
+        return (
+            self.path == other.path
+            and self.digest == other.digest
+            and self.ref == other.ref
+            and self.birth_artifact_id == other.birth_artifact_id
+            and self.size == other.size
+            and self.extra == other.extra
+            and self.local_path == other.local_path
+            and self.skip_cache == other.skip_cache
+        )
+
+    @property
+    def name(self) -> LogicalPath:
+        """Deprecated; use `path` instead."""
+        deprecate(
+            field_name=Deprecated.artifactmanifestentry__name,
+            warning_message="ArtifactManifestEntry.name is deprecated, use .path instead.",
+        )
+        return self.path
+
+    def parent_artifact(self) -> Artifact:
+        """Get the artifact to which this artifact entry belongs.
+
+        Returns:
+            (PublicArtifact): The parent artifact
+        """
+        if self._parent_artifact is None:
+            raise NotImplementedError
+        return self._parent_artifact
+
+    def download(
+        self, root: str | None = None, skip_cache: bool | None = None
+    ) -> FilePathStr:
+        """Download this artifact entry to the specified root path.
+
+        Args:
+            root: (str, optional) The root path in which to download this
+                artifact entry. Defaults to the artifact's root.
+
+        Returns:
+            (str): The path of the downloaded artifact entry.
+        """
+        if self._parent_artifact is None:
+            raise NotImplementedError
+
+        root = root or self._parent_artifact._default_root()
+        self._parent_artifact._add_download_root(root)
+        path = str(Path(self.path))
+        dest_path = os.path.join(root, path)
+
+        if skip_cache:
+            override_cache_path = dest_path
+        else:
+            override_cache_path = None
+
+        # Skip checking the cache (and possibly downloading) if the file already exists
+        # and has the digest we're expecting.
+        try:
+            md5_hash = md5_file_b64(dest_path)
+        except (FileNotFoundError, IsADirectoryError):
+            logger.debug(f"unable to find {dest_path}, skip searching for file")
+        else:
+            if self.digest == md5_hash:
+                return FilePathStr(dest_path)
+
+        if self.ref is not None:
+            cache_path = self._parent_artifact.manifest.storage_policy.load_reference(
+                self, local=True, dest_path=override_cache_path
+            )
+        else:
+            cache_path = self._parent_artifact.manifest.storage_policy.load_file(
+                self._parent_artifact, self, dest_path=override_cache_path
+            )
+
+        if skip_cache:
+            return FilePathStr(dest_path)
+        else:
+            return FilePathStr(
+                str(filesystem.copy_or_overwrite_changed(cache_path, dest_path))
+            )
+
+    def ref_target(self) -> FilePathStr | URIStr:
+        """Get the reference URL that is targeted by this artifact entry.
+
+        Returns:
+            (str): The reference URL of this artifact entry.
+
+        Raises:
+            ValueError: If this artifact entry was not a reference.
+        """
+        if self.ref is None:
+            raise ValueError("Only reference entries support ref_target().")
+        if self._parent_artifact is None:
+            return self.ref
+        return self._parent_artifact.manifest.storage_policy.load_reference(
+            self._parent_artifact.manifest.entries[self.path], local=False
+        )
+
+    def ref_url(self) -> str:
+        """Get a URL to this artifact entry.
+
+        These URLs can be referenced by another artifact.
+
+        Returns:
+            (str): A URL representing this artifact entry.
+
+        Examples:
+            Basic usage
+            ```
+            ref_url = source_artifact.get_entry("file.txt").ref_url()
+            derived_artifact.add_reference(ref_url)
+            ```
+        """
+        if self._parent_artifact is None:
+            raise NotImplementedError
+        assert self._parent_artifact.id is not None
+        return (
+            "wandb-artifact://"
+            + b64_to_hex_id(B64MD5(self._parent_artifact.id))
+            + "/"
+            + self.path
+        )
+
+    def to_json(self) -> ArtifactManifestEntryDict:
+        contents: ArtifactManifestEntryDict = {
+            "path": self.path,
+            "digest": self.digest,
+        }
+        if self.size is not None:
+            contents["size"] = self.size
+        if self.ref:
+            contents["ref"] = self.ref
+        if self.birth_artifact_id:
+            contents["birthArtifactID"] = self.birth_artifact_id
+        if self.local_path:
+            contents["local_path"] = self.local_path
+        if self.skip_cache:
+            contents["skip_cache"] = self.skip_cache
+        if self.extra:
+            contents["extra"] = self.extra
+        return contents
+
+    def _is_artifact_reference(self) -> bool:
+        return self.ref is not None and urlparse(self.ref).scheme == "wandb-artifact"
+
+    def _referenced_artifact_id(self) -> str | None:
+        if not self._is_artifact_reference():
+            return None
+        return hex_to_b64_id(urlparse(self.ref).netloc)

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_manifests/artifact_manifest_v1.py

@@ -0,0 +1,92 @@
+"""Artifact manifest v1."""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
+from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+from wandb.sdk.artifacts.storage_policy import StoragePolicy
+from wandb.sdk.internal.internal_api import Api as InternalApi
+from wandb.sdk.lib.hashutil import HexMD5, _md5
+
+
+class ArtifactManifestV1(ArtifactManifest):
+    @classmethod
+    def version(cls) -> int:
+        return 1
+
+    @classmethod
+    def from_manifest_json(
+        cls, manifest_json: dict, api: InternalApi | None = None
+    ) -> ArtifactManifestV1:
+        if manifest_json["version"] != cls.version():
+            raise ValueError(
+                "Expected manifest version 1, got {}".format(manifest_json["version"])
+            )
+
+        storage_policy_name = manifest_json["storagePolicy"]
+        storage_policy_config = manifest_json.get("storagePolicyConfig", {})
+        storage_policy_cls = StoragePolicy.lookup_by_name(storage_policy_name)
+
+        entries: Mapping[str, ArtifactManifestEntry]
+        entries = {
+            name: ArtifactManifestEntry(
+                path=name,
+                digest=val["digest"],
+                birth_artifact_id=val.get("birthArtifactID"),
+                ref=val.get("ref"),
+                size=val.get("size"),
+                extra=val.get("extra"),
+                local_path=val.get("local_path"),
+                skip_cache=val.get("skip_cache"),
+            )
+            for name, val in manifest_json["contents"].items()
+        }
+
+        return cls(
+            storage_policy_cls.from_config(storage_policy_config, api=api), entries
+        )
+
+    def __init__(
+        self,
+        storage_policy: StoragePolicy,
+        entries: Mapping[str, ArtifactManifestEntry] | None = None,
+    ) -> None:
+        super().__init__(storage_policy, entries=entries)
+
+    def to_manifest_json(self) -> dict:
+        """This is the JSON that's stored in wandb_manifest.json.
+
+        If include_local is True we also include the local paths to files. This is
+        used to represent an artifact that's waiting to be saved on the current
+        system. We don't need to include the local paths in the artifact manifest
+        contents.
+        """
+        contents = {}
+        for entry in sorted(self.entries.values(), key=lambda k: k.path):
+            json_entry: dict[str, Any] = {
+                "digest": entry.digest,
+            }
+            if entry.birth_artifact_id:
+                json_entry["birthArtifactID"] = entry.birth_artifact_id
+            if entry.ref:
+                json_entry["ref"] = entry.ref
+            if entry.extra:
+                json_entry["extra"] = entry.extra
+            if entry.size is not None:
+                json_entry["size"] = entry.size
+            contents[entry.path] = json_entry
+        return {
+            "version": self.__class__.version(),
+            "storagePolicy": self.storage_policy.name(),
+            "storagePolicyConfig": self.storage_policy.config() or {},
+            "contents": contents,
+        }
+
+    def digest(self) -> HexMD5:
+        hasher = _md5()
+        hasher.update(b"wandb-artifact-manifest-v1\n")
+        for name, entry in sorted(self.entries.items(), key=lambda kv: kv[0]):
+            hasher.update(f"{name}:{entry.digest}\n".encode())
+        return HexMD5(hasher.hexdigest())

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_saver.py

@@ -0,0 +1,265 @@
+"""Artifact saver."""
+
+from __future__ import annotations
+
+import concurrent.futures
+import json
+import os
+import tempfile
+from typing import TYPE_CHECKING, Awaitable, Sequence
+
+import wandb
+import wandb.filesync.step_prepare
+from wandb import util
+from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
+from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, md5_file_b64
+from wandb.sdk.lib.paths import URIStr
+
+if TYPE_CHECKING:
+    from typing import Protocol
+
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+    from wandb.sdk.internal.file_pusher import FilePusher
+    from wandb.sdk.internal.internal_api import Api as InternalApi
+    from wandb.sdk.internal.progress import ProgressFn
+
+    class SaveFn(Protocol):
+        def __call__(
+            self, entry: ArtifactManifestEntry, progress_callback: ProgressFn
+        ) -> bool:
+            pass
+
+    class SaveFnAsync(Protocol):
+        def __call__(
+            self, entry: ArtifactManifestEntry, progress_callback: ProgressFn
+        ) -> Awaitable[bool]:
+            pass
+
+
+class ArtifactSaver:
+    _server_artifact: dict | None  # TODO better define this dict
+
+    def __init__(
+        self,
+        api: InternalApi,
+        digest: str,
+        manifest_json: dict,
+        file_pusher: FilePusher,
+        is_user_created: bool = False,
+    ) -> None:
+        self._api = api
+        self._file_pusher = file_pusher
+        self._digest = digest
+        self._manifest = ArtifactManifest.from_manifest_json(
+            manifest_json,
+            api=self._api,
+        )
+        self._is_user_created = is_user_created
+        self._server_artifact = None
+
+    def save(
+        self,
+        type: str,
+        name: str,
+        client_id: str,
+        sequence_client_id: str,
+        distributed_id: str | None = None,
+        finalize: bool = True,
+        metadata: dict | None = None,
+        ttl_duration_seconds: int | None = None,
+        description: str | None = None,
+        aliases: Sequence[str] | None = None,
+        tags: Sequence[str] | None = None,
+        use_after_commit: bool = False,
+        incremental: bool = False,
+        history_step: int | None = None,
+        base_id: str | None = None,
+    ) -> dict | None:
+        return self._save_internal(
+            type,
+            name,
+            client_id,
+            sequence_client_id,
+            distributed_id,
+            finalize,
+            metadata,
+            ttl_duration_seconds,
+            description,
+            aliases,
+            tags,
+            use_after_commit,
+            incremental,
+            history_step,
+            base_id,
+        )
+
+    def _save_internal(
+        self,
+        type: str,
+        name: str,
+        client_id: str,
+        sequence_client_id: str,
+        distributed_id: str | None = None,
+        finalize: bool = True,
+        metadata: dict | None = None,
+        ttl_duration_seconds: int | None = None,
+        description: str | None = None,
+        aliases: Sequence[str] | None = None,
+        tags: Sequence[str] | None = None,
+        use_after_commit: bool = False,
+        incremental: bool = False,
+        history_step: int | None = None,
+        base_id: str | None = None,
+    ) -> dict | None:
+        alias_specs = []
+        for alias in aliases or []:
+            alias_specs.append({"artifactCollectionName": name, "alias": alias})
+
+        tag_specs = [{"tagName": tag} for tag in tags or []]
+
+        """Returns the server artifact."""
+        self._server_artifact, latest = self._api.create_artifact(
+            type,
+            name,
+            self._digest,
+            metadata=metadata,
+            ttl_duration_seconds=ttl_duration_seconds,
+            aliases=alias_specs,
+            tags=tag_specs,
+            description=description,
+            is_user_created=self._is_user_created,
+            distributed_id=distributed_id,
+            client_id=client_id,
+            sequence_client_id=sequence_client_id,
+            history_step=history_step,
+        )
+
+        assert self._server_artifact is not None  # mypy optionality unwrapper
+        artifact_id = self._server_artifact["id"]
+        if base_id is None and latest:
+            base_id = latest["id"]
+        if self._server_artifact["state"] == "COMMITTED":
+            if use_after_commit:
+                self._api.use_artifact(artifact_id)
+            return self._server_artifact
+        if (
+            self._server_artifact["state"] != "PENDING"
+            # For old servers, see https://github.com/wandb/wandb/pull/6190
+            and self._server_artifact["state"] != "DELETED"
+        ):
+            raise Exception(
+                'Unknown artifact state "{}"'.format(self._server_artifact["state"])
+            )
+
+        manifest_type = "FULL"
+        manifest_filename = "wandb_manifest.json"
+        if incremental:
+            manifest_type = "INCREMENTAL"
+            manifest_filename = "wandb_manifest.incremental.json"
+        elif distributed_id:
+            manifest_type = "PATCH"
+            manifest_filename = "wandb_manifest.patch.json"
+        artifact_manifest_id, _ = self._api.create_artifact_manifest(
+            manifest_filename,
+            "",
+            artifact_id,
+            base_artifact_id=base_id,
+            include_upload=False,
+            type=manifest_type,
+        )
+
+        step_prepare = wandb.filesync.step_prepare.StepPrepare(
+            self._api, 0.1, 0.01, 1000
+        )  # TODO: params
+        step_prepare.start()
+
+        # Upload Artifact "L1" files, the actual artifact contents
+        self._file_pusher.store_manifest_files(
+            self._manifest,
+            artifact_id,
+            lambda entry, progress_callback: self._manifest.storage_policy.store_file(
+                artifact_id,
+                artifact_manifest_id,
+                entry,
+                step_prepare,
+                progress_callback=progress_callback,
+            ),
+        )
+
+        def before_commit() -> None:
+            self._resolve_client_id_manifest_references()
+            with tempfile.NamedTemporaryFile("w+", suffix=".json", delete=False) as fp:
+                path = os.path.abspath(fp.name)
+                json.dump(self._manifest.to_manifest_json(), fp, indent=4)
+            digest = md5_file_b64(path)
+            if distributed_id or incremental:
+                # If we're in the distributed flow, we want to update the
+                # patch manifest we created with our finalized digest.
+                _, resp = self._api.update_artifact_manifest(
+                    artifact_manifest_id,
+                    digest=digest,
+                )
+            else:
+                # In the regular flow, we can recreate the full manifest with the
+                # updated digest.
+                #
+                # NOTE: We do this for backwards compatibility with older backends
+                # that don't support the 'updateArtifactManifest' API.
+                _, resp = self._api.create_artifact_manifest(
+                    manifest_filename,
+                    digest,
+                    artifact_id,
+                    base_artifact_id=base_id,
+                )
+
+            # We're duplicating the file upload logic a little, which isn't great.
+            upload_url = resp["uploadUrl"]
+            upload_headers = resp["uploadHeaders"]
+            extra_headers = {}
+            for upload_header in upload_headers:
+                key, val = upload_header.split(":", 1)
+                extra_headers[key] = val
+            with open(path, "rb") as fp2:
+                self._api.upload_file_retry(
+                    upload_url,
+                    fp2,
+                    extra_headers=extra_headers,
+                )
+
+        commit_result: concurrent.futures.Future[None] = concurrent.futures.Future()
+
+        # This will queue the commit. It will only happen after all the file uploads are done
+        self._file_pusher.commit_artifact(
+            artifact_id,
+            finalize=finalize,
+            before_commit=before_commit,
+            result_future=commit_result,
+        )
+
+        # Block until all artifact files are uploaded and the
+        # artifact is committed.
+        try:
+            commit_result.result()
+        finally:
+            step_prepare.shutdown()
+
+        if finalize and use_after_commit:
+            self._api.use_artifact(artifact_id)
+
+        return self._server_artifact
+
+    def _resolve_client_id_manifest_references(self) -> None:
+        for entry_path in self._manifest.entries:
+            entry = self._manifest.entries[entry_path]
+            if entry.ref is not None:
+                if entry.ref.startswith("wandb-client-artifact:"):
+                    client_id = util.host_from_path(entry.ref)
+                    artifact_file_path = util.uri_from_path(entry.ref)
+                    artifact_id = self._api._resolve_client_id(client_id)
+                    if artifact_id is None:
+                        raise RuntimeError(f"Could not resolve client id {client_id}")
+                    entry.ref = URIStr(
+                        "wandb-artifact://{}/{}".format(
+                            b64_to_hex_id(B64MD5(artifact_id)), artifact_file_path
+                        )
+                    )

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_state.py

@@ -0,0 +1,11 @@
+"""Artifact state."""
+
+from enum import Enum
+
+
+class ArtifactState(Enum):
+    PENDING = "PENDING"
+    COMMITTED = "COMMITTED"
+    DELETED = "DELETED"
+    GARBAGE_COLLECTED = "GARBAGE_COLLECTED"
+    PENDING_DELETION = "PENDING_DELETION"

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/artifact_ttl.py

@@ -0,0 +1,7 @@
+"""Artifact TTL."""
+
+from enum import Enum
+
+
+class ArtifactTTL(Enum):
+    INHERIT = 0

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/exceptions.py

@@ -0,0 +1,57 @@
+"""Artifact exceptions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
+
+from wandb import errors
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    ArtifactT = TypeVar("ArtifactT", bound=Artifact)
+
+
+class ArtifactStatusError(AttributeError):
+    """Raised when an artifact is in an invalid state for the requested operation."""
+
+    def __init__(
+        self,
+        msg: str = "Artifact is in an invalid state for the requested operation.",
+        name: str | None = None,
+        obj: ArtifactT | None = None,
+    ):
+        # Follow the same pattern as AttributeError in python 3.10+ by `name/obj` attributes
+        # See: https://docs.python.org/3/library/exceptions.html#AttributeError
+        try:
+            super().__init__(msg, name=name, obj=obj)
+        except TypeError:
+            # The `name`/`obj` keyword args and attributes were only added in python >= 3.10
+            super().__init__(msg)
+            self.name = name or ""
+            self.obj = obj
+
+
+class ArtifactNotLoggedError(ArtifactStatusError):
+    """Raised for Artifact methods or attributes only available after logging."""
+
+    def __init__(self, fullname: str, obj: ArtifactT):
+        *_, name = fullname.split(".")
+        msg = (
+            f"{fullname!r} used prior to logging artifact or while in offline mode. "
+            f"Call {type(obj).wait.__qualname__}() before accessing logged artifact properties."
+        )
+        super().__init__(msg=msg, name=name, obj=obj)
+
+
+class ArtifactFinalizedError(ArtifactStatusError):
+    """Raised for Artifact methods or attributes that can't be changed after logging."""
+
+    def __init__(self, fullname: str, obj: ArtifactT):
+        *_, name = fullname.split(".")
+        msg = f"{fullname!r} used on logged artifact. Can't modify finalized artifact."
+        super().__init__(msg=msg, name=name, obj=obj)
+
+
+class WaitTimeoutError(errors.Error):
+    """Raised when wait() timeout occurs before process is finished."""

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/staging.py

@@ -0,0 +1,25 @@
+"""Manages artifact file staging.
+
+Artifact files are copied to the staging area as soon as they are added to an artifact
+in order to avoid file changes corrupting the artifact. Once the upload is complete, the
+file should be moved to the artifact cache.
+"""
+
+import os
+
+from wandb import env
+from wandb.sdk.lib.filesystem import mkdir_exists_ok
+from wandb.sdk.lib.paths import FilePathStr
+
+
+def get_staging_dir() -> FilePathStr:
+    path = os.path.join(env.get_data_dir(), "artifacts", "staging")
+    try:
+        mkdir_exists_ok(path)
+    except OSError as e:
+        raise PermissionError(
+            f"Unable to write staging files to {path}. To fix this problem, please set "
+            f"{env.DATA_DIR} to a directory where you have the necessary write access."
+        ) from e
+
+    return FilePathStr(os.path.abspath(os.path.expanduser(path)))

vllm/lib/python3.10/site-packages/wandb/sdk/artifacts/storage_handler.py

@@ -0,0 +1,62 @@
+"""Storage handler."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from wandb.sdk.lib.paths import FilePathStr, URIStr
+
+if TYPE_CHECKING:
+    from urllib.parse import ParseResult
+
+    from wandb.sdk.artifacts.artifact import Artifact
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+
+DEFAULT_MAX_OBJECTS = 10**7
+
+
+class StorageHandler:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
+        """Checks whether this handler can handle the given url.
+
+        Returns:
+            Whether this handler can handle the given url.
+        """
+        raise NotImplementedError
+
+    def load_path(
+        self,
+        manifest_entry: ArtifactManifestEntry,
+        local: bool = False,
+    ) -> URIStr | FilePathStr:
+        """Load a file or directory given the corresponding index entry.
+
+        Args:
+            manifest_entry: The index entry to load
+            local: Whether to load the file locally or not
+
+        Returns:
+            A path to the file represented by `index_entry`
+        """
+        raise NotImplementedError
+
+    def store_path(
+        self,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: str | None = None,
+        checksum: bool = True,
+        max_objects: int | None = None,
+    ) -> Sequence[ArtifactManifestEntry]:
+        """Store the file or directory at the given path to the specified artifact.
+
+        Args:
+            path: The path to store
+            name: If specified, the logical name that should map to `path`
+            checksum: Whether to compute the checksum of the file
+            max_objects: The maximum number of objects to store
+
+        Returns:
+            A list of manifest entries to store within the artifact
+        """
+        raise NotImplementedError