diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_forward_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_forward_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..c2c27968476d6bafa5ac5629d0205f4b8e5c6fe9 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_forward_cpu_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 +#include +#include + +// 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 + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor _cdist_forward(const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional compute_mode); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_floor_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_floor_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d79a0b653d06835297e4a1cf1f2a12c448b893c1 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_floor_cpu_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 +#include +#include + +// 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 + +namespace at { + +namespace cpu { + +TORCH_API ::std::vector _foreach_floor(at::TensorList self); +TORCH_API void _foreach_floor_(at::TensorList self); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_slogdet.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_slogdet.h new file mode 100644 index 0000000000000000000000000000000000000000..34666a692125967c6329a83fce897c641ba5e507 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_slogdet.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_linalg_slogdet(Tensor A) -> (Tensor sign, Tensor logabsdet, Tensor LU, Tensor pivots) +inline ::std::tuple _linalg_slogdet(const at::Tensor & A) { + return at::_ops::_linalg_slogdet::call(A); +} + +// aten::_linalg_slogdet.sign(Tensor A, *, Tensor(a!) sign, Tensor(b!) logabsdet, Tensor(c!) LU, Tensor(d!) pivots) -> (Tensor(a!) sign, Tensor(b!) logabsdet, Tensor(c!) LU, Tensor(d!) pivots) +inline ::std::tuple _linalg_slogdet_out(at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots, const at::Tensor & A) { + return at::_ops::_linalg_slogdet_sign::call(A, sign, logabsdet, LU, pivots); +} +// aten::_linalg_slogdet.sign(Tensor A, *, Tensor(a!) sign, Tensor(b!) logabsdet, Tensor(c!) LU, Tensor(d!) pivots) -> (Tensor(a!) sign, Tensor(b!) logabsdet, Tensor(c!) LU, Tensor(d!) pivots) +inline ::std::tuple _linalg_slogdet_outf(const at::Tensor & A, at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots) { + return at::_ops::_linalg_slogdet_sign::call(A, sign, logabsdet, LU, pivots); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_make_per_tensor_quantized_tensor_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_make_per_tensor_quantized_tensor_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..efa99b6c547cc1e76a759b9b33c0f9af5ab6a5eb --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_make_per_tensor_quantized_tensor_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & _make_per_tensor_quantized_tensor_out(at::Tensor & out, const at::Tensor & self, double scale, int64_t zero_point); +TORCH_API at::Tensor & _make_per_tensor_quantized_tensor_outf(const at::Tensor & self, double scale, int64_t zero_point, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_scale_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_scale_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..7c1d6e64de5ac4bf061999390ae3624a212c428b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_scale_cuda_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 +#include +#include + +// 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 + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor _masked_scale(const at::Tensor & self, const at::Tensor & mask, double scale); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_prelu_kernel_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_prelu_kernel_native.h new file mode 100644 index 0000000000000000000000000000000000000000..ae08f2f272aa64dd642fa427cfc557599c35739a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_prelu_kernel_native.h @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor _prelu_kernel(const at::Tensor & self, const at::Tensor & weight); +TORCH_API at::Tensor mkldnn_prelu(const at::Tensor & self, const at::Tensor & weight); +TORCH_API at::Tensor _prelu_kernel_quantized_cpu(const at::Tensor & self, const at::Tensor & weight); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sobol_engine_draw_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sobol_engine_draw_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..89531fb9278edcc382c81d41b26b9bc3ad96f2fc --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sobol_engine_draw_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API ::std::tuple _sobol_engine_draw(const at::Tensor & quasi, int64_t n, const at::Tensor & sobolstate, int64_t dimension, int64_t num_generated, c10::optional dtype); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_check_tensor.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_check_tensor.h new file mode 100644 index 0000000000000000000000000000000000000000..653ad92194c947f3a25a11c27292ef3f2d74fa95 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_check_tensor.h @@ -0,0 +1,30 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_test_check_tensor(Tensor self) -> Tensor +inline at::Tensor _test_check_tensor(const at::Tensor & self) { + return at::_ops::_test_check_tensor::call(self); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/addcmul_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/addcmul_native.h new file mode 100644 index 0000000000000000000000000000000000000000..ae5d8effd2d13f48d51ae05d886343dbd8c0be02 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/addcmul_native.h @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_addcmul_out : public at::meta::structured_addcmul { +void impl(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value, const at::Tensor & out); +}; +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/bartlett_window.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/bartlett_window.h new file mode 100644 index 0000000000000000000000000000000000000000..0f890ec4f60cf55756641a3b003fbd5d1b944825 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/bartlett_window.h @@ -0,0 +1,61 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor bartlett_window(int64_t window_length, at::TensorOptions options={}) { + return at::_ops::bartlett_window::call(window_length, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor bartlett_window(int64_t window_length, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::bartlett_window::call(window_length, dtype, layout, device, pin_memory); +} + +// aten::bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor bartlett_window(int64_t window_length, bool periodic, at::TensorOptions options={}) { + return at::_ops::bartlett_window_periodic::call(window_length, periodic, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor bartlett_window(int64_t window_length, bool periodic, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::bartlett_window_periodic::call(window_length, periodic, dtype, layout, device, pin_memory); +} + +// aten::bartlett_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bartlett_window_out(at::Tensor & out, int64_t window_length) { + return at::_ops::bartlett_window_out::call(window_length, out); +} +// aten::bartlett_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bartlett_window_outf(int64_t window_length, at::Tensor & out) { + return at::_ops::bartlett_window_out::call(window_length, out); +} + +// aten::bartlett_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bartlett_window_out(at::Tensor & out, int64_t window_length, bool periodic) { + return at::_ops::bartlett_window_periodic_out::call(window_length, periodic, out); +} +// aten::bartlett_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bartlett_window_outf(int64_t window_length, bool periodic, at::Tensor & out) { + return at::_ops::bartlett_window_periodic_out::call(window_length, periodic, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_solve_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_solve_native.h new file mode 100644 index 0000000000000000000000000000000000000000..936c1181fab195df909a88ae703431ebde9436a1 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_solve_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor cholesky_solve(const at::Tensor & self, const at::Tensor & input2, bool upper=false); +TORCH_API at::Tensor & cholesky_solve_out(const at::Tensor & self, const at::Tensor & input2, bool upper, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/eq_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/eq_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..a15f08555822b803f3b3400e9b0da39ea3247f43 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/eq_cpu_dispatch.h @@ -0,0 +1,30 @@ +#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 +#include +#include + +// 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 + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor eq(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & eq_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & eq_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & eq_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor eq(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & eq_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & eq_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & eq_(at::Tensor & self, const at::Tensor & other); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/erf_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/erf_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..2b0b85d47a375a6cbee206e61b1b45768b2ed9a1 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/erf_cuda_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 +#include +#include + +// 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 + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor erf(const at::Tensor & self); +TORCH_API at::Tensor & erf_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & erf_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & erf_(at::Tensor & self); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..87d3f521d623b05e3ae74ba8e93887ccd05a1831 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_cuda_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 +#include +#include + +// 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 + +namespace at { + +namespace cuda { + +TORCH_API ::std::tuple geqrf(const at::Tensor & self); +TORCH_API ::std::tuple geqrf_out(at::Tensor & a, at::Tensor & tau, const at::Tensor & self); +TORCH_API ::std::tuple geqrf_outf(const at::Tensor & self, at::Tensor & a, at::Tensor & tau); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hardswish_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hardswish_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d4793bce95907be7bab651ba176c568b5ed02e1e --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hardswish_cpu_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 +#include +#include + +// 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 + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor hardswish(const at::Tensor & self); +TORCH_API at::Tensor & hardswish_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & hardswish_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & hardswish_(at::Tensor & self); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isin_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isin_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d5a9cf70fbbca31cdd7689a7fe6f4dced9f32b8b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isin_meta_dispatch.h @@ -0,0 +1,31 @@ +#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 +#include +#include + +// 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 + +namespace at { + +namespace meta { + +TORCH_API at::Tensor isin(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_outf(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); +TORCH_API at::Tensor isin(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_outf(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out); +TORCH_API at::Tensor isin(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_out(at::Tensor & out, const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_outf(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isposinf_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isposinf_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..80523e781050ef36805acbfbd675dcaffa7c26c8 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isposinf_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor isposinf(const at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/kl_div_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/kl_div_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3ba4fdf397867c01740c65d98789efa9c4c4c3f7 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/kl_div_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor kl_div(const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean, bool log_target=false); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..a9a642218aaff628ab37261d9493ddd607d36e28 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm_compositeimplicitautograd_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API ::std::tuple lstm(const at::Tensor & input, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first); +TORCH_API ::std::tuple lstm(const at::Tensor & data, const at::Tensor & batch_sizes, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/masked_select_backward_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/masked_select_backward_native.h new file mode 100644 index 0000000000000000000000000000000000000000..20ad74a501feb52014995be8848b271366db65fa --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/masked_select_backward_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor masked_select_backward(const at::Tensor & grad, const at::Tensor & input, const at::Tensor & mask); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/minimum_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/minimum_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..6bba249cec6f5b699071724076bb0666935fda48 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/minimum_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// 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 + +namespace at { +namespace _ops { + + +struct TORCH_API minimum { + using schema = at::Tensor (const 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::minimum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "minimum(Tensor self, Tensor other) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API minimum_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::minimum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "minimum.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/multilabel_margin_loss_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/multilabel_margin_loss_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..bba7d0ecbf4c171e540a9447cfa3f7589e1d6c39 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/multilabel_margin_loss_compositeimplicitautograd_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor multilabel_margin_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean); +TORCH_API at::Tensor & multilabel_margin_loss_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean); +TORCH_API at::Tensor & multilabel_margin_loss_outf(const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/new_zeros.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/new_zeros.h new file mode 100644 index 0000000000000000000000000000000000000000..e8bd2536dd49fec9e1d13d12f173b7e4cf14dee4 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/new_zeros.h @@ -0,0 +1,97 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +namespace symint { + template ::value>> + at::Tensor new_zeros(const at::Tensor & self, at::IntArrayRef size, at::TensorOptions options={}) { + return at::_ops::new_zeros::call(self, c10::fromIntArrayRefSlow(size), optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); + } +} + +namespace symint { + template ::value>> + at::Tensor new_zeros(const at::Tensor & self, at::IntArrayRef size, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::new_zeros::call(self, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory); + } +} + +namespace symint { + template ::value>> + at::Tensor new_zeros(const at::Tensor & self, c10::SymIntArrayRef size, at::TensorOptions options={}) { + return at::_ops::new_zeros::call(self, size, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); + } +} + +namespace symint { + template ::value>> + at::Tensor new_zeros(const at::Tensor & self, c10::SymIntArrayRef size, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::new_zeros::call(self, size, dtype, layout, device, pin_memory); + } +} + +// aten::new_zeros.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_zeros_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) { + return at::_ops::new_zeros_out::call(self, c10::fromIntArrayRefSlow(size), out); +} +namespace symint { + template ::value>> + at::Tensor & new_zeros_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) { + return at::_ops::new_zeros_out::call(self, c10::fromIntArrayRefSlow(size), out); + } +} + +// aten::new_zeros.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_zeros_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) { + return at::_ops::new_zeros_out::call(self, c10::fromIntArrayRefSlow(size), out); +} +namespace symint { + template ::value>> + at::Tensor & new_zeros_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) { + return at::_ops::new_zeros_out::call(self, c10::fromIntArrayRefSlow(size), out); + } +} + +// aten::new_zeros.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_zeros_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) { + return at::_ops::new_zeros_out::call(self, size, out); +} +namespace symint { + template ::value>> + at::Tensor & new_zeros_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) { + return at::_ops::new_zeros_out::call(self, size, out); + } +} + +// aten::new_zeros.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_zeros_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) { + return at::_ops::new_zeros_out::call(self, size, out); +} +namespace symint { + template ::value>> + at::Tensor & new_zeros_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) { + return at::_ops::new_zeros_out::call(self, size, out); + } +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/normal_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/normal_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3f7d5a090449fd008bc2a70f3d3f26ad18ae683c --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/normal_cuda_dispatch.h @@ -0,0 +1,32 @@ +#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 +#include +#include + +// 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 + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor & normal_(at::Tensor & self, double mean=0, double std=1, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor normal(const at::Tensor & mean, double std=1, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor & normal_out(at::Tensor & out, const at::Tensor & mean, double std=1, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor & normal_outf(const at::Tensor & mean, double std, c10::optional generator, at::Tensor & out); +TORCH_API at::Tensor normal(double mean, const at::Tensor & std, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor & normal_out(at::Tensor & out, double mean, const at::Tensor & std, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor & normal_outf(double mean, const at::Tensor & std, c10::optional generator, at::Tensor & out); +TORCH_API at::Tensor normal(const at::Tensor & mean, const at::Tensor & std, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor & normal_out(at::Tensor & out, const at::Tensor & mean, const at::Tensor & std, c10::optional generator=c10::nullopt); +TORCH_API at::Tensor & normal_outf(const at::Tensor & mean, const at::Tensor & std, c10::optional generator, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pdist.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pdist.h new file mode 100644 index 0000000000000000000000000000000000000000..c0e5aa2371dad3c37b776125294f06df6e97ea12 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pdist.h @@ -0,0 +1,30 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::pdist(Tensor self, float p=2) -> Tensor +inline at::Tensor pdist(const at::Tensor & self, double p=2) { + return at::_ops::pdist::call(self, p); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reflection_pad2d_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reflection_pad2d_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..2c16ddf552e3160b1ea3e7d7e6a393e014003dcd --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reflection_pad2d_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 +#include +#include + +// 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 + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor reflection_pad2d(const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor reflection_pad2d_symint(const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & reflection_pad2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor & reflection_pad2d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out); +TORCH_API at::Tensor & reflection_pad2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & reflection_pad2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reshape_as_compositeimplicitautogradnestedtensor_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reshape_as_compositeimplicitautogradnestedtensor_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6ded71dc805d1b73a29485d86aeca626109e5770 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reshape_as_compositeimplicitautogradnestedtensor_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 +#include +#include + +// 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 + +namespace at { + +namespace compositeimplicitautogradnestedtensor { + +TORCH_API at::Tensor reshape_as(const at::Tensor & self, const at::Tensor & other); + +} // namespace compositeimplicitautogradnestedtensor +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest3d_backward_meta.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest3d_backward_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..e8f6bcb9bc213c4041229dab1f52265425214907 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest3d_backward_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_upsample_nearest3d_backward : public at::impl::MetaBase { + + + void meta(const at::Tensor & grad_output, at::ArrayRef output_size, at::ArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w); +}; + +} // namespace native +} // namespace at diff --git a/vllm/lib/python3.10/site-packages/colorful/__init__.py b/vllm/lib/python3.10/site-packages/colorful/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9412a7efe1ca76742be7382767236c9375c390ee --- /dev/null +++ b/vllm/lib/python3.10/site-packages/colorful/__init__.py @@ -0,0 +1,133 @@ +# -*- coding: utf-8 -*- + +""" + colorful + ~~~~~~~~ + + Terminal string styling done right, in Python. + + :copyright: (c) 2017 by Timo Furrer + :license: MIT, see LICENSE for more details. +""" + +import os +import sys +import copy +import types +import platform +from contextlib import contextmanager + +from .core import Colorful +from . import terminal + +#: Holds the current version +__version__ = '0.5.6' + +# if we are on Windows we have to init colorama +if platform.system() == 'Windows': + os.system('color') + + +class ColorfulModule(types.ModuleType): + """ + Module Type object for dynamic attribute access on + this module. + """ + def __init__(self, colorful, *args): + super(ColorfulModule, self).__init__(*args) + self.colorful = colorful + + @contextmanager + def with_setup(self, colormode=None, colorpalette=None, extend_colors=False): + """ + Return a new Colorful object with the given color config. + """ + colorful = Colorful( + colormode=self.colorful.colormode, + colorpalette=copy.copy(self.colorful.colorpalette) + ) + + colorful.setup( + colormode=colormode, colorpalette=colorpalette, extend_colors=extend_colors + ) + yield colorful + + @contextmanager + def with_8_ansi_colors(self): + yield Colorful( + colormode=terminal.ANSI_8_COLORS, + colorpalette=copy.copy(self.colorful.colorpalette) + ) + + @contextmanager + def with_16_ansi_colors(self): + yield Colorful( + colormode=terminal.ANSI_16_COLORS, + colorpalette=copy.copy(self.colorful.colorpalette) + ) + + @contextmanager + def with_256_ansi_colors(self): + yield Colorful( + colormode=terminal.ANSI_256_COLORS, + colorpalette=copy.copy(self.colorful.colorpalette) + ) + + @contextmanager + def with_true_colors(self): + yield Colorful( + colormode=terminal.TRUE_COLORS, + colorpalette=copy.copy(self.colorful.colorpalette) + ) + + @contextmanager + def with_palette(self, colorpalette): + yield Colorful( + colormode=self.colorful.colormode, + colorpalette=colorpalette + ) + + @contextmanager + def with_updated_palette(self, colorpalette): + colorful = Colorful( + colormode=self.colorful.colormode, + colorpalette=copy.copy(self.colorful.colorpalette), + ) + colorful.update_palette(colorpalette) + yield colorful + + @contextmanager + def with_style(self, style_name): + colorful = Colorful( + colormode=self.colorful.colormode, + colorpalette={}, + ) + colorful.use_style(style_name) + yield colorful + + def __getattr__(self, name): + """ + Dynamically get methods from Colorful object. + """ + # check if original module had the requested attribute + # if yes, we have to return it since we don't want to + # break the module functionality + orig_module = __name__ + '_orig' + if orig_module in sys.modules: + try: + return getattr(sys.modules[orig_module], name) + except AttributeError: + pass # fallback to colorful functionality + + return getattr(self.colorful, name) + + +if os.environ.get('COLORFUL_NO_MODULE_OVERWRITE', '0') != '1': + # Unfortunately, prior to Python 3.4 the replaced + # modules gets garbage collected which will + # destroy all currently imported modules. + # To prevent this, is to store a backup of the original + # modules in sys.modules. + sys.modules[__name__ + '_orig'] = sys.modules[__name__] + # expose the Colorful class as module + sys.modules[__name__] = ColorfulModule(Colorful(), __name__) diff --git a/vllm/lib/python3.10/site-packages/colorful/__pycache__/colors.cpython-310.pyc b/vllm/lib/python3.10/site-packages/colorful/__pycache__/colors.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d4c7ef9e45287d0fa20c806be4f470ec218838a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/colorful/__pycache__/colors.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/colorful/__pycache__/core.cpython-310.pyc b/vllm/lib/python3.10/site-packages/colorful/__pycache__/core.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..beb16364e51550d70aabf494d06d6a81d47e1351 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/colorful/__pycache__/core.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/colorful/__pycache__/styles.cpython-310.pyc b/vllm/lib/python3.10/site-packages/colorful/__pycache__/styles.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd74bee08b0ee769537948d840209362a6976845 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/colorful/__pycache__/styles.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/colorful/__pycache__/terminal.cpython-310.pyc b/vllm/lib/python3.10/site-packages/colorful/__pycache__/terminal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5fd78c195ca02a1ebf26496fba0156df10182a99 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/colorful/__pycache__/terminal.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/colorful/ansi.py b/vllm/lib/python3.10/site-packages/colorful/ansi.py new file mode 100644 index 0000000000000000000000000000000000000000..47cc93353892280fecb31fc73a6163ceea3d14cf --- /dev/null +++ b/vllm/lib/python3.10/site-packages/colorful/ansi.py @@ -0,0 +1,89 @@ +# -*- coding: utf-8 -*- + +""" + colorful + ~~~~~~~~ + + Terminal string styling done right, in Python. + + :copyright: (c) 2017 by Timo Furrer + :license: MIT, see LICENSE for more details. +""" + +import math + +# For the ANSI escape code sequences please consult +# https://en.wikipedia.org/wiki/ANSI_escape_code + +#: Holds the modifier names in the correct order +MODIFIERS = { + 'reset': (0, 0), + 'bold': (1, 22), + 'dimmed': (2, 22), + 'italic': (3, 23), + 'underlined': (4, 24), + 'blinkslow': (5, 25), + 'blinkrapid': (6, 25), + 'inversed': (7, 27), + 'concealed': (8, 28), + 'struckthrough': (9, 29) +} + +#: Holds the offset for resetting the modifiers +MODIFIER_RESET_OFFSET = 21 + +#: Holds the start index for the fore- and background colors +FOREGROUND_COLOR_OFFSET = 30 +BACKGROUND_COLOR_OFFSET = 40 + +#: Holds the offset to reset the color back to default. +# this number has to be added to either ``FOREGROUND_COLOR_OFFSET`` or +# ``BACKGROUND_COLOR_OFFSET`` to get an usable ANSI escape code. +COLOR_CLOSE_OFFSET = 9 + +#: Holds the Control Sequence Introducer +CSI = '\033[' + +#: Holds the base ANSI escape code +ANSI_ESCAPE_CODE = '{csi}{{code}}m'.format(csi=CSI) + +#: Holds the placeholder for the nest indicators +NEST_PLACEHOLDER = ANSI_ESCAPE_CODE.format(code=26) + + +def round(value): + x = math.floor(value) + if (value - x) < 0.5: + return int(x) + return int(math.ceil(value)) + + +def rgb_to_ansi256(r, g, b): + """ + Convert RGB to ANSI 256 color + """ + if r == g and g == b: + if r < 8: + return 16 + if r > 248: + return 231 + + return round(((r - 8) / 247.0) * 24) + 232 + + ansi_r = 36 * round(r / 255.0 * 5.0) + ansi_g = 6 * round(g / 255.0 * 5.0) + ansi_b = round(b / 255.0 * 5.0) + ansi = 16 + ansi_r + ansi_g + ansi_b + return ansi + + +def rgb_to_ansi16(r, g, b, use_bright=False): + """ + Convert RGB to ANSI 16 color + """ + ansi_b = round(b / 255.0) << 2 + ansi_g = round(g / 255.0) << 1 + ansi_r = round(r / 255.0) + ansi = (90 if use_bright else 30) + (ansi_b | ansi_g | ansi_r) + + return ansi diff --git a/vllm/lib/python3.10/site-packages/colorful/colors.py b/vllm/lib/python3.10/site-packages/colorful/colors.py new file mode 100644 index 0000000000000000000000000000000000000000..d075d72f5fc0b4a5474a4ce1da73e44671dc9e90 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/colorful/colors.py @@ -0,0 +1,101 @@ +# -*- coding: utf-8 -*- + +""" + colorful + ~~~~~~~~ + + Terminal string styling done right, in Python. + + :copyright: (c) 2017 by Timo Furrer + :license: MIT, see LICENSE for more details. +""" + +import json + +from . import utils + + +def parse_colors(path): + """Parse the given color files. + + Supported are: + * .txt for X11 colors + * .json for colornames + """ + if path.endswith(".txt"): + return parse_rgb_txt_file(path) + elif path.endswith(".json"): + return parse_json_color_file(path) + + raise TypeError("colorful only supports .txt and .json files for colors") + + +def parse_rgb_txt_file(path): + """ + Parse the given rgb.txt file into a Python dict. + + See https://en.wikipedia.org/wiki/X11_color_names for more information + + :param str path: the path to the X11 rgb.txt file + """ + #: Holds the generated color dict + color_dict = {} + + with open(path, 'r') as rgb_txt: + for line in rgb_txt: + line = line.strip() + if not line or line.startswith('!'): + continue # skip comments + + parts = line.split() + color_dict[" ".join(parts[3:])] = (int(parts[0]), int(parts[1]), int(parts[2])) + + return color_dict + + +def parse_json_color_file(path): + """Parse a JSON color file. + + The JSON has to be in the following format: + + .. code:: json + + [{"name": "COLOR_NAME", "hex": "#HEX"}, ...] + + :param str path: the path to the JSON color file + """ + with open(path, "r") as color_file: + color_list = json.load(color_file) + + # transform raw color list into color dict + color_dict = {c["name"]: c["hex"] for c in color_list} + return color_dict + + +def sanitize_color_palette(colorpalette): + """ + Sanitze the given color palette so it can + be safely used by Colorful. + + It will convert colors specified in hex RGB to + a RGB channel triplet. + """ + new_palette = {} + + def __make_valid_color_name(name): + """ + Convert the given name into a valid colorname + """ + if len(name) == 1: + name = name[0] + return name[:1].lower() + name[1:] + + return name[0].lower() + ''.join(word.capitalize() for word in name[1:]) + + for key, value in colorpalette.items(): + if isinstance(value, str): + # we assume it's a hex RGB value + value = utils.hex_to_rgb(value) + new_palette[__make_valid_color_name(key.split())] = value + + return new_palette diff --git a/vllm/lib/python3.10/site-packages/colorful/styles.py b/vllm/lib/python3.10/site-packages/colorful/styles.py new file mode 100644 index 0000000000000000000000000000000000000000..aca53e0f469265019714079c5460d8cf2ca37d6a --- /dev/null +++ b/vllm/lib/python3.10/site-packages/colorful/styles.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- + +""" + colorful + ~~~~~~~~ + + Terminal string styling done right, in Python. + + :copyright: (c) 2017 by Timo Furrer + :license: MIT, see LICENSE for more details. +""" + + +#: Holds the solarized style +SOLARIZED = { + 'base03': '#002b36', + 'base02': '#073642', + 'base01': '#586e75', + 'base00': '#657b83', + 'base0': '#839496', + 'base1': '#93a1a1', + 'base2': '#eee8d5', + 'base3': '#fdf6e3', + 'yellow': '#b58900', + 'orange': '#cb4b16', + 'red': '#dc322f', + 'magenta': '#d33682', + 'violet': '#6c71c4', + 'blue': '#268bd2', + 'cyan': '#2aa198', + 'green': '#859900' +} + +#: Holds the monokai style +MONOKAI = { + 'ghostWhite': '#F8F8F0', + 'lightGhostWhite': '#F8F8F2', + 'lightGray': '#CCCCCC', + 'gray': '#888888', + 'brownGray': '#49483E', + 'darkGray': '#282828', + 'yellow': '#E6DB74', + 'blue': '#66D9EF', + 'magenta': '#F92672', + 'purple': '#AE81FF', + 'brown': '#75715E', + 'orange': '#FD971F', + 'lightOrange': '#FFD569', + 'green': '#A6E22E', + 'seaGreen': '#529B2F' +} diff --git a/vllm/lib/python3.10/site-packages/colorful/terminal.py b/vllm/lib/python3.10/site-packages/colorful/terminal.py new file mode 100644 index 0000000000000000000000000000000000000000..e0ffe76a19232b79a91ffb8ecdd5b89e63e27a90 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/colorful/terminal.py @@ -0,0 +1,80 @@ +# -*- coding: utf-8 -*- + +""" + colorful + ~~~~~~~~ + + Terminal string styling done right, in Python. + + :copyright: (c) 2017 by Timo Furrer + :license: MIT, see LICENSE for more details. +""" + +import sys + + +# Valid color modes for colorful +NO_COLORS = 0 +ANSI_8_COLORS = 8 +ANSI_16_COLORS = 16 +ANSI_256_COLORS = 256 +TRUE_COLORS = 0xFFFFFF + + +def detect_color_support(env): # noqa + """ + Detect what color palettes are supported. + It'll return a valid color mode to use + with colorful. + + :param dict env: the environment dict like returned by ``os.envion`` + """ + if env.get('COLORFUL_DISABLE', '0') == '1': + return NO_COLORS + + if env.get('COLORFUL_FORCE_8_COLORS', '0') == '1': + return ANSI_8_COLORS + + if env.get('COLORFUL_FORCE_16_COLORS', '0') == '1': + return ANSI_16_COLORS + + if env.get('COLORFUL_FORCE_256_COLORS', '0') == '1': + return ANSI_256_COLORS + + if env.get('COLORFUL_FORCE_TRUE_COLORS', '0') == '1': + return TRUE_COLORS + + # if we are not a tty + if not sys.stdout.isatty(): + return NO_COLORS + + colorterm_env = env.get('COLORTERM') + if colorterm_env: + if colorterm_env in {'truecolor', '24bit'}: + return TRUE_COLORS + + if colorterm_env in {'8bit'}: + return ANSI_256_COLORS + + termprog_env = env.get('TERM_PROGRAM') + if termprog_env: + if termprog_env in {'iTerm.app', 'Hyper'}: + return TRUE_COLORS + + if termprog_env in {'Apple_Terminal'}: + return ANSI_256_COLORS + + term_env = env.get('TERM') + if term_env: + if term_env in {'screen-256', 'screen-256color', 'xterm-256', 'xterm-256color'}: + return ANSI_256_COLORS + + if term_env in {'screen', 'xterm', 'vt100', 'color', 'ansi', 'cygwin', 'linux'}: + return ANSI_16_COLORS + + if colorterm_env: + # if there was no match with $TERM either but we + # had one with $COLORTERM, we use it! + return ANSI_16_COLORS + + return ANSI_8_COLORS diff --git a/vllm/lib/python3.10/site-packages/colorful/utils.py b/vllm/lib/python3.10/site-packages/colorful/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8b6bd7a073318cf39037255c2b0b63fdc376d3da --- /dev/null +++ b/vllm/lib/python3.10/site-packages/colorful/utils.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- + +""" + colorful + ~~~~~~~~ + + Terminal string styling done right, in Python. + + :copyright: (c) 2017 by Timo Furrer + :license: MIT, see LICENSE for more details. +""" +import re + + +def hex_to_rgb(value): + """ + Convert the given hex string to a + valid RGB channel triplet. + """ + value = value.lstrip('#') + check_hex(value) + + length = len(value) + step = int(length / 3) + return tuple(int(value[i:i+step], 16) for i in range(0, length, step)) + + +def check_hex(value): + """ + Check if the given hex value is a valid RGB color + + It should match the format: [0-9a-fA-F] + and be of length 3 or 6. + """ + length = len(value) + if length not in (3, 6): + raise ValueError('Hex string #{} is too long'.format(value)) + + regex = r'[0-9a-f]{{{length}}}'.format(length=length) + if not re.search(regex, value, re.I): + raise ValueError('Invalid Hex String: #{}'.format(value)) diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c437a86403aee7c22da291a88706bd5567233173 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/_optical_flow.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/_optical_flow.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..151719adef43f50ce87d996d8e875e1072663637 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/_optical_flow.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/_stereo_matching.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/_stereo_matching.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffce5ea13bb19d09c0399df932f67e1c0964accc Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/_stereo_matching.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/celeba.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/celeba.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29faca19e3f79019c775ee5727301875ec4ef18f Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/celeba.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/clevr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/clevr.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..361aec0012a7a0920a0bb954aacd2ce33192f78f Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/clevr.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/coco.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/coco.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50b8217b72e48bbf639e4a9afaaa20a7623e55b7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/coco.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/dtd.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/dtd.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..451c37188d07e257e8abc1eb490d165e34217d74 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/dtd.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/eurosat.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/eurosat.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac02095aa04e872856378132f91d9c9025341391 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/eurosat.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fakedata.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fakedata.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9d16866ebc858a157ab35bd1bb8534c414e26ec Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fakedata.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fer2013.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fer2013.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f703d148be41824a073edd7e8f8bd7cbdb9d6cd8 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fer2013.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fgvc_aircraft.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fgvc_aircraft.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e1031fa71fbb465e5c6a9538fa956065b838dd0 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/fgvc_aircraft.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/flickr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/flickr.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97c130a8d1a77f4eca767d6d647bb175ae076549 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/flickr.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/flowers102.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/flowers102.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40d7ff2c72d073bdbb0e7ef8d57a4ad7807ca30f Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/flowers102.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/imagenette.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/imagenette.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..399cc152d8cd29bd84b45c59b8f59aee8388f09d Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/imagenette.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/inaturalist.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/inaturalist.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..879bc62750998714fb4e97f270649a3c3a03e8f2 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/inaturalist.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/kitti.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/kitti.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d619f3dfeec9d40148f5b5aae87a2c67dfa90499 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/kitti.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/lsun.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/lsun.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba4ebf73679e39236360ce8fe6bd54ef52c3c8f7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/lsun.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/omniglot.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/omniglot.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41a1fe04d066b41f147a0b8cf6d11d65024d39f0 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/omniglot.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/pcam.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/pcam.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..147cee33962becd7360bfe6da64ed8fcd0e6c37a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/pcam.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/places365.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/places365.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7f5ff5d0ba5b060af07f91f020d808d18c70593 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/places365.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/sbd.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/sbd.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3fd5392711bdfeb31ce04e34bf540eb83a79ea70 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/sbd.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/sbu.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/sbu.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9120b0892be74e6bab02cde9dbfde9dcf878fc65 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/sbu.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/semeion.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/semeion.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2655049deb2cc7e48bc03c5ba90d3fc192f6176d Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/semeion.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/stanford_cars.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/stanford_cars.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..acc8c3ec78d9d203a58775a4dffce5ce6fe3cc36 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/stanford_cars.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/svhn.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/svhn.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95d0ea6f59809687f538845c643d4324e68fa8ac Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/svhn.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/ucf101.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/ucf101.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66f888a2806c94c4360b59382bddb575320a9f1a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/ucf101.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/usps.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/usps.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c582dc7f6e8efd0eac09d14c51b690a167d5b671 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/usps.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/video_utils.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/video_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c853911e9ec9ce033c880a807997b256fafe0c97 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/video_utils.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/vision.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/vision.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6f4e0eb035398e8c9b9c1d76c5b5630c0fbba27 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/vision.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/voc.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/voc.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d096b38229cdeaf848c177c27e5a727f13050e24 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/voc.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/widerface.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/widerface.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da1db0ec295c1eef26f01860a826db36f4beced1 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/__pycache__/widerface.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__init__.py b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..58b2d2abd936d885221174d194a633a8e413935f --- /dev/null +++ b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__init__.py @@ -0,0 +1,3 @@ +from .clip_sampler import DistributedSampler, RandomClipSampler, UniformClipSampler + +__all__ = ("DistributedSampler", "UniformClipSampler", "RandomClipSampler") diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..267df3e39fc6891c2c5fa9f466b306b857f33eda Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__pycache__/clip_sampler.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__pycache__/clip_sampler.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c212fa2b26715d33c284fbc79e320f207da2b3c6 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/__pycache__/clip_sampler.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/clip_sampler.py b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/clip_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..026c3d75d3b8acd5d0240d8e537e608a92cddfdb --- /dev/null +++ b/vllm/lib/python3.10/site-packages/torchvision/datasets/samplers/clip_sampler.py @@ -0,0 +1,172 @@ +import math +from typing import cast, Iterator, List, Optional, Sized, Union + +import torch +import torch.distributed as dist +from torch.utils.data import Sampler +from torchvision.datasets.video_utils import VideoClips + + +class DistributedSampler(Sampler): + """ + Extension of DistributedSampler, as discussed in + https://github.com/pytorch/pytorch/issues/23430 + + Example: + dataset: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] + num_replicas: 4 + shuffle: False + + when group_size = 1 + RANK | shard_dataset + ========================= + rank_0 | [0, 4, 8, 12] + rank_1 | [1, 5, 9, 13] + rank_2 | [2, 6, 10, 0] + rank_3 | [3, 7, 11, 1] + + when group_size = 2 + + RANK | shard_dataset + ========================= + rank_0 | [0, 1, 8, 9] + rank_1 | [2, 3, 10, 11] + rank_2 | [4, 5, 12, 13] + rank_3 | [6, 7, 0, 1] + + """ + + def __init__( + self, + dataset: Sized, + num_replicas: Optional[int] = None, + rank: Optional[int] = None, + shuffle: bool = False, + group_size: int = 1, + ) -> None: + if num_replicas is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + num_replicas = dist.get_world_size() + if rank is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + rank = dist.get_rank() + if len(dataset) % group_size != 0: + raise ValueError( + f"dataset length must be a multiplier of group size dataset length: {len(dataset)}, group size: {group_size}" + ) + self.dataset = dataset + self.group_size = group_size + self.num_replicas = num_replicas + self.rank = rank + self.epoch = 0 + dataset_group_length = len(dataset) // group_size + self.num_group_samples = int(math.ceil(dataset_group_length * 1.0 / self.num_replicas)) + self.num_samples = self.num_group_samples * group_size + self.total_size = self.num_samples * self.num_replicas + self.shuffle = shuffle + + def __iter__(self) -> Iterator[int]: + # deterministically shuffle based on epoch + g = torch.Generator() + g.manual_seed(self.epoch) + indices: Union[torch.Tensor, List[int]] + if self.shuffle: + indices = torch.randperm(len(self.dataset), generator=g).tolist() + else: + indices = list(range(len(self.dataset))) + + # add extra samples to make it evenly divisible + indices += indices[: (self.total_size - len(indices))] + assert len(indices) == self.total_size + + total_group_size = self.total_size // self.group_size + indices = torch.reshape(torch.LongTensor(indices), (total_group_size, self.group_size)) + + # subsample + indices = indices[self.rank : total_group_size : self.num_replicas, :] + indices = torch.reshape(indices, (-1,)).tolist() + assert len(indices) == self.num_samples + + if isinstance(self.dataset, Sampler): + orig_indices = list(iter(self.dataset)) + indices = [orig_indices[i] for i in indices] + + return iter(indices) + + def __len__(self) -> int: + return self.num_samples + + def set_epoch(self, epoch: int) -> None: + self.epoch = epoch + + +class UniformClipSampler(Sampler): + """ + Sample `num_video_clips_per_video` clips for each video, equally spaced. + When number of unique clips in the video is fewer than num_video_clips_per_video, + repeat the clips until `num_video_clips_per_video` clips are collected + + Args: + video_clips (VideoClips): video clips to sample from + num_clips_per_video (int): number of clips to be sampled per video + """ + + def __init__(self, video_clips: VideoClips, num_clips_per_video: int) -> None: + if not isinstance(video_clips, VideoClips): + raise TypeError(f"Expected video_clips to be an instance of VideoClips, got {type(video_clips)}") + self.video_clips = video_clips + self.num_clips_per_video = num_clips_per_video + + def __iter__(self) -> Iterator[int]: + idxs = [] + s = 0 + # select num_clips_per_video for each video, uniformly spaced + for c in self.video_clips.clips: + length = len(c) + if length == 0: + # corner case where video decoding fails + continue + + sampled = torch.linspace(s, s + length - 1, steps=self.num_clips_per_video).floor().to(torch.int64) + s += length + idxs.append(sampled) + return iter(cast(List[int], torch.cat(idxs).tolist())) + + def __len__(self) -> int: + return sum(self.num_clips_per_video for c in self.video_clips.clips if len(c) > 0) + + +class RandomClipSampler(Sampler): + """ + Samples at most `max_video_clips_per_video` clips for each video randomly + + Args: + video_clips (VideoClips): video clips to sample from + max_clips_per_video (int): maximum number of clips to be sampled per video + """ + + def __init__(self, video_clips: VideoClips, max_clips_per_video: int) -> None: + if not isinstance(video_clips, VideoClips): + raise TypeError(f"Expected video_clips to be an instance of VideoClips, got {type(video_clips)}") + self.video_clips = video_clips + self.max_clips_per_video = max_clips_per_video + + def __iter__(self) -> Iterator[int]: + idxs = [] + s = 0 + # select at most max_clips_per_video for each video, randomly + for c in self.video_clips.clips: + length = len(c) + size = min(length, self.max_clips_per_video) + sampled = torch.randperm(length)[:size] + s + s += length + idxs.append(sampled) + idxs_ = torch.cat(idxs) + # shuffle all clips randomly + perm = torch.randperm(len(idxs_)) + return iter(idxs_[perm].tolist()) + + def __len__(self) -> int: + return sum(min(len(c), self.max_clips_per_video) for c in self.video_clips.clips) diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/svhn.py b/vllm/lib/python3.10/site-packages/torchvision/datasets/svhn.py new file mode 100644 index 0000000000000000000000000000000000000000..5d20d7db7e3ccc1d77c5949830cf7b610d88355f --- /dev/null +++ b/vllm/lib/python3.10/site-packages/torchvision/datasets/svhn.py @@ -0,0 +1,130 @@ +import os.path +from pathlib import Path +from typing import Any, Callable, Optional, Tuple, Union + +import numpy as np +from PIL import Image + +from .utils import check_integrity, download_url, verify_str_arg +from .vision import VisionDataset + + +class SVHN(VisionDataset): + """`SVHN `_ Dataset. + Note: The SVHN dataset assigns the label `10` to the digit `0`. However, in this Dataset, + we assign the label `0` to the digit `0` to be compatible with PyTorch loss functions which + expect the class labels to be in the range `[0, C-1]` + + .. warning:: + + This class needs `scipy `_ to load data from `.mat` format. + + Args: + root (str or ``pathlib.Path``): Root directory of the dataset where the data is stored. + split (string): One of {'train', 'test', 'extra'}. + Accordingly dataset is selected. 'extra' is Extra training set. + transform (callable, optional): A function/transform that takes in a PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + + """ + + split_list = { + "train": [ + "http://ufldl.stanford.edu/housenumbers/train_32x32.mat", + "train_32x32.mat", + "e26dedcc434d2e4c54c9b2d4a06d8373", + ], + "test": [ + "http://ufldl.stanford.edu/housenumbers/test_32x32.mat", + "test_32x32.mat", + "eb5a983be6a315427106f1b164d9cef3", + ], + "extra": [ + "http://ufldl.stanford.edu/housenumbers/extra_32x32.mat", + "extra_32x32.mat", + "a93ce644f1a588dc4d68dda5feec44a7", + ], + } + + def __init__( + self, + root: Union[str, Path], + split: str = "train", + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + download: bool = False, + ) -> None: + super().__init__(root, transform=transform, target_transform=target_transform) + self.split = verify_str_arg(split, "split", tuple(self.split_list.keys())) + self.url = self.split_list[split][0] + self.filename = self.split_list[split][1] + self.file_md5 = self.split_list[split][2] + + if download: + self.download() + + if not self._check_integrity(): + raise RuntimeError("Dataset not found or corrupted. You can use download=True to download it") + + # import here rather than at top of file because this is + # an optional dependency for torchvision + import scipy.io as sio + + # reading(loading) mat file as array + loaded_mat = sio.loadmat(os.path.join(self.root, self.filename)) + + self.data = loaded_mat["X"] + # loading from the .mat file gives an np.ndarray of type np.uint8 + # converting to np.int64, so that we have a LongTensor after + # the conversion from the numpy array + # the squeeze is needed to obtain a 1D tensor + self.labels = loaded_mat["y"].astype(np.int64).squeeze() + + # the svhn dataset assigns the class label "10" to the digit 0 + # this makes it inconsistent with several loss functions + # which expect the class labels to be in the range [0, C-1] + np.place(self.labels, self.labels == 10, 0) + self.data = np.transpose(self.data, (3, 2, 0, 1)) + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is index of the target class. + """ + img, target = self.data[index], int(self.labels[index]) + + # doing this so that it is consistent with all other datasets + # to return a PIL Image + img = Image.fromarray(np.transpose(img, (1, 2, 0))) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = self.target_transform(target) + + return img, target + + def __len__(self) -> int: + return len(self.data) + + def _check_integrity(self) -> bool: + root = self.root + md5 = self.split_list[self.split][2] + fpath = os.path.join(root, self.filename) + return check_integrity(fpath, md5) + + def download(self) -> None: + md5 = self.split_list[self.split][2] + download_url(self.url, self.root, self.filename, md5) + + def extra_repr(self) -> str: + return "Split: {split}".format(**self.__dict__) diff --git a/vllm/lib/python3.10/site-packages/torchvision/datasets/vision.py b/vllm/lib/python3.10/site-packages/torchvision/datasets/vision.py new file mode 100644 index 0000000000000000000000000000000000000000..e524c67e263abd9ec9ed5b86aa55203e1f3ba144 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/torchvision/datasets/vision.py @@ -0,0 +1,111 @@ +import os +from pathlib import Path +from typing import Any, Callable, List, Optional, Tuple, Union + +import torch.utils.data as data + +from ..utils import _log_api_usage_once + + +class VisionDataset(data.Dataset): + """ + Base Class For making datasets which are compatible with torchvision. + It is necessary to override the ``__getitem__`` and ``__len__`` method. + + Args: + root (string, optional): Root directory of dataset. Only used for `__repr__`. + transforms (callable, optional): A function/transforms that takes in + an image and a label and returns the transformed versions of both. + transform (callable, optional): A function/transform that takes in a PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + + .. note:: + + :attr:`transforms` and the combination of :attr:`transform` and :attr:`target_transform` are mutually exclusive. + """ + + _repr_indent = 4 + + def __init__( + self, + root: Union[str, Path] = None, # type: ignore[assignment] + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + ) -> None: + _log_api_usage_once(self) + if isinstance(root, str): + root = os.path.expanduser(root) + self.root = root + + has_transforms = transforms is not None + has_separate_transform = transform is not None or target_transform is not None + if has_transforms and has_separate_transform: + raise ValueError("Only transforms or transform/target_transform can be passed as argument") + + # for backwards-compatibility + self.transform = transform + self.target_transform = target_transform + + if has_separate_transform: + transforms = StandardTransform(transform, target_transform) + self.transforms = transforms + + def __getitem__(self, index: int) -> Any: + """ + Args: + index (int): Index + + Returns: + (Any): Sample and meta data, optionally transformed by the respective transforms. + """ + raise NotImplementedError + + def __len__(self) -> int: + raise NotImplementedError + + def __repr__(self) -> str: + head = "Dataset " + self.__class__.__name__ + body = [f"Number of datapoints: {self.__len__()}"] + if self.root is not None: + body.append(f"Root location: {self.root}") + body += self.extra_repr().splitlines() + if hasattr(self, "transforms") and self.transforms is not None: + body += [repr(self.transforms)] + lines = [head] + [" " * self._repr_indent + line for line in body] + return "\n".join(lines) + + def _format_transform_repr(self, transform: Callable, head: str) -> List[str]: + lines = transform.__repr__().splitlines() + return [f"{head}{lines[0]}"] + ["{}{}".format(" " * len(head), line) for line in lines[1:]] + + def extra_repr(self) -> str: + return "" + + +class StandardTransform: + def __init__(self, transform: Optional[Callable] = None, target_transform: Optional[Callable] = None) -> None: + self.transform = transform + self.target_transform = target_transform + + def __call__(self, input: Any, target: Any) -> Tuple[Any, Any]: + if self.transform is not None: + input = self.transform(input) + if self.target_transform is not None: + target = self.target_transform(target) + return input, target + + def _format_transform_repr(self, transform: Callable, head: str) -> List[str]: + lines = transform.__repr__().splitlines() + return [f"{head}{lines[0]}"] + ["{}{}".format(" " * len(head), line) for line in lines[1:]] + + def __repr__(self) -> str: + body = [self.__class__.__name__] + if self.transform is not None: + body += self._format_transform_repr(self.transform, "Transform: ") + if self.target_transform is not None: + body += self._format_transform_repr(self.target_transform, "Target transform: ") + + return "\n".join(body)