diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_addmm_activation_meta.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_addmm_activation_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..849ca5fec0e90f591d84717958ac70ed8b2eb508 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_addmm_activation_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__addmm_activation : public at::impl::MetaBase { + + + void meta(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu); +}; + +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_convolution_double_backward_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_convolution_double_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..e6c44c7fd61ab40eb35b06afd2157bfadda6fc7f --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_convolution_double_backward_ops.h @@ -0,0 +1,28 @@ +#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 _convolution_double_backward { + using schema = ::std::tuple (const c10::optional &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, bool, c10::SymIntArrayRef, c10::SymInt, ::std::array); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_convolution_double_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_convolution_double_backward(Tensor? ggI, Tensor? ggW, Tensor? ggb, Tensor gO, Tensor weight, Tensor self, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor)") + static ::std::tuple call(const c10::optional & ggI, const c10::optional & ggW, const c10::optional & ggb, const at::Tensor & gO, const at::Tensor & weight, const at::Tensor & self, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array output_mask); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const c10::optional & ggI, const c10::optional & ggW, const c10::optional & ggb, const at::Tensor & gO, const at::Tensor & weight, const at::Tensor & self, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array output_mask); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..8272599eb8fc95c315f0af85dd2c954cc22ef0de --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_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 ::std::tuple _embedding_bag_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq=false, int64_t mode=0, bool sparse=false, const c10::optional & per_sample_weights={}, bool include_last_offset=false, int64_t padding_idx=-1); +TORCH_API ::std::tuple _embedding_bag_outf(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const c10::optional & per_sample_weights, bool include_last_offset, int64_t padding_idx, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine.h new file mode 100644 index 0000000000000000000000000000000000000000..eb3bd2b77a5855f4553e35dbe92d97081d2dd882 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine.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::_fake_quantize_learnable_per_tensor_affine(Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max, float grad_factor=1.0) -> Tensor +inline at::Tensor _fake_quantize_learnable_per_tensor_affine(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t quant_min, int64_t quant_max, double grad_factor=1.0) { + return at::_ops::_fake_quantize_learnable_per_tensor_affine::call(self, scale, zero_point, quant_min, quant_max, grad_factor); +} + +// aten::_fake_quantize_learnable_per_tensor_affine.out(Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max, float grad_factor=1.0, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _fake_quantize_learnable_per_tensor_affine_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t quant_min, int64_t quant_max, double grad_factor=1.0) { + return at::_ops::_fake_quantize_learnable_per_tensor_affine_out::call(self, scale, zero_point, quant_min, quant_max, grad_factor, out); +} +// aten::_fake_quantize_learnable_per_tensor_affine.out(Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max, float grad_factor=1.0, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _fake_quantize_learnable_per_tensor_affine_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t quant_min, int64_t quant_max, double grad_factor, at::Tensor & out) { + return at::_ops::_fake_quantize_learnable_per_tensor_affine_out::call(self, scale, zero_point, quant_min, quant_max, grad_factor, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_adamw_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_adamw_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..bf58972aaf2b57587e9387a1cfdbb0425ddf304f --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_adamw_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 +#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 void _fused_adamw_(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const c10::optional & grad_scale={}, const c10::optional & found_inf={}); +TORCH_API void _fused_adamw_(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const c10::optional & grad_scale={}, const c10::optional & found_inf={}); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..82fd19c70f022d615634b61487af8e957aaa0968 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_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 ::std::tuple _fused_moving_avg_obs_fq_helper(const at::Tensor & self, const at::Tensor & observer_on, const at::Tensor & fake_quant_on, at::Tensor & running_min, at::Tensor & running_max, at::Tensor & scale, at::Tensor & zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, bool per_row_fake_quant=false, bool symmetric_quant=false); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_slogdet_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_slogdet_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3aa0fbc39d445de7e925603361b0d84cb250bae1 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_slogdet_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 _linalg_slogdet(const at::Tensor & A); +TORCH_API ::std::tuple _linalg_slogdet_out(at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots, const at::Tensor & A); +TORCH_API ::std::tuple _linalg_slogdet_outf(const at::Tensor & A, at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_softmax_backward_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_softmax_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..61cf50e0b4955be2abc32984a5f40a1d33334985 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_softmax_backward_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 _masked_softmax_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_masked_softmax_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_masked_softmax_backward(Tensor grad_output, Tensor output, Tensor mask, int? dim=None) -> Tensor") + static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, c10::optional dim); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, c10::optional dim); +}; + +struct TORCH_API _masked_softmax_backward_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_masked_softmax_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_masked_softmax_backward.out(Tensor grad_output, Tensor output, Tensor mask, int? dim=None, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, c10::optional dim, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, c10::optional dim, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_native_batch_norm_legit.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_native_batch_norm_legit.h new file mode 100644 index 0000000000000000000000000000000000000000..d467c2a7507ef6694652bf8f4797a6a83c3ed169 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_native_batch_norm_legit.h @@ -0,0 +1,58 @@ +#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::_native_batch_norm_legit(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor) +inline ::std::tuple _native_batch_norm_legit(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps) { + return at::_ops::_native_batch_norm_legit::call(input, weight, bias, running_mean, running_var, training, momentum, eps); +} + +// aten::_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!)) +inline ::std::tuple _native_batch_norm_legit_out(at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd, const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps) { + return at::_ops::_native_batch_norm_legit_out::call(input, weight, bias, running_mean, running_var, training, momentum, eps, out, save_mean, save_invstd); +} +// aten::_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!)) +inline ::std::tuple _native_batch_norm_legit_outf(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd) { + return at::_ops::_native_batch_norm_legit_out::call(input, weight, bias, running_mean, running_var, training, momentum, eps, out, save_mean, save_invstd); +} + +// aten::_native_batch_norm_legit.no_stats(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor) +inline ::std::tuple _native_batch_norm_legit(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, bool training, double momentum, double eps) { + return at::_ops::_native_batch_norm_legit_no_stats::call(input, weight, bias, training, momentum, eps); +} + +// aten::_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!)) +inline ::std::tuple _native_batch_norm_legit_out(at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd, const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, bool training, double momentum, double eps) { + return at::_ops::_native_batch_norm_legit_no_stats_out::call(input, weight, bias, training, momentum, eps, out, save_mean, save_invstd); +} +// aten::_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!)) +inline ::std::tuple _native_batch_norm_legit_outf(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd) { + return at::_ops::_native_batch_norm_legit_no_stats_out::call(input, weight, bias, training, momentum, eps, out, save_mean, save_invstd); +} + +// aten::_native_batch_norm_legit_functional(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor, Tensor running_mean_out, Tensor running_var_out) +inline ::std::tuple _native_batch_norm_legit_functional(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const at::Tensor & running_mean, const at::Tensor & running_var, bool training, double momentum, double eps) { + return at::_ops::_native_batch_norm_legit_functional::call(input, weight, bias, running_mean, running_var, training, momentum, eps); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_view_from_buffer_copy_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_view_from_buffer_copy_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..2816f51117ca47bfe421c7e7d89fda27b742bf7e --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_view_from_buffer_copy_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 _nested_view_from_buffer_copy(const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_pdist_forward_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_pdist_forward_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..2a947bf4f3bea45fb02c0e0377eca291070c7860 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_pdist_forward_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 & _pdist_forward_out(at::Tensor & out, const at::Tensor & self, double p=2); +TORCH_API at::Tensor & _pdist_forward_outf(const at::Tensor & self, double p, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_trilinear_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_trilinear_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..4368ffd655f67ff5ab139f2e63af036ceea94394 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_trilinear_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 & _trilinear_out(at::Tensor & out, const at::Tensor & i1, const at::Tensor & i2, const at::Tensor & i3, at::IntArrayRef expand1, at::IntArrayRef expand2, at::IntArrayRef expand3, at::IntArrayRef sumdim, int64_t unroll_dim=1); +TORCH_API at::Tensor & _trilinear_outf(const at::Tensor & i1, const at::Tensor & i2, const at::Tensor & i3, at::IntArrayRef expand1, at::IntArrayRef expand2, at::IntArrayRef expand3, at::IntArrayRef sumdim, int64_t unroll_dim, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d.h new file mode 100644 index 0000000000000000000000000000000000000000..b601652ebf34987e734facd2da2cb2ffd1ca1ae0 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d.h @@ -0,0 +1,113 @@ +#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::_upsample_nearest_exact1d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor +inline at::Tensor _upsample_nearest_exact1d(const at::Tensor & input, at::OptionalIntArrayRef output_size, c10::optional> scale_factors) { + return at::_ops::_upsample_nearest_exact1d_vec::call(input, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt, scale_factors); +} +namespace symint { + template ::value>> + at::Tensor _upsample_nearest_exact1d(const at::Tensor & input, at::OptionalIntArrayRef output_size, c10::optional> scale_factors) { + return at::_ops::_upsample_nearest_exact1d_vec::call(input, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt, scale_factors); + } +} + +// aten::_upsample_nearest_exact1d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor +inline at::Tensor _upsample_nearest_exact1d_symint(const at::Tensor & input, at::OptionalSymIntArrayRef output_size, c10::optional> scale_factors) { + return at::_ops::_upsample_nearest_exact1d_vec::call(input, output_size, scale_factors); +} +namespace symint { + template ::value>> + at::Tensor _upsample_nearest_exact1d(const at::Tensor & input, at::OptionalSymIntArrayRef output_size, c10::optional> scale_factors) { + return at::_ops::_upsample_nearest_exact1d_vec::call(input, output_size, scale_factors); + } +} + +// aten::_upsample_nearest_exact1d.out(Tensor self, SymInt[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _upsample_nearest_exact1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, c10::fromIntArrayRefSlow(output_size), scales, out); +} +namespace symint { + template ::value>> + at::Tensor & _upsample_nearest_exact1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, c10::fromIntArrayRefSlow(output_size), scales, out); + } +} + +// aten::_upsample_nearest_exact1d.out(Tensor self, SymInt[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _upsample_nearest_exact1d_outf(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales, at::Tensor & out) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, c10::fromIntArrayRefSlow(output_size), scales, out); +} +namespace symint { + template ::value>> + at::Tensor & _upsample_nearest_exact1d_outf(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales, at::Tensor & out) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, c10::fromIntArrayRefSlow(output_size), scales, out); + } +} + +// aten::_upsample_nearest_exact1d.out(Tensor self, SymInt[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _upsample_nearest_exact1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, output_size, scales, out); +} +namespace symint { + template ::value>> + at::Tensor & _upsample_nearest_exact1d_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, output_size, scales, out); + } +} + +// aten::_upsample_nearest_exact1d.out(Tensor self, SymInt[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _upsample_nearest_exact1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales, at::Tensor & out) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, output_size, scales, out); +} +namespace symint { + template ::value>> + at::Tensor & _upsample_nearest_exact1d_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales, at::Tensor & out) { + return at::_ops::_upsample_nearest_exact1d_out::call(self, output_size, scales, out); + } +} + +// aten::_upsample_nearest_exact1d(Tensor self, SymInt[1] output_size, float? scales=None) -> Tensor +inline at::Tensor _upsample_nearest_exact1d(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d::call(self, c10::fromIntArrayRefSlow(output_size), scales); +} +namespace symint { + template ::value>> + at::Tensor _upsample_nearest_exact1d(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d::call(self, c10::fromIntArrayRefSlow(output_size), scales); + } +} + +// aten::_upsample_nearest_exact1d(Tensor self, SymInt[1] output_size, float? scales=None) -> Tensor +inline at::Tensor _upsample_nearest_exact1d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d::call(self, output_size, scales); +} +namespace symint { + template ::value>> + at::Tensor _upsample_nearest_exact1d(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales=c10::nullopt) { + return at::_ops::_upsample_nearest_exact1d::call(self, output_size, scales); + } +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool2d_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool2d_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..f38ef3f53c5cdf8ee361c43897e2ca5aa78c9c6a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool2d_meta_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 meta { + +TORCH_API ::std::tuple adaptive_max_pool2d(const at::Tensor & self, at::IntArrayRef output_size); +TORCH_API ::std::tuple adaptive_max_pool2d_out(at::Tensor & out, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef output_size); +TORCH_API ::std::tuple adaptive_max_pool2d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out, at::Tensor & indices); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool3d_backward_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool3d_backward_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..b8a54daf60841981383e559fdfbd50d8c49ef71a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool3d_backward_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 +#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 adaptive_max_pool3d_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices); +TORCH_API at::Tensor & adaptive_max_pool3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices); +TORCH_API at::Tensor & adaptive_max_pool3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/as_strided_scatter_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/as_strided_scatter_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..30666480885b9a85b4c495333ba834a32ccee5d2 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/as_strided_scatter_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 as_strided_scatter { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::as_strided_scatter") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "as_strided_scatter(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional storage_offset); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional storage_offset); +}; + +struct TORCH_API as_strided_scatter_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::as_strided_scatter") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "as_strided_scatter.out(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional storage_offset, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional storage_offset, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/conj_physical_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/conj_physical_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..041deb488a75360ff9bca1d6510058425244cd16 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/conj_physical_compositeexplicitautograd_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 compositeexplicitautograd { + +TORCH_API at::Tensor & conj_physical_(at::Tensor & self); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/convolution_backward_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/convolution_backward_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d695d0baa938070c7cc4880343a998a152c32a24 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/convolution_backward_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 +#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 convolution_backward(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalIntArrayRef bias_sizes, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array output_mask); +TORCH_API ::std::tuple convolution_backward_symint(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalSymIntArrayRef bias_sizes, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array output_mask); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_batch_norm_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_batch_norm_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..0919d8fc8d7929b3a3b30986f8c133eb67cf541d --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_batch_norm_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 ::std::tuple cudnn_batch_norm_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon); +TORCH_API ::std::tuple cudnn_batch_norm_outf(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/diag_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/diag_native.h new file mode 100644 index 0000000000000000000000000000000000000000..1669e4f227662d8e0b751211d2968ce125df75bb --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/diag_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 diag(const at::Tensor & self, int64_t diagonal=0); +TORCH_API at::Tensor & diag_out(const at::Tensor & self, int64_t diagonal, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_dense_backward_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_dense_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..4a5b482c1e32b02753b284b83855a5f84e4297e2 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_dense_backward_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 embedding_dense_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, c10::SymInt, c10::SymInt, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::embedding_dense_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "embedding_dense_backward(Tensor grad_output, Tensor indices, SymInt num_weights, SymInt padding_idx, bool scale_grad_by_freq) -> Tensor") + static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq); +}; + +struct TORCH_API embedding_dense_backward_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, c10::SymInt, c10::SymInt, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::embedding_dense_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "embedding_dense_backward.out(Tensor grad_output, Tensor indices, SymInt num_weights, SymInt padding_idx, bool scale_grad_by_freq, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/eye_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/eye_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d720fde72796a593add5ddcfeda51ce8dcb532f8 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/eye_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 & eye_out(at::Tensor & out, int64_t n); +TORCH_API at::Tensor & eye_outf(int64_t n, at::Tensor & out); +TORCH_API at::Tensor & eye_symint_out(at::Tensor & out, c10::SymInt n); +TORCH_API at::Tensor & eye_symint_outf(c10::SymInt n, at::Tensor & out); +TORCH_API at::Tensor & eye_out(at::Tensor & out, int64_t n, int64_t m); +TORCH_API at::Tensor & eye_outf(int64_t n, int64_t m, at::Tensor & out); +TORCH_API at::Tensor & eye_symint_out(at::Tensor & out, c10::SymInt n, c10::SymInt m); +TORCH_API at::Tensor & eye_symint_outf(c10::SymInt n, c10::SymInt m, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..933b0f3b741b2d6ed9f3159b2b2ab2ff64921a6b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_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 fake_quantize_per_tensor_affine_cachemask_backward(const at::Tensor & grad, const at::Tensor & mask); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ifft2_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ifft2_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..a449611d88a4c7a4ffd6ee3f6a305042c3ed768d --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ifft2_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor fft_ifft2(const at::Tensor & self, at::OptionalIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API at::Tensor fft_ifft2_symint(const at::Tensor & self, at::OptionalSymIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API at::Tensor & fft_ifft2_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API at::Tensor & fft_ifft2_outf(const at::Tensor & self, at::OptionalIntArrayRef s, at::IntArrayRef dim, c10::optional norm, at::Tensor & out); +TORCH_API at::Tensor & fft_ifft2_symint_out(at::Tensor & out, const at::Tensor & self, at::OptionalSymIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API at::Tensor & fft_ifft2_symint_outf(const at::Tensor & self, at::OptionalSymIntArrayRef s, at::IntArrayRef dim, c10::optional norm, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/i0_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/i0_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..9b3666463c2b8eb1353408e8564576b924e80204 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/i0_ops.h @@ -0,0 +1,50 @@ +#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 i0 { + 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::i0") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "i0(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API i0_ { + using schema = 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::i0_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "i0_(Tensor(a!) self) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self); +}; + +struct TORCH_API i0_out { + using schema = 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::i0") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "i0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isfinite_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isfinite_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..b84a8eacdea28f4ebb03b86fc87489cc6a04fa20 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isfinite_ops.h @@ -0,0 +1,28 @@ +#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 isfinite { + 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::isfinite") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isfinite(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logical_and_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logical_and_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..cbba19f9530a4d070f824315fa02bfafc8ba1123 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logical_and_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 at::Tensor & logical_and_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & logical_and_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logical_xor_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logical_xor_native.h new file mode 100644 index 0000000000000000000000000000000000000000..6f29c969c6691dac334b74e332fd6b509f1210fb --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/logical_xor_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 logical_xor(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & logical_xor_(at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & logical_xor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lu_unpack_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lu_unpack_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..87e98c03f6048f6e24c9378434ad3c4243273d37 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lu_unpack_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 lu_unpack { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::lu_unpack") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "lu_unpack(Tensor LU_data, Tensor LU_pivots, bool unpack_data=True, bool unpack_pivots=True) -> (Tensor P, Tensor L, Tensor U)") + static ::std::tuple call(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots); +}; + +struct TORCH_API lu_unpack_out { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &, 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::lu_unpack") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "lu_unpack.out(Tensor LU_data, Tensor LU_pivots, bool unpack_data=True, bool unpack_pivots=True, *, Tensor(a!) P, Tensor(b!) L, Tensor(c!) U) -> (Tensor(a!) P, Tensor(b!) L, Tensor(c!) U)") + static ::std::tuple call(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots, at::Tensor & P, at::Tensor & L, at::Tensor & U); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots, at::Tensor & P, at::Tensor & L, at::Tensor & U); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/margin_ranking_loss.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/margin_ranking_loss.h new file mode 100644 index 0000000000000000000000000000000000000000..6044a265ac3f9ea1097ba8e614714a19033fda7b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/margin_ranking_loss.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::margin_ranking_loss(Tensor input1, Tensor input2, Tensor target, float margin=0.0, int reduction=Mean) -> Tensor +inline at::Tensor margin_ranking_loss(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & target, double margin=0.0, int64_t reduction=at::Reduction::Mean) { + return at::_ops::margin_ranking_loss::call(input1, input2, target, margin, reduction); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_rnn_layer_backward_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_rnn_layer_backward_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d1dbd18bb708c09ec070b4b558418d1090f7a27b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_rnn_layer_backward_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 ::std::tuple mkldnn_rnn_layer_backward(const at::Tensor & input, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & weight4, const at::Tensor & hx_, const at::Tensor & cx_tmp, const at::Tensor & output, const at::Tensor & hy_, const at::Tensor & cy_, const c10::optional & grad_output, const c10::optional & grad_hy, const c10::optional & grad_cy, bool reverse, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool train, bool bidirectional, at::IntArrayRef batch_sizes, bool batch_first, const at::Tensor & workspace); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_group_norm_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_group_norm_native.h new file mode 100644 index 0000000000000000000000000000000000000000..d5a61bcd4c1ee9cf41df15dc141c96f2127450a3 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_group_norm_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 ::std::tuple math_group_norm(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps); +TORCH_API ::std::tuple native_group_norm_out_symint(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); +TORCH_API ::std::tuple native_group_norm(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pin_memory_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pin_memory_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..52f01fc1658ad8a690abcfc237a1f706c8614f2c --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pin_memory_ops.h @@ -0,0 +1,28 @@ +#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 pin_memory { + using schema = at::Tensor (const at::Tensor &, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::pin_memory") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "pin_memory(Tensor(a) self, Device? device=None) -> Tensor(a)") + static at::Tensor call(const at::Tensor & self, c10::optional device); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional device); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/q_per_channel_zero_points_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/q_per_channel_zero_points_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..02e538c13e5a0bb044320787665a1f180159c13b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/q_per_channel_zero_points_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 q_per_channel_zero_points { + 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::q_per_channel_zero_points") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "q_per_channel_zero_points(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API q_per_channel_zero_points_out { + using schema = 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::q_per_channel_zero_points") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "q_per_channel_zero_points.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/quantize_per_channel_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/quantize_per_channel_native.h new file mode 100644 index 0000000000000000000000000000000000000000..6dced6271caf885396711390b8b058c505ecc5e5 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/quantize_per_channel_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 & quantize_per_channel_out(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype, at::Tensor & out); +TORCH_API at::Tensor quantize_per_channel(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rad2deg.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rad2deg.h new file mode 100644 index 0000000000000000000000000000000000000000..eb4b0b6c1f04fdb952797123ae6ed19f5090677c --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rad2deg.h @@ -0,0 +1,44 @@ +#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::rad2deg(Tensor self) -> Tensor +inline at::Tensor rad2deg(const at::Tensor & self) { + return at::_ops::rad2deg::call(self); +} + +// aten::rad2deg_(Tensor(a!) self) -> Tensor(a!) +inline at::Tensor & rad2deg_(at::Tensor & self) { + return at::_ops::rad2deg_::call(self); +} + +// aten::rad2deg.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & rad2deg_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::rad2deg_out::call(self, out); +} +// aten::rad2deg.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & rad2deg_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::rad2deg_out::call(self, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/repeat_interleave_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/repeat_interleave_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..938c5c97105c9c396c63202c6aeb3c09c2834a01 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/repeat_interleave_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 +#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 repeat_interleave(const at::Tensor & repeats, c10::optional output_size=c10::nullopt); +TORCH_API at::Tensor repeat_interleave_symint(const at::Tensor & repeats, c10::optional output_size=c10::nullopt); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reshape_as.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reshape_as.h new file mode 100644 index 0000000000000000000000000000000000000000..f91d4233ef60aef89b5985106adaed66120d6267 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reshape_as.h @@ -0,0 +1,26 @@ +#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 { + + + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rot90_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rot90_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..9ff69923da2df097c22b89311e8e61e7e8f26ae0 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rot90_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 rot90 { + using schema = at::Tensor (const at::Tensor &, int64_t, at::IntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rot90") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rot90(Tensor self, int k=1, int[] dims=[0,1]) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t k, at::IntArrayRef dims); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t k, at::IntArrayRef dims); +}; + +struct TORCH_API rot90_out { + using schema = at::Tensor & (const at::Tensor &, int64_t, at::IntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rot90") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rot90.out(Tensor self, int k=1, int[] dims=[0,1], *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, int64_t k, at::IntArrayRef dims, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t k, at::IntArrayRef dims, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rrelu_with_noise_backward_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rrelu_with_noise_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..85e7d49f2645149f38b6ebe18b1db6c1da1d16ee --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rrelu_with_noise_backward_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 rrelu_with_noise_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rrelu_with_noise_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rrelu_with_noise_backward(Tensor grad_output, Tensor self, Tensor noise, Scalar lower, Scalar upper, bool training, bool self_is_result) -> Tensor") + static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result); +}; + +struct TORCH_API rrelu_with_noise_backward_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rrelu_with_noise_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rrelu_with_noise_backward.out(Tensor grad_output, Tensor self, Tensor noise, Scalar lower, Scalar upper, bool training, bool self_is_result, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/set_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/set_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..f58ebc53bc74b0ce6739cf925d4c4ffe578d32dd --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/set_meta_dispatch.h @@ -0,0 +1,27 @@ +#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 & set_(at::Tensor & self, at::Storage source); +TORCH_API at::Tensor & set_(at::Tensor & self, at::Storage source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride={}); +TORCH_API at::Tensor & set__symint(at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride={}); +TORCH_API at::Tensor & set_(at::Tensor & self, const at::Tensor & source); +TORCH_API at::Tensor & set_(at::Tensor & self); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv3d_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv3d_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..2c5865bee332ec9332e96e27e54445a4381b8551 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv3d_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor slow_conv3d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0); +TORCH_API at::Tensor slow_conv3d_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0)); +TORCH_API at::Tensor & slow_conv3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0); +TORCH_API at::Tensor & slow_conv3d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::Tensor & out); +TORCH_API at::Tensor & slow_conv3d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0)); +TORCH_API at::Tensor & slow_conv3d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_dilated3d_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_dilated3d_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..77d72373651e551df5654b3440119ad2ba181f5a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_dilated3d_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 at::Tensor slow_conv_dilated3d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef dilation=1); +TORCH_API at::Tensor slow_conv_dilated3d_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/softplus_backward_meta.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/softplus_backward_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..7436f1a636f3ae9fb7cb7979b1bf278b38260d6b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/softplus_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_softplus_backward : public TensorIteratorBase { + + + void meta(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold); +}; + +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_sinc.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_sinc.h new file mode 100644 index 0000000000000000000000000000000000000000..af67db6f40f955540f3b867d16d47a35e245c6ef --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_sinc.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::special_sinc(Tensor self) -> Tensor +inline at::Tensor special_sinc(const at::Tensor & self) { + return at::_ops::special_sinc::call(self); +} + +// aten::special_sinc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_sinc_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::special_sinc_out::call(self, out); +} +// aten::special_sinc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_sinc_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::special_sinc_out::call(self, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_xlog1py_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_xlog1py_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..496e84b27a3095bbe1431706adb08800465eaa30 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_xlog1py_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 special_xlog1py(const at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/tanh_backward_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/tanh_backward_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e278ce95589d108c109e31000961a2fd57ceeeb1 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/tanh_backward_meta_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 meta { + +TORCH_API at::Tensor tanh_backward(const at::Tensor & grad_output, const at::Tensor & output); +TORCH_API at::Tensor & tanh_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & output); +TORCH_API at::Tensor & tanh_backward_outf(const at::Tensor & grad_output, const at::Tensor & output, at::Tensor & grad_input); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/topk_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/topk_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3b4c4f5d5e18220c58c72d8c5b8947d0a9022c8d --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/topk_cuda_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 cuda { + +TORCH_API ::std::tuple topk(const at::Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true); +TORCH_API ::std::tuple topk_symint(const at::Tensor & self, c10::SymInt k, int64_t dim=-1, bool largest=true, bool sorted=true); +TORCH_API ::std::tuple topk_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true); +TORCH_API ::std::tuple topk_outf(const at::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted, at::Tensor & values, at::Tensor & indices); +TORCH_API ::std::tuple topk_symint_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, c10::SymInt k, int64_t dim=-1, bool largest=true, bool sorted=true); +TORCH_API ::std::tuple topk_symint_outf(const at::Tensor & self, c10::SymInt k, int64_t dim, bool largest, bool sorted, at::Tensor & values, at::Tensor & indices); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/xor_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/xor_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6aab74f0bb16a4ff25ff5e8b09ea910c660d47d9 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/xor_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor __xor__(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & __ixor__(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor __xor__(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & __ixor__(at::Tensor & self, const at::Tensor & other); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/zeros_like_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/zeros_like_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..88d9f6888c2eeb77adbe289f7e5dd9f63c5eca4f --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/zeros_like_compositeexplicitautograd_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 compositeexplicitautograd { + +TORCH_API at::Tensor zeros_like(const at::Tensor & self, at::TensorOptions options={}, c10::optional memory_format=c10::nullopt); +TORCH_API at::Tensor zeros_like(const at::Tensor & self, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory, c10::optional memory_format); +TORCH_API at::Tensor & zeros_like_out(at::Tensor & out, const at::Tensor & self, c10::optional memory_format=c10::nullopt); +TORCH_API at::Tensor & zeros_like_outf(const at::Tensor & self, c10::optional memory_format, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/LICENSE b/vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..104eebf5a3002fccdaceef3a4cb936173c1c2035 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2018 Alex Grönholm + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vllm/lib/python3.10/site-packages/opencensus/tags/tag.py b/vllm/lib/python3.10/site-packages/opencensus/tags/tag.py new file mode 100644 index 0000000000000000000000000000000000000000..717b0afdeff33d82febbf387b7a84a9c169d7834 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/opencensus/tags/tag.py @@ -0,0 +1,38 @@ +# Copyright 2018, OpenCensus Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from collections import namedtuple + +from opencensus.tags.tag_key import TagKey +from opencensus.tags.tag_value import TagValue + +Tag_ = namedtuple('Tag', ['key', 'value']) + + +class Tag(Tag_): + """A tag, in the format [KEY]:[VALUE]. + + :type key: str + :param key: The name of the tag + + :type value: str + :param value: The value of the tag + + """ + def __new__(cls, key, value): + return super(Tag, cls).__new__( + cls, + key=TagKey(key), + value=TagValue(value), + ) diff --git a/vllm/lib/python3.10/site-packages/opencensus/tags/tag_key.py b/vllm/lib/python3.10/site-packages/opencensus/tags/tag_key.py new file mode 100644 index 0000000000000000000000000000000000000000..7399d2da01eaec8099e629bda24e1f6d1503fe50 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/opencensus/tags/tag_key.py @@ -0,0 +1,35 @@ +# Copyright 2018, OpenCensus Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from opencensus.tags.validation import is_valid_tag_name + +_TAG_NAME_ERROR = \ + 'tag name must not be empty,' \ + 'no longer than 255 characters and of ascii values between 32 - 126' + + +class TagKey(str): + """A tag key with a property name""" + + def __new__(cls, name): + """Create and return a new tag key + + :type name: str + :param name: The name of the key + :return: TagKey + """ + if not isinstance(name, cls): + if not is_valid_tag_name(name): + raise ValueError(_TAG_NAME_ERROR) + return super(TagKey, cls).__new__(cls, name) diff --git a/vllm/lib/python3.10/site-packages/opencensus/tags/tag_map.py b/vllm/lib/python3.10/site-packages/opencensus/tags/tag_map.py new file mode 100644 index 0000000000000000000000000000000000000000..9a818e6338b4e09875099cd2ddbdb23117cc1020 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/opencensus/tags/tag_map.py @@ -0,0 +1,104 @@ +# Copyright 2018, OpenCensus Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from collections import OrderedDict + +from opencensus.tags.tag_key import TagKey +from opencensus.tags.tag_value import TagValue + + +class TagMap(object): + """ A tag map is a map of tags from key to value + + :type tags: list(:class: '~opencensus.tags.tag.Tag') + :param tags: a list of tags + + """ + + def __init__(self, tags=None): + self.map = OrderedDict(tags if tags else []) + + def __iter__(self): + return self.map.items().__iter__() + + def insert(self, key, value): + """Inserts a key and value in the map if the map does not already + contain the key. + + :type key: :class: '~opencensus.tags.tag_key.TagKey' + :param key: a tag key to insert into the map + + :type value: :class: '~opencensus.tags.tag_value.TagValue' + :param value: a tag value that is associated with the tag key and + the value to insert into the tag map + + """ + if key in self.map: + return + + try: + tag_key = TagKey(key) + tag_val = TagValue(value) + self.map[tag_key] = tag_val + except ValueError: + raise + + def delete(self, key): + """Deletes a tag from the map if the key is in the map + + :type key: :class: '~opencensus.tags.tag_key.TagKey' + :param key: A string representing a possible tag key + + :returns: the value of the key in the dictionary if it is in there, + or None if it is not. + """ + self.map.pop(key, None) + + def update(self, key, value): + """Updates the map by updating the value of a key + + :type key: :class: '~opencensus.tags.tag_key.TagKey' + :param key: A tag key to be updated + + :type value: :class: '~opencensus.tags.tag_value.TagValue' + :param value: The value to update the key to in the map + + """ + if key in self.map: + self.map[key] = value + + def tag_key_exists(self, key): + """Checking if the tag key exists in the map + + :type key: '~opencensus.tags.tag_key.TagKey' + :param key: A string to check to see if that is a key in the map + + :returns: True if the key is in map, False is it is not + + """ + return key in self.map + + def get_value(self, key): + """ Gets the value of the key passed in if the key exists in the map + + :type key: str + :param key: A string representing a key to get the value of in the map + + :returns: A KeyError if the value is None, else returns the value + + """ + try: + return self.map[key] + except KeyError: + raise KeyError('key is not in map') diff --git a/vllm/lib/python3.10/site-packages/opencensus/tags/tag_value.py b/vllm/lib/python3.10/site-packages/opencensus/tags/tag_value.py new file mode 100644 index 0000000000000000000000000000000000000000..d22b07e0ba7e70ef1c2d6b51d6f723a01451356b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/opencensus/tags/tag_value.py @@ -0,0 +1,35 @@ +# Copyright 2018, OpenCensus Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from opencensus.tags.validation import is_valid_tag_value + +_TAG_VALUE_ERROR = \ + 'tag value must not be longer than 255 characters ' \ + 'and of ascii values between 32 - 126' + + +class TagValue(str): + """The value of a tag""" + + def __new__(cls, value): + """Create and return a new tag value + + :type value: str + :param value: A string representing the value of a key in a tag + :return: TagValue + """ + if not isinstance(value, cls): + if not is_valid_tag_value(value): + raise ValueError(_TAG_VALUE_ERROR) + return super(TagValue, cls).__new__(cls, value) diff --git a/vllm/lib/python3.10/site-packages/opencensus/tags/validation.py b/vllm/lib/python3.10/site-packages/opencensus/tags/validation.py new file mode 100644 index 0000000000000000000000000000000000000000..8d51ac86caba797b3a0b03af3044cba619e9907a --- /dev/null +++ b/vllm/lib/python3.10/site-packages/opencensus/tags/validation.py @@ -0,0 +1,42 @@ +# Copyright 2018, OpenCensus Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +def is_legal_chars(value): + return all(32 <= ord(char) <= 126 for char in value) + + +def is_valid_tag_name(name): + """Checks if the name of a tag key is valid + + :type name: str + :param name: name to check + + :rtype: bool + :returns: True if it valid, else returns False + """ + return is_legal_chars(name) if 0 < len(name) <= 255 else False + + +def is_valid_tag_value(value): + """Checks if the value is valid + + :type value: str + :param value: the value to be checked + + :rtype: bool + :returns: True if valid, if not, False. + + """ + return is_legal_chars(value) if len(value) <= 255 else False diff --git a/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/INSTALLER b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/LICENSE b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..3a4399759e40dba1d833698e2d585f2e81f0c695 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Will McGugan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/METADATA b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..3b7b1b59077cee323c689d88b5898d9b2b857a09 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/METADATA @@ -0,0 +1,263 @@ +Metadata-Version: 2.1 +Name: textual +Version: 1.0.0 +Summary: Modern Text User Interface framework +Home-page: https://github.com/Textualize/textual +License: MIT +Author: Will McGugan +Author-email: will@textualize.io +Requires-Python: >=3.8.1,<4.0.0 +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: MacOS +Classifier: Operating System :: Microsoft :: Windows :: Windows 10 +Classifier: Operating System :: Microsoft :: Windows :: Windows 11 +Classifier: Operating System :: POSIX :: Linux +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Typing :: Typed +Provides-Extra: syntax +Requires-Dist: markdown-it-py[linkify,plugins] (>=2.1.0) +Requires-Dist: platformdirs (>=3.6.0,<5) +Requires-Dist: rich (>=13.3.3) +Requires-Dist: tree-sitter (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-bash (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-css (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-go (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-html (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-java (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-javascript (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-json (>=0.24.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-markdown (>=0.3.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-python (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-regex (>=0.24.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-rust (>=0.23.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-sql (>=0.3.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-toml (>=0.6.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-xml (>=0.7.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: tree-sitter-yaml (>=0.6.0) ; (python_version >= "3.9") and (extra == "syntax") +Requires-Dist: typing-extensions (>=4.4.0,<5.0.0) +Project-URL: Bug Tracker, https://github.com/Textualize/textual/issues +Project-URL: Documentation, https://textual.textualize.io/ +Project-URL: Repository, https://github.com/Textualize/textual +Description-Content-Type: text/markdown + + + +[![Discord](https://img.shields.io/discord/1026214085173461072)](https://discord.gg/Enf6Z3qhVr) +[![Supported Python Versions](https://img.shields.io/pypi/pyversions/textual/0.87.1)](https://pypi.org/project/textual/) +[![PyPI version](https://badge.fury.io/py/textual.svg)](https://badge.fury.io/py/textual) +![OS support](https://img.shields.io/badge/OS-macOS%20Linux%20Windows-red) + + + +![textual-splash](https://github.com/user-attachments/assets/4caeb77e-48c0-4cf7-b14d-c53ded855ffd) + +# Textual + +clock + +Build cross-platform user interfaces with a simple Python API. Run your apps in the terminal *or* a web browser. + +Textual's API combines modern Python with the best of developments from the web world, for a lean app development experience. +De-coupled components and an advanced [testing](https://textual.textualize.io/guide/testing/) framework ensure you can maintain your app for the long-term. + +Want some more examples? See the [examples](https://github.com/Textualize/textual/tree/main/examples) directory. + +```python +""" +An App to show the current time. +""" + +from datetime import datetime + +from textual.app import App, ComposeResult +from textual.widgets import Digits + + +class ClockApp(App): + CSS = """ + Screen { align: center middle; } + Digits { width: auto; } + """ + + def compose(self) -> ComposeResult: + yield Digits("") + + def on_ready(self) -> None: + self.update_clock() + self.set_interval(1, self.update_clock) + + def update_clock(self) -> None: + clock = datetime.now().time() + self.query_one(Digits).update(f"{clock:%T}") + + +if __name__ == "__main__": + app = ClockApp() + app.run() +``` + +> [!TIP] +> Textual is an asynchronous framework under the hood. Which means you can integrate your apps with async libraries — if you want to. +> If you don't want or need to use async, Textual won't force it on you. + + + + + +## Widgets + +Textual's library of [widgets](https://textual.textualize.io/widget_gallery/) covers everything from buttons, tree controls, data tables, inputs, text areas, and more… +Combined with a flexible [layout](https://textual.textualize.io/how-to/design-a-layout/) system, you can realize any User Interface you need. + +Predefined themes ensure your apps will look good out of the box. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + ![buttons](https://github.com/user-attachments/assets/2ac26387-aaa3-41ed-bc00-7d488600343c) + + + +![tree](https://github.com/user-attachments/assets/61ccd6e9-97ea-4918-8eda-3ee0f0d3770e) + +
+ + ![datatables](https://github.com/user-attachments/assets/3e1f9f7a-f965-4901-a114-3c188bd17695) + + + +![inputs](https://github.com/user-attachments/assets/b02aa203-7c37-42da-a1bb-2cb244b7d0d3) + +
+ +![listview](https://github.com/user-attachments/assets/963603bc-aa07-4688-bd24-379962ece871) + + + +![textarea](https://github.com/user-attachments/assets/cd4ba787-5519-40e2-8d86-8224e1b7e506) + +
+ + + + +## Installing + +Install Textual via pip: + +``` +pip install textual textual-dev +``` + +See [getting started](https://textual.textualize.io/getting_started/) for details. + + + + +## Demo + + +Run the following command to see a little of what Textual can do: + +``` +python -m textual +``` + +Or try the [textual demo](https://github.com/textualize/textual-demo) *without* installing (requires [uv](https://docs.astral.sh/uv/)): + +```bash +uvx --python 3.12 textual-demo +``` + + + +## Dev Console + +devtools + + +How do you debug an app in the terminal that is also running in the terminal? + +The `textual-dev` package supplies a dev console that connects to your application from another terminal. +In addition to system messages and events, your logged messages and print statements will appear in the dev console. + +See [the guide](https://textual.textualize.io/guide/devtools/) for other helpful tools provided by the `textual-dev` package. + + + +## Command Palette + + +Textual apps have a *fuzzy search* command palette. +Hit `ctrl+p` to open the command palette. + +It is easy to extend the command palette with [custom commands](https://textual.textualize.io/guide/command_palette/) for your application. + + +![Command Palette](https://github.com/user-attachments/assets/94d8ec5d-b668-4033-a5cb-bf820e1b8d60) + + + +# Textual ❤️ Web + +textual-serve + + +Textual apps are equally at home in the browser as they are the terminal. Any Textual app may be served with `textual serve` — so you can share your creations on the web. +Here's how to serve the demo app: + +``` +textual serve "python -m textual" +``` + +In addition to serving your apps locally, you can serve apps with [Textual Web](https://github.com/Textualize/textual-web). + +Textual Web's firewall-busting technology can serve an unlimited number of applications. + +Since Textual apps have low system requirements, you can install them anywhere Python also runs. Turning any device in to a connected device. +No desktop required! + + + + + +## Join us on Discord + +Join the Textual developers and community on our [Discord Server](https://discord.gg/Enf6Z3qhVr). + diff --git a/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/RECORD b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..1e00957370877f7aa6bb215ecb97557e656c7f08 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/RECORD @@ -0,0 +1,487 @@ +textual-1.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +textual-1.0.0.dist-info/LICENSE,sha256=lPKQp2I3bf23do5CBwYYsKv9KieZ6rGxwJeBbDo561c,1069 +textual-1.0.0.dist-info/METADATA,sha256=EGXRb0WOHNujq-kbCUykf3OWE_vVJY09ebzj_CGWLAw,8971 +textual-1.0.0.dist-info/RECORD,, +textual-1.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +textual-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88 +textual/__init__.py,sha256=1jh_SBS5LDh4h481CKsNB6lnVdOkwehLqCETO3IE3jw,4782 +textual/__main__.py,sha256=im4DgMc-NCHyZsg9zQ_eHL_cQD30vnpv8_faistjl-U,104 +textual/__pycache__/__init__.cpython-310.pyc,, +textual/__pycache__/__main__.cpython-310.pyc,, +textual/__pycache__/_animator.cpython-310.pyc,, +textual/__pycache__/_ansi_sequences.cpython-310.pyc,, +textual/__pycache__/_ansi_theme.cpython-310.pyc,, +textual/__pycache__/_arrange.cpython-310.pyc,, +textual/__pycache__/_binary_encode.cpython-310.pyc,, +textual/__pycache__/_border.cpython-310.pyc,, +textual/__pycache__/_box_drawing.cpython-310.pyc,, +textual/__pycache__/_callback.cpython-310.pyc,, +textual/__pycache__/_cells.cpython-310.pyc,, +textual/__pycache__/_color_constants.cpython-310.pyc,, +textual/__pycache__/_compose.cpython-310.pyc,, +textual/__pycache__/_compositor.cpython-310.pyc,, +textual/__pycache__/_context.cpython-310.pyc,, +textual/__pycache__/_debug.cpython-310.pyc,, +textual/__pycache__/_dispatch_key.cpython-310.pyc,, +textual/__pycache__/_doc.cpython-310.pyc,, +textual/__pycache__/_duration.cpython-310.pyc,, +textual/__pycache__/_easing.cpython-310.pyc,, +textual/__pycache__/_event_broker.cpython-310.pyc,, +textual/__pycache__/_files.cpython-310.pyc,, +textual/__pycache__/_immutable_sequence_view.cpython-310.pyc,, +textual/__pycache__/_import_app.cpython-310.pyc,, +textual/__pycache__/_keyboard_protocol.cpython-310.pyc,, +textual/__pycache__/_layout_resolve.cpython-310.pyc,, +textual/__pycache__/_line_split.cpython-310.pyc,, +textual/__pycache__/_log.cpython-310.pyc,, +textual/__pycache__/_loop.cpython-310.pyc,, +textual/__pycache__/_node_list.cpython-310.pyc,, +textual/__pycache__/_on.cpython-310.pyc,, +textual/__pycache__/_opacity.cpython-310.pyc,, +textual/__pycache__/_parser.cpython-310.pyc,, +textual/__pycache__/_partition.cpython-310.pyc,, +textual/__pycache__/_path.cpython-310.pyc,, +textual/__pycache__/_profile.cpython-310.pyc,, +textual/__pycache__/_resolve.cpython-310.pyc,, +textual/__pycache__/_segment_tools.cpython-310.pyc,, +textual/__pycache__/_sleep.cpython-310.pyc,, +textual/__pycache__/_slug.cpython-310.pyc,, +textual/__pycache__/_spatial_map.cpython-310.pyc,, +textual/__pycache__/_styles_cache.cpython-310.pyc,, +textual/__pycache__/_text_area_theme.cpython-310.pyc,, +textual/__pycache__/_time.cpython-310.pyc,, +textual/__pycache__/_tree_sitter.cpython-310.pyc,, +textual/__pycache__/_two_way_dict.cpython-310.pyc,, +textual/__pycache__/_types.cpython-310.pyc,, +textual/__pycache__/_wait.cpython-310.pyc,, +textual/__pycache__/_widget_navigation.cpython-310.pyc,, +textual/__pycache__/_win_sleep.cpython-310.pyc,, +textual/__pycache__/_work_decorator.cpython-310.pyc,, +textual/__pycache__/_wrap.cpython-310.pyc,, +textual/__pycache__/_xterm_parser.cpython-310.pyc,, +textual/__pycache__/actions.cpython-310.pyc,, +textual/__pycache__/app.cpython-310.pyc,, +textual/__pycache__/await_complete.cpython-310.pyc,, +textual/__pycache__/await_remove.cpython-310.pyc,, +textual/__pycache__/binding.cpython-310.pyc,, +textual/__pycache__/box_model.cpython-310.pyc,, +textual/__pycache__/cache.cpython-310.pyc,, +textual/__pycache__/canvas.cpython-310.pyc,, +textual/__pycache__/case.cpython-310.pyc,, +textual/__pycache__/clock.cpython-310.pyc,, +textual/__pycache__/color.cpython-310.pyc,, +textual/__pycache__/command.cpython-310.pyc,, +textual/__pycache__/constants.cpython-310.pyc,, +textual/__pycache__/containers.cpython-310.pyc,, +textual/__pycache__/content.cpython-310.pyc,, +textual/__pycache__/coordinate.cpython-310.pyc,, +textual/__pycache__/design.cpython-310.pyc,, +textual/__pycache__/dom.cpython-310.pyc,, +textual/__pycache__/driver.cpython-310.pyc,, +textual/__pycache__/errors.cpython-310.pyc,, +textual/__pycache__/eta.cpython-310.pyc,, +textual/__pycache__/events.cpython-310.pyc,, +textual/__pycache__/expand_tabs.cpython-310.pyc,, +textual/__pycache__/features.cpython-310.pyc,, +textual/__pycache__/file_monitor.cpython-310.pyc,, +textual/__pycache__/filter.cpython-310.pyc,, +textual/__pycache__/fuzzy.cpython-310.pyc,, +textual/__pycache__/geometry.cpython-310.pyc,, +textual/__pycache__/keys.cpython-310.pyc,, +textual/__pycache__/layout.cpython-310.pyc,, +textual/__pycache__/lazy.cpython-310.pyc,, +textual/__pycache__/logging.cpython-310.pyc,, +textual/__pycache__/map_geometry.cpython-310.pyc,, +textual/__pycache__/message.cpython-310.pyc,, +textual/__pycache__/message_pump.cpython-310.pyc,, +textual/__pycache__/messages.cpython-310.pyc,, +textual/__pycache__/notifications.cpython-310.pyc,, +textual/__pycache__/pad.cpython-310.pyc,, +textual/__pycache__/pilot.cpython-310.pyc,, +textual/__pycache__/reactive.cpython-310.pyc,, +textual/__pycache__/render.cpython-310.pyc,, +textual/__pycache__/rlock.cpython-310.pyc,, +textual/__pycache__/screen.cpython-310.pyc,, +textual/__pycache__/scroll_view.cpython-310.pyc,, +textual/__pycache__/scrollbar.cpython-310.pyc,, +textual/__pycache__/signal.cpython-310.pyc,, +textual/__pycache__/strip.cpython-310.pyc,, +textual/__pycache__/suggester.cpython-310.pyc,, +textual/__pycache__/suggestions.cpython-310.pyc,, +textual/__pycache__/system_commands.cpython-310.pyc,, +textual/__pycache__/theme.cpython-310.pyc,, +textual/__pycache__/timer.cpython-310.pyc,, +textual/__pycache__/types.cpython-310.pyc,, +textual/__pycache__/validation.cpython-310.pyc,, +textual/__pycache__/visual.cpython-310.pyc,, +textual/__pycache__/walk.cpython-310.pyc,, +textual/__pycache__/widget.cpython-310.pyc,, +textual/__pycache__/worker.cpython-310.pyc,, +textual/__pycache__/worker_manager.cpython-310.pyc,, +textual/_animator.py,sha256=CHg3pfbueGyJCZKeOWS_2TB_dWcnbdQHaru28COVZSM,20465 +textual/_ansi_sequences.py,sha256=kWFZ-oj-yGYXMdZECNE7rVgccArtXzzc7Qeem8MI55k,18013 +textual/_ansi_theme.py,sha256=MpgDzVTxQof5ZkOVZ5rlBSzOP3ZYo3-0uK6HEvO0WGE,1013 +textual/_arrange.py,sha256=Kmjjc21A1xN2nhRphi-tWNL7rCURdMoD7XCLzi31Q0U,8633 +textual/_binary_encode.py,sha256=55ShbwGjF0uhhn3BLNEu7YTwM26ngYXueEHQ1RWyju0,7654 +textual/_border.py,sha256=ORut0pHkFlGA3YkzhQCjr2meeEKFaq4K3SbCs-Oakr4,12835 +textual/_box_drawing.py,sha256=Bu2sJZXeRb4zeGYraxhQcRtDGBedu4TGPdPqUHefh1A,8159 +textual/_callback.py,sha256=nDZXtWBL4Jx9HJtvjuT7icUFMuAnJXj6BjbrPynQ4LE,2705 +textual/_cells.py,sha256=zoL0YG-ZC6OMJ1J2JGxreIlU2n71fgGEsQH4YTjX4I0,1416 +textual/_color_constants.py,sha256=Q9ZQwtoZKkRq23cwWL95rjtg7fHUNC3rwImqeZLgcwY,6099 +textual/_compose.py,sha256=P1d8fK_H5JA9eLECBpfQei5zSEA4YhQKI_ZtDuht9Z4,2411 +textual/_compositor.py,sha256=zJiYQxp538n1l39yrQ7gzTCUjIwh4uiA_mW6lZIh1U4,40347 +textual/_context.py,sha256=Ujsl9xYHGTtp8mCqtwxpjrT_Wch1lK1Eo6y1nFnjicA,1028 +textual/_debug.py,sha256=pZ5YtrAaWkeDYoCI9wVMrwwZ71l4IuctHybV-MKSdFA,614 +textual/_dispatch_key.py,sha256=qesJHJMB6dNUbMTtpPBftLEo-e_SymbhEzO3U6hnJPQ,2462 +textual/_doc.py,sha256=TGh8u3SIaJqxfd5RjCQmIm2RelzoZhUkaYGrLk-StMo,5585 +textual/_duration.py,sha256=JrFyqVeUr6gxxaoyo9S3GloKBHLeNzkBD0eyultTzQk,1211 +textual/_easing.py,sha256=r3Jb71ijnfjtlL6GnmhUxmdCvTEmLC7j-2KrpxYoluU,4101 +textual/_event_broker.py,sha256=Bl5R38QBo89OD8xjm1shdAo90v4T3HeIMd1-jvLeGgA,999 +textual/_files.py,sha256=k6nkz2nRVhzxn8HSLCmCQoIM8MX8fUq_jCcfAfCyY6U,1002 +textual/_immutable_sequence_view.py,sha256=hdK2l5-CVkrwNb35LnDA0KWLy6drrQs5iyvrzZXSX7E,1859 +textual/_import_app.py,sha256=SjJ1Csw1G1nlmY5TJUY5cz-ut0qbyuwPIl0JRBzHJHI,3609 +textual/_keyboard_protocol.py,sha256=_2fITzjFYDgyS1DsJH1RhxmYz2Qkt9hlKMeMDSIVaEM,2881 +textual/_layout_resolve.py,sha256=tI_3JCOcUhmdZhAD--eCO0pJwLrLZfQS6-xZ0VDuenk,3274 +textual/_line_split.py,sha256=vlbYtnU1sNO8n4CApMDbU9Pq1wmZ96AWxrW4SbcKzSY,846 +textual/_log.py,sha256=JcWqpo98ntjo83SeIgmEuu7yYjEL8SUhb9-24eWEmzQ,436 +textual/_loop.py,sha256=2N2GLMdpG9Bs72VcAzq5cTO8a2kzFbo1kiUbD62AIKs,2602 +textual/_node_list.py,sha256=LllMf16LZliHANy9gwRrGG6NkDDTjp_oRG0gPtfYZ0o,6014 +textual/_on.py,sha256=GCQqrasJaH5wTutndEzei4I_wZVhNnaBFI-VN7TAhw0,3336 +textual/_opacity.py,sha256=6ksXtAu6_AYir8y3vkpz9Op-rYXB9sJgPrnbw6Oieno,1527 +textual/_parser.py,sha256=lIhJAESh42mtTVPRuqHcCor1KELfpmTcyoJsG5By36E,3307 +textual/_partition.py,sha256=Pfnz7RmnBkvaz4-xmaK6T6fwtrVjgNHkE8G83ZSsk30,845 +textual/_path.py,sha256=nFU9maUFeMgKsRZWzQIrs1xPAkCSvh0xevoCtDeGhxM,2062 +textual/_profile.py,sha256=XYC0j7iZhQrnoUe31NwDAYWuOK1qNMHRJE7hoC3e0Xc,462 +textual/_resolve.py,sha256=LJFLIlXxyEy2LLDnyuE_NCfuCN8iYtDczkkTNKjDlw4,9588 +textual/_segment_tools.py,sha256=6PRCDkhmwfk0uNjA4-geaXOvMlGVkKDikg8GkXC29K0,8432 +textual/_sleep.py,sha256=-4I-rtLWHL0sI7b0iRAWcjOcwYoRHRmSqz5dwaBQ8nw,1620 +textual/_slug.py,sha256=kkBalxyOzObVp5Pf5TGXinMiXycFfqge8D9jBIjvSLk,3652 +textual/_spatial_map.py,sha256=Jt4NEYub6IMkeiZXhuVM6wHje_4PnjuNul9dDdvqe-8,3764 +textual/_styles_cache.py,sha256=1KERmDqj0KDaU4tSU3Y2AvnvBjBRdMnmIm_NHkuDLaE,18307 +textual/_text_area_theme.py,sha256=dyZXT1WUEtcBGjXu9PKOI_y8-qvl4JUpnH8vAHdjXE0,18067 +textual/_time.py,sha256=6uwXYkuJqNsaUbdDPILYFVIG3MAtyYOxOgxJfiJkIiU,1410 +textual/_tree_sitter.py,sha256=tfB34HD7ri393rqY0LM8w2hqF8hSb5H97LMLtK3Ks9E,1657 +textual/_two_way_dict.py,sha256=jgjnZJquPTXJXAVH0TbmxFYFFT_6wDGsTAbZu8iR-PQ,2009 +textual/_types.py,sha256=1ivhTkBWxn3gsxzwzJaAIJDLHTvyITItitogKZTbvzA,1935 +textual/_wait.py,sha256=02WFOnKgfjenZJGdG7gMkAB6_S628Bd6cwqSUjuhV48,1446 +textual/_widget_navigation.py,sha256=lXaDlKOYMs8N778c8w1P36E4q_KRRFxe5u_-B46Sh9U,5702 +textual/_win_sleep.py,sha256=hQOr66VZQRh_dLflytq-FiUuAnxUKPtxk3nfqEaJwso,3773 +textual/_work_decorator.py,sha256=nFVvKFkK5WY0yJqPBlYDxdqpqo-gFhSc-WJYlO4EdZ0,5109 +textual/_wrap.py,sha256=Wub-6hr5P4JYyb-prW9x0YKPl4Q4H5mNaN_sTUqbyhI,5986 +textual/_xterm_parser.py,sha256=O8ZiJarEt19KbVuejN-TMq6LTyRCQo7fZHNUXJb3t6M,14361 +textual/actions.py,sha256=4UViH1TdTW8BaPxirxA5x7trNTpGTYCHIqnivBxq0Do,1669 +textual/app.py,sha256=kIzr-H4EtxAnUzE_CRuaFTVpg02HGhT9C4PXFK1-dog,168963 +textual/await_complete.py,sha256=YVsA_7Ag7E6hMiWoXt4hATzJIi0tgBukmDMMb7C8sXo,2598 +textual/await_remove.py,sha256=7eYlWIgV8ezMR092Vxf8fvTY11hoWCKqL0pdPRcFoNY,1345 +textual/binding.py,sha256=_T9c-ZnDc96SgsLZn4uQSO8lB5_w0GcaiBp80KMtgPY,13302 +textual/box_model.py,sha256=YZwVBQ-cWw0LbuvJ0Y7MzBB6siDIgyxOSnhW7KE-mrY,322 +textual/cache.py,sha256=XiW_VmMVHB_qJ0jcpiTGm3VyUlekqkxrFNd5dTBlo40,9357 +textual/canvas.py,sha256=mQ0-xajosQC8WkNJhzZ9HuvYKpsyjl0T48bhIVufdus,8203 +textual/case.py,sha256=fHL0-HcWfcyi5wNCIFuQOLs_9td48pApOK6KnjsFVTc,524 +textual/clock.py,sha256=cxdZ_3Li9d-uzKRIWYe9Zu0Xi1o3eV0trThFDEC9A0g,2022 +textual/color.py,sha256=HpBymcpd8at7DuA7wMvFeDtazN2rFXkSzbID7MhuXTw,26130 +textual/command.py,sha256=CJDOS9N_FhpI9ljcDfL2pujxafzERtoQ9U3fR0ZKc_E,42434 +textual/constants.py,sha256=li7HgYWDEbPx3-7WYI84UJZEjK1bfD6AxzoOv4tglMY,5083 +textual/containers.py,sha256=CLMK-320WgpeYwKQVwFsplBWYx2ZM5U_Kp9CzIH4TV4,8369 +textual/content.py,sha256=TkztUkLZirSESUMa_PO6IFUC2yYC0oH6eRZaBYPuThY,33048 +textual/coordinate.py,sha256=OTKoFBCgu0UF3QAxZkbbFVX2kcXzi7BFvRgQ59LhHII,1247 +textual/css/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +textual/css/__pycache__/__init__.cpython-310.pyc,, +textual/css/__pycache__/_error_tools.cpython-310.pyc,, +textual/css/__pycache__/_help_renderables.cpython-310.pyc,, +textual/css/__pycache__/_help_text.cpython-310.pyc,, +textual/css/__pycache__/_style_properties.cpython-310.pyc,, +textual/css/__pycache__/_styles_builder.cpython-310.pyc,, +textual/css/__pycache__/constants.cpython-310.pyc,, +textual/css/__pycache__/errors.cpython-310.pyc,, +textual/css/__pycache__/match.cpython-310.pyc,, +textual/css/__pycache__/model.cpython-310.pyc,, +textual/css/__pycache__/parse.cpython-310.pyc,, +textual/css/__pycache__/query.cpython-310.pyc,, +textual/css/__pycache__/scalar.cpython-310.pyc,, +textual/css/__pycache__/scalar_animation.cpython-310.pyc,, +textual/css/__pycache__/styles.cpython-310.pyc,, +textual/css/__pycache__/stylesheet.cpython-310.pyc,, +textual/css/__pycache__/tokenize.cpython-310.pyc,, +textual/css/__pycache__/tokenizer.cpython-310.pyc,, +textual/css/__pycache__/transition.cpython-310.pyc,, +textual/css/__pycache__/types.cpython-310.pyc,, +textual/css/_error_tools.py,sha256=arH_pq5n4hS904RzU13W1K32hbUm3xOo41-zhR3VMNA,743 +textual/css/_help_renderables.py,sha256=eDeNkC_dUXJ-iMkX-NLVJxQVVc3rqVbH9-nLVNj2o28,2833 +textual/css/_help_text.py,sha256=Pg00p8MBL1YZxmRSLzcFZbF1wJ837aQQPL0JWfjveW0,29546 +textual/css/_style_properties.py,sha256=ppajpfzQTBbL21DVQkQv4mthhYglkRdLGprniuMk5TY,42476 +textual/css/_styles_builder.py,sha256=jUzzYnouOVdm-RbHuxJcTIGw7trMmMdGh6n3rhBu3js,46025 +textual/css/constants.py,sha256=1xeZzRgQJs24t6Hi2GYip3X_6Fd4EOM0yynMQzFjb98,1858 +textual/css/errors.py,sha256=7nLjfcAC36ZGOZds1zqbHAxhc0gfEvhED20Tat8goWQ,1304 +textual/css/match.py,sha256=NCR-qQ6qpAYYd4gBU0wyOBQOWBHwjhbi0ZBsvSZyJFY,2390 +textual/css/model.py,sha256=ogdrDqUxvOAn4Q5ZgUVr1wHFTl5K3aOYAOLkh4rVyxE,8750 +textual/css/parse.py,sha256=mbyoFJmCGzy-wZcnJEsR3DQz2ZP6ranERAX7JgJ_7yU,16569 +textual/css/query.py,sha256=G-qw2gF_GX1likMp6f5oMie6yAV2UkDx8yRMO44-jGE,15700 +textual/css/scalar.py,sha256=ZZaYoDpdAO6NefsP6CEAp10h9eK_MDeRDNH4S8ymVH8,9951 +textual/css/scalar_animation.py,sha256=SRcA2ncys8BM37TJb7YQkrOn_GRrNtmtOuOYyynTruk,3159 +textual/css/styles.py,sha256=9dzWEfl3kon8jZfy5Oh0PhgZW_nzrYcq614CkpbStI0,48473 +textual/css/stylesheet.py,sha256=noOnGXhf8SgO-jU48D3Fn36VNr-GP_LcRRrnJZO11o0,26050 +textual/css/tokenize.py,sha256=L1I4X0yGw1Ak0kDegRu0dgHgw8ZOY7r6ri4UueTk_so,8761 +textual/css/tokenizer.py,sha256=UOV69Jw3Pi1qta8pCZp9-EeiMj5jUUd-mTLUyyCQf9w,10316 +textual/css/transition.py,sha256=IufvMOlCOnfTt3JtzFVp30_Nmi6PQsulaANXgFW2N2M,417 +textual/css/types.py,sha256=xnHCeIAMouGHHnQpq9AKu66wMrGxu06x_xT_flLr8cw,1482 +textual/demo/__main__.py,sha256=im4DgMc-NCHyZsg9zQ_eHL_cQD30vnpv8_faistjl-U,104 +textual/demo/__pycache__/__main__.cpython-310.pyc,, +textual/demo/__pycache__/data.cpython-310.pyc,, +textual/demo/__pycache__/demo_app.cpython-310.pyc,, +textual/demo/__pycache__/game.cpython-310.pyc,, +textual/demo/__pycache__/home.cpython-310.pyc,, +textual/demo/__pycache__/page.cpython-310.pyc,, +textual/demo/__pycache__/projects.cpython-310.pyc,, +textual/demo/__pycache__/widgets.cpython-310.pyc,, +textual/demo/data.py,sha256=ICO9k-4VJC1_yyRnZuMDBi6YQfyGN9sQrAevfKSR3U8,15435 +textual/demo/demo_app.py,sha256=XytLFr0KlGDdRf4UwZmz6aV9UM_Zk5nFI5spHQiLXPw,2965 +textual/demo/game.py,sha256=bRtSoHKEDeq31a1IUTgJ6vGLLTCpdtENbxCTH4PQU00,19337 +textual/demo/home.py,sha256=OK4kHveZFxV3HtMOkmI7p0-QSKSzfAtw5QrAZzU88HY,8422 +textual/demo/page.py,sha256=SpC1DiZEX1nZ_XvMg9hNQhl9rSppFdwC1lepIRBL1X8,2527 +textual/demo/projects.py,sha256=PG3ce0IgksWZvxppm9Pqf2Ai8KpjpQfprM8d-Iv-KeU,6963 +textual/demo/widgets.py,sha256=eGGuKuEaClhwWREUq42htrZFzgJNlweWKH2epy-aZR0,23796 +textual/design.py,sha256=CLT5CcSNphsDGX3VLay2khguPfj2zESsNJsDGI959Iw,14997 +textual/document/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +textual/document/__pycache__/__init__.cpython-310.pyc,, +textual/document/__pycache__/_document.cpython-310.pyc,, +textual/document/__pycache__/_document_navigator.cpython-310.pyc,, +textual/document/__pycache__/_edit.cpython-310.pyc,, +textual/document/__pycache__/_history.cpython-310.pyc,, +textual/document/__pycache__/_syntax_aware_document.cpython-310.pyc,, +textual/document/__pycache__/_wrapped_document.cpython-310.pyc,, +textual/document/_document.py,sha256=3M6oGZT7rNZnfDJ1z5UD5iDvE8IarhMXsWs0jVmvCwU,14859 +textual/document/_document_navigator.py,sha256=d6NPYjOWoHP205dnPQ9Ui6pD4GD0yROQwbn9KZPZn1A,18340 +textual/document/_edit.py,sha256=cWNgagAsw3RHP0rBsE0kI_IEn9TpRii3loSSS0KZONU,5707 +textual/document/_history.py,sha256=cbjM8gU-0b58GM6S0s8UfxXOhWoIdjiKMls8QolWWaU,7061 +textual/document/_syntax_aware_document.py,sha256=Wuw7i7fUN6jXZG8kH3revMBPg2MLEfDmQyq49SrSfJU,9782 +textual/document/_wrapped_document.py,sha256=ZvvGZn57xzwr9j3Ovfz_JeriwYUJBkTCZNdMhIL1-yc,17779 +textual/dom.py,sha256=pgwrpXnCQZXGxLgcNuzRhKlC_Wvs2deNODzDXxnm70E,58242 +textual/driver.py,sha256=qngjffPkLDaxkNoW6p_Si8-iwRFoHsNDqLDdSgPKvpo,10326 +textual/drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +textual/drivers/__pycache__/__init__.cpython-310.pyc,, +textual/drivers/__pycache__/_byte_stream.cpython-310.pyc,, +textual/drivers/__pycache__/_input_reader.cpython-310.pyc,, +textual/drivers/__pycache__/_input_reader_linux.cpython-310.pyc,, +textual/drivers/__pycache__/_input_reader_windows.cpython-310.pyc,, +textual/drivers/__pycache__/_writer_thread.cpython-310.pyc,, +textual/drivers/__pycache__/headless_driver.cpython-310.pyc,, +textual/drivers/__pycache__/linux_driver.cpython-310.pyc,, +textual/drivers/__pycache__/linux_inline_driver.cpython-310.pyc,, +textual/drivers/__pycache__/web_driver.cpython-310.pyc,, +textual/drivers/__pycache__/win32.cpython-310.pyc,, +textual/drivers/__pycache__/windows_driver.cpython-310.pyc,, +textual/drivers/_byte_stream.py,sha256=AAfHW-eVgPSkL7pQ2wU862HWyeeC118JoryJDZ-Ifqk,4052 +textual/drivers/_input_reader.py,sha256=jkV3cvjaiSM-nww0NW07NuDyNx4aP3oih-j2JHhVnto,222 +textual/drivers/_input_reader_linux.py,sha256=Xkk-aFeeVTRbN6I2jeV1FFVs_cdPYy7yHOG_s5TNUYw,1165 +textual/drivers/_input_reader_windows.py,sha256=u3IZ_dG4Nm1R80zG-nfP8yM0cs8esNWBbBVc4P6IJ4w,830 +textual/drivers/_writer_thread.py,sha256=Z_RECFN1mPiGZy_-nQoE4maaOxWm7S8GTrIQUhsSChE,1710 +textual/drivers/headless_driver.py,sha256=f7iV1VkGAR0-EliPfCcpegDfuA6qWjuIzMUiIkkvozI,1888 +textual/drivers/linux_driver.py,sha256=RSAqTLXM8PxD3yKE_6oghs_eMmJruZk-g2DJ4je5Mz4,16178 +textual/drivers/linux_inline_driver.py,sha256=sOCtiCB8NWnVjEvypEXDt0ATGnCqVYIaC5MArhMjIyc,10579 +textual/drivers/web_driver.py,sha256=-wL1c6PzfZPuZuVF6TnZPjgLYeFtOTI-gsSSRXFX64A,12280 +textual/drivers/win32.py,sha256=Ndsbr_nAln_zAl_ANlpg5iWMqdZxNh9E6V-ohnFp3VU,9677 +textual/drivers/windows_driver.py,sha256=pJFent9ZkTum-AMHJb3MeEHrkczh7O_GyaP8qdHU73E,4247 +textual/errors.py,sha256=QPtkzBtQVpbeXKJLm4EYyaqnrFrucbaztxAXlrtULYQ,534 +textual/eta.py,sha256=o5yMTLluXRknS7M1H2ZYufdAXYCx-YQbvYmwc0OyQxA,4645 +textual/events.py,sha256=ryVKlqlVLhmNU4IJ9WxJ6AMa96bzGZrzgzFJ7QMKFwY,23387 +textual/expand_tabs.py,sha256=FDinVoYRDINnaWiBPP-Z_6WMFVpS7j0vklZE3_yquoc,3538 +textual/features.py,sha256=NdME3Ye5SodDPgK39wkE0DANWijBq9BDeNzx9iT_PJ4,699 +textual/file_monitor.py,sha256=dFfdQHpSsheW09lFLq_OJyaL2kptuGIFxn-pd50Ohzo,1945 +textual/filter.py,sha256=15-4fcc3JQsPHn_BM7TwLDTvfGZMYXmZa3dBULySrZ0,7353 +textual/fuzzy.py,sha256=XX7TOhczpqibkiLEP0iJkrzSz-tnMX303UXWCR-aaYI,6842 +textual/geometry.py,sha256=ydWZcp0KThIDtSMTn0wUUHPM2udMMnoqoRCbVxFSwJk,40359 +textual/keys.py,sha256=KOjkFk2vmq804kwAPclnfJ576uHLqj1c9-keTs1-y28,9773 +textual/layout.py,sha256=yW6XGn-6QKB3tPIL7xFi33Zl121384Gqvud3_ROVQiY,9553 +textual/layouts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +textual/layouts/__pycache__/__init__.cpython-310.pyc,, +textual/layouts/__pycache__/factory.cpython-310.pyc,, +textual/layouts/__pycache__/grid.cpython-310.pyc,, +textual/layouts/__pycache__/horizontal.cpython-310.pyc,, +textual/layouts/__pycache__/vertical.cpython-310.pyc,, +textual/layouts/factory.py,sha256=3jSqo-4cyeJYrWoUIQ1RjP-Tm7DDPU1bFcma_HqVkM4,805 +textual/layouts/grid.py,sha256=ywWMIQvzbwD9Y_J7McftVcGQum_fIN8RaCy2k6-271Q,11158 +textual/layouts/horizontal.py,sha256=O5N2CY8aMGMbctfOexDkwvGZabNfDsOQ64QITlBQBYM,3811 +textual/layouts/vertical.py,sha256=2-bBaGipwlrmdwFnXCDep0YkfqSLi7zjNxnUfYrF5Ak,3857 +textual/lazy.py,sha256=dgKBCqB33AM1t-5_FgcWhS4jDsrNE9_hOT7u08BnxUc,4330 +textual/logging.py,sha256=YSFS52VGUx_P-GL1IKqqnQf5brcbiVA_j5-HkBC0iw4,1187 +textual/map_geometry.py,sha256=Wge908i7q-i6t7dArr9UCDzbKlyJhBD58lpLLkZGMFM,1363 +textual/message.py,sha256=UIFvz-AJgVlaGW90IVyXhzqho5cCxFzN2ZC6PJf-3GI,4893 +textual/message_pump.py,sha256=pgnNtdZ44dwFX5ILMUO_oUKjVa_SS-4A1OlPU412diY,30464 +textual/messages.py,sha256=KIvk_FhKWS8eFg4dqRQzivuMiJYuE7WI7TwYSqZ9jpc,3804 +textual/notifications.py,sha256=zhyc4vB-RIJZxe8ZvmCWQcCBeybQOYuJ75LRIgzqi4k,3627 +textual/pad.py,sha256=DsyjLlO1SzVUrftxYOVDQvpM22q_Gq4UXJTYY4VdUrw,2306 +textual/pilot.py,sha256=OakfQFi1w7Uu4N3hJi90jZF05ob0v_kY5QDhSHdyc4Q,22136 +textual/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +textual/reactive.py,sha256=KaLnuQ4lm9uQGHBLN56S9KEWV5yr1E4pr-Fno7IBStQ,16224 +textual/render.py,sha256=ntSdGt8-GSgMbYi9zB2tWbgcv1qWS1zqqA0PEh35XSk,1135 +textual/renderables/__init__.py,sha256=LNDET3CcfKQYwg52JbF6ffJruVE-2N0Oq46VQfHykL0,62 +textual/renderables/__pycache__/__init__.cpython-310.pyc,, +textual/renderables/__pycache__/_blend_colors.cpython-310.pyc,, +textual/renderables/__pycache__/background_screen.cpython-310.pyc,, +textual/renderables/__pycache__/bar.cpython-310.pyc,, +textual/renderables/__pycache__/blank.cpython-310.pyc,, +textual/renderables/__pycache__/digits.cpython-310.pyc,, +textual/renderables/__pycache__/gradient.cpython-310.pyc,, +textual/renderables/__pycache__/sparkline.cpython-310.pyc,, +textual/renderables/__pycache__/styled.cpython-310.pyc,, +textual/renderables/__pycache__/text_opacity.cpython-310.pyc,, +textual/renderables/__pycache__/tint.cpython-310.pyc,, +textual/renderables/_blend_colors.py,sha256=KbnKzTr2X22THJcp-P6XQzFufELM3HynSC8Ali6wQbg,732 +textual/renderables/background_screen.py,sha256=owJyg1aPV4QkrfpBjDSph6vtkGIINJneSeTBA0QOEZE,2975 +textual/renderables/bar.py,sha256=47fV-DvmdiCTy0M28t8oyJcgIREhfzJFt3CuOyi6aRk,4461 +textual/renderables/blank.py,sha256=bksMSYsJEAKChc2xugLxx6n9C3RZ_xbWUA3LrCXIjnQ,785 +textual/renderables/digits.py,sha256=Ijyg_gDpb7MAcWSf6BPlewD_0qHu2UqbHkU9TguAsV8,3659 +textual/renderables/gradient.py,sha256=2DY9n4S92g5Vsy_0uPVP8W-l-Yvo2d1Jgvzf4EMMZPw,4631 +textual/renderables/sparkline.py,sha256=9ea74HiDZiwuLt6YzxDSHUPIYC_x5X1A151V5gkAsts,4263 +textual/renderables/styled.py,sha256=my4vs7gj1NyOjrHP43RpKCWJC5F61vCPvrJq5jUdARE,1937 +textual/renderables/text_opacity.py,sha256=-wtUlJQz82nLb4cTtSK--XsITHpKpishwxaYs4QtDlA,2984 +textual/renderables/tint.py,sha256=ENMlS2DJVIRFkYBBsdnGBXddN9H9D1tsyoQlqvCZX-w,2327 +textual/rlock.py,sha256=-p1g3itvbTIiBJ3cuUX5-e_7RedDSeKgXU6JWHIk7BM,1657 +textual/screen.py,sha256=VQCOhvGWyiINCkOPxz08zSVnR4VxqrZ9IeVRo4HKkhA,57326 +textual/scroll_view.py,sha256=OCapl5-sI1TYX_9C5bbyZF4gKPoCTuolvO-mTAjtNpI,5858 +textual/scrollbar.py,sha256=qv0oUp6qoO5PQoTAAsKNmJsdv8xD1PwA7yvnqVwiPkw,13367 +textual/signal.py,sha256=Lb4GMvcI7YFKf22nf-ZkJP6X4tyVQmsVdYRU51IER-Q,4384 +textual/strip.py,sha256=hubNeQi2tsi_oGlyLVwh89pWa0T-9qHfsWIgZ1GOgCo,19960 +textual/suggester.py,sha256=mgF0OQYIdLDMN122SDNksOtw5vlcqpIHFQz2kJOkWXE,4723 +textual/suggestions.py,sha256=bXR4HHbksBrWnfCuQX2Q0Ohb8jFPdvpz8E9mVIJenT8,1415 +textual/system_commands.py,sha256=o44kIVF0wlxkBGp2AfjMtQj9gMPw5_JzDaZy3a30HuI,2041 +textual/theme.py,sha256=S-7s-aqsGV7GB1qW-l2SFxz-e8XVaiKtRc-FhDJveAU,9339 +textual/timer.py,sha256=BHtq2zzieHBluDFEcYWioG9kLJzJBu4E3HLvQFar-V4,6006 +textual/tree-sitter/highlights/bash.scm,sha256=t0Ig2VT0hbdibSsrYfN7Ui4S6xgwgD44jlfdeX3JnxE,577 +textual/tree-sitter/highlights/css.scm,sha256=3TuBRu72TCXWwNzKSu_VFVSXqQs117vvg5kDckTSJC8,1006 +textual/tree-sitter/highlights/go.scm,sha256=FrYW0vTzVTTRQWn8fFCIm8U05fmAdgnTOhcSHGDgMP4,1421 +textual/tree-sitter/highlights/html.scm,sha256=h8CDLw5phM8CZBRVmv1xNqVVMDSJaSDcqpoj32EZXxI,408 +textual/tree-sitter/highlights/java.scm,sha256=l7TNO-5hRFPhfmFRWpjo1lDmb_m_ehisUB8RnfCTfp4,2008 +textual/tree-sitter/highlights/javascript.scm,sha256=02MK5tybKyeyMLX4u5KwXNSR-xK_81Pa5ioKbXgEYe4,2739 +textual/tree-sitter/highlights/json.scm,sha256=u9_szLgFyYLehBbugUMp9i22DiH7d_UJodrcLmXxCEA,430 +textual/tree-sitter/highlights/markdown.scm,sha256=eQbMTMHdDNxdCAMIZ7ueALx7I552uyV6zUIDwA4k3jk,745 +textual/tree-sitter/highlights/python.scm,sha256=WQXivskjhpxs-5PQuyP2rmZFvUu4Ypez1rmy68BbMSQ,7361 +textual/tree-sitter/highlights/regex.scm,sha256=WTAGJ0nhjdcc_T-p5mKiIPHtq-DWmJCpDwrV7RRBm3s,591 +textual/tree-sitter/highlights/rust.scm,sha256=ESEJTK6-dv8Xb-VnuuneOyvTfIi_jtgaYtFW_1rXR-g,3386 +textual/tree-sitter/highlights/sql.scm,sha256=2PMjK6-8MF2I7dWKGJ3_jFcy1AO6q_d9j7gr2XFlt5w,7735 +textual/tree-sitter/highlights/toml.scm,sha256=ONYMbMSK_vUThvf1ilCAJr-ko8LQLbTLzpCnpRCa2UI,606 +textual/tree-sitter/highlights/xml.scm,sha256=qkpWHIRpKMOk2IWsvmkKYGiWYaRWhLq-Fs-LehUJthA,2281 +textual/tree-sitter/highlights/yaml.scm,sha256=AEm4EwATSujzIy1qgSoXOXrUYaMH3Kd3P3BpkQT-Fxk,943 +textual/types.py,sha256=tYw07liOXMPf-OLVZ04d7_T0rq_HS83rrpss3AeTEvk,1435 +textual/validation.py,sha256=lrM8NTGr1_PMzpdoUjrI7aCkhDkNVCCVuJt6nQRRTag,18361 +textual/visual.py,sha256=7VPWeYgbwGdzrvof7BcsvbiAXERaOuZZFSxjkjg7JNM,14547 +textual/walk.py,sha256=Epkx1pKwAUJ1lKtLIkqOKr9es1mbI8ghEJF4SJqiO2c,3721 +textual/widget.py,sha256=7HYnl1nyusOdBAOQA4nH4You5juS1cN_7nBpxkgxsng,156738 +textual/widgets/__init__.py,sha256=O3UwuSzpA9WQJWjbx7rPGPG-GbULWGTZNAVh0xgccxA,3817 +textual/widgets/__init__.pyi,sha256=Q1-TJ7SQGXhTwUypaOq9chCGVmE3r5H915MeOduMmwg,1970 +textual/widgets/__pycache__/__init__.cpython-310.pyc,, +textual/widgets/__pycache__/_button.cpython-310.pyc,, +textual/widgets/__pycache__/_checkbox.cpython-310.pyc,, +textual/widgets/__pycache__/_collapsible.cpython-310.pyc,, +textual/widgets/__pycache__/_content_switcher.cpython-310.pyc,, +textual/widgets/__pycache__/_data_table.cpython-310.pyc,, +textual/widgets/__pycache__/_digits.cpython-310.pyc,, +textual/widgets/__pycache__/_directory_tree.cpython-310.pyc,, +textual/widgets/__pycache__/_footer.cpython-310.pyc,, +textual/widgets/__pycache__/_header.cpython-310.pyc,, +textual/widgets/__pycache__/_help_panel.cpython-310.pyc,, +textual/widgets/__pycache__/_input.cpython-310.pyc,, +textual/widgets/__pycache__/_key_panel.cpython-310.pyc,, +textual/widgets/__pycache__/_label.cpython-310.pyc,, +textual/widgets/__pycache__/_link.cpython-310.pyc,, +textual/widgets/__pycache__/_list_item.cpython-310.pyc,, +textual/widgets/__pycache__/_list_view.cpython-310.pyc,, +textual/widgets/__pycache__/_loading_indicator.cpython-310.pyc,, +textual/widgets/__pycache__/_log.cpython-310.pyc,, +textual/widgets/__pycache__/_markdown.cpython-310.pyc,, +textual/widgets/__pycache__/_markdown_viewer.cpython-310.pyc,, +textual/widgets/__pycache__/_masked_input.cpython-310.pyc,, +textual/widgets/__pycache__/_option_list.cpython-310.pyc,, +textual/widgets/__pycache__/_placeholder.cpython-310.pyc,, +textual/widgets/__pycache__/_pretty.cpython-310.pyc,, +textual/widgets/__pycache__/_progress_bar.cpython-310.pyc,, +textual/widgets/__pycache__/_radio_button.cpython-310.pyc,, +textual/widgets/__pycache__/_radio_set.cpython-310.pyc,, +textual/widgets/__pycache__/_rich_log.cpython-310.pyc,, +textual/widgets/__pycache__/_rule.cpython-310.pyc,, +textual/widgets/__pycache__/_select.cpython-310.pyc,, +textual/widgets/__pycache__/_selection_list.cpython-310.pyc,, +textual/widgets/__pycache__/_sparkline.cpython-310.pyc,, +textual/widgets/__pycache__/_static.cpython-310.pyc,, +textual/widgets/__pycache__/_switch.cpython-310.pyc,, +textual/widgets/__pycache__/_tab.cpython-310.pyc,, +textual/widgets/__pycache__/_tab_pane.cpython-310.pyc,, +textual/widgets/__pycache__/_tabbed_content.cpython-310.pyc,, +textual/widgets/__pycache__/_tabs.cpython-310.pyc,, +textual/widgets/__pycache__/_text_area.cpython-310.pyc,, +textual/widgets/__pycache__/_toast.cpython-310.pyc,, +textual/widgets/__pycache__/_toggle_button.cpython-310.pyc,, +textual/widgets/__pycache__/_tooltip.cpython-310.pyc,, +textual/widgets/__pycache__/_tree.cpython-310.pyc,, +textual/widgets/__pycache__/_welcome.cpython-310.pyc,, +textual/widgets/__pycache__/button.cpython-310.pyc,, +textual/widgets/__pycache__/data_table.cpython-310.pyc,, +textual/widgets/__pycache__/directory_tree.cpython-310.pyc,, +textual/widgets/__pycache__/input.cpython-310.pyc,, +textual/widgets/__pycache__/markdown.cpython-310.pyc,, +textual/widgets/__pycache__/option_list.cpython-310.pyc,, +textual/widgets/__pycache__/rule.cpython-310.pyc,, +textual/widgets/__pycache__/select.cpython-310.pyc,, +textual/widgets/__pycache__/selection_list.cpython-310.pyc,, +textual/widgets/__pycache__/tabbed_content.cpython-310.pyc,, +textual/widgets/__pycache__/text_area.cpython-310.pyc,, +textual/widgets/__pycache__/tree.cpython-310.pyc,, +textual/widgets/_button.py,sha256=LRR_iqxcUMR34HRpjjhAHN7iS5LI9NDuxibvAV6n7Wk,12399 +textual/widgets/_checkbox.py,sha256=7dcek73xEVosI8Umkm0ZmLLrn-Ews4hpWUJhD68EqRk,803 +textual/widgets/_collapsible.py,sha256=aSyYxkjmzjAM7JwHUhf_J0riepSwUFKwOdWyQ8QATLE,7481 +textual/widgets/_content_switcher.py,sha256=VxF92FfuGZkR4novpSffNtkjp38IRgS8CqSlES4BQDQ,4326 +textual/widgets/_data_table.py,sha256=TIEiVyPlUD6QD42h5C58Gr5K2PWIJp4lE_f4G9IXrpA,106133 +textual/widgets/_digits.py,sha256=wEAGReN9lIMGbq-HFJR1-E_hT1QnLqgSfo2hLQOHMUc,3186 +textual/widgets/_directory_tree.py,sha256=zRhBrRrq1N90QiXPdpFkEN56SAsUveYgDzEWZyxKkZ8,20023 +textual/widgets/_footer.py,sha256=JcL1ofLSdx4wm458E352lINEgtejwZigfhQ_pn9XBcw,8069 +textual/widgets/_header.py,sha256=oWa1PrcWd9Jpfl6dlIEzMoa9_2N1cLSAJRNp5hl7Ck8,6294 +textual/widgets/_help_panel.py,sha256=03N-Ajp2fjORuUk6NHgtVmgZAmditH3hAvIpQVYcgn4,2856 +textual/widgets/_input.py,sha256=URA5vhSt4f4X6i5vgVSwYECW79juJqSHYiq6qctBr50,36929 +textual/widgets/_key_panel.py,sha256=-5fl3KvehQHbKOnecmLrk5Og_yzMVZB_cLmgiK7rHpg,5345 +textual/widgets/_label.py,sha256=jDDQ0spWdMJHi4VMIR2YkW1yfDrZCpc68fCtn516ego,1775 +textual/widgets/_link.py,sha256=fDrE_TVdporJph43ATjLfy1qj892SYKSCaGU9R2Z9VM,1954 +textual/widgets/_list_item.py,sha256=6T2eQt-V61lEkBD9LXeNcm2CrrCpPunQvE8eccW6Y6c,1199 +textual/widgets/_list_view.py,sha256=mZMInm3AFeaQJjsl1rmsT5M_qPIJR7w6R7ou1ue702w,14184 +textual/widgets/_loading_indicator.py,sha256=gzVP6-4vEs0fTjVGUNSB23QsxLNccD6dbIsxq05ZEr4,2545 +textual/widgets/_log.py,sha256=9VJSOOrJ98A3NCfvmM_n5-OAboBELMTzQFTm8NJSAdY,10187 +textual/widgets/_markdown.py,sha256=OvqOsuLw9hfBWxVbGELSqR7x2WFGmRNmnuWYWRq8svI,39050 +textual/widgets/_markdown_viewer.py,sha256=0vm68FEUPAW48rKglOuEZkHD633yrE48GsUNL1BMw88,83 +textual/widgets/_masked_input.py,sha256=Rn6mVGw8lsDqvPhTPUCVp7kRnOPt-CdtXaZQkN9rhFY,26148 +textual/widgets/_option_list.py,sha256=sWy5sXdwG_LMW47UIxzHsznVftUku5ca55YJq24tU08,35554 +textual/widgets/_placeholder.py,sha256=j7Oi1Vrc2fN5e__q23mINMQH_V_PnGq9v8MM2PNK7n8,6179 +textual/widgets/_pretty.py,sha256=bqoo49hzXaMhSZFkP4OBSds-M88sMbVC3c_OWWouirA,1455 +textual/widgets/_progress_bar.py,sha256=u6NL_WL9hmrsFmwWLU8BBaAOVt98hRl6aFdLhj0vrvs,12760 +textual/widgets/_radio_button.py,sha256=k1XkfAwIHDvqPpSk8FCElOSnS_eoEksmwBhGZaMu90A,1037 +textual/widgets/_radio_set.py,sha256=MIAzml47Z3amiXihiVzoMhFn4QxJJStJKLp0Ihf-HVg,10822 +textual/widgets/_rich_log.py,sha256=s5tME9F12YZDAUj3zFAcezJkm1tAaWkT2MGB5KRL2lM,12138 +textual/widgets/_rule.py,sha256=AoGNaME62i6sQFDPnJUtQymogKa1Xd2DI7b14oTT6nc,7481 +textual/widgets/_select.py,sha256=3oGE1FFhYhXTmvJAwkvMw1bm5HdZDcvL330RSY9DAPk,19954 +textual/widgets/_selection_list.py,sha256=pylzk1i2Gfmco7wc4jVgmLn82fUhD_OY3vTrR556jQ0,25501 +textual/widgets/_sparkline.py,sha256=w7AdwIbgJNad0MYh44rCWD1p5K0A63emjRTkSLuBlB8,3847 +textual/widgets/_static.py,sha256=mTbuJVOCHWveRp3oAoiKJ43ZUJzZA1jW49inG6cTMrE,3449 +textual/widgets/_switch.py,sha256=wNNRicW--JAqp4Sn39IQ9y2a2X4sHemJjhN7RhjStpU,5904 +textual/widgets/_tab.py,sha256=iWSYcf02lpgnbkmX187-TRlT-_n0PWhHS85ZAEjKsi0,57 +textual/widgets/_tab_pane.py,sha256=X8G7JmPYUhxPDRutl4nTQU_f15aMsmwg3grCN4-I7CI,75 +textual/widgets/_tabbed_content.py,sha256=gXSFdAMZ7hgqg6PHyLXwrgcJXqfngDI1FeKVgljeDD0,23912 +textual/widgets/_tabs.py,sha256=ChiL2v3_QP2nq_h2RKRTAIaSgfQULChyF6zviUICLaY,27063 +textual/widgets/_text_area.py,sha256=UKMzqGECL_xmkEN47ADC8VmgNKA1zOD2r9cXIswH_pM,89449 +textual/widgets/_toast.py,sha256=7IJ0APU2Keo8STmJ_0rVToGw5h3jrbAbRAq0JYKiUM0,5907 +textual/widgets/_toggle_button.py,sha256=gXpAiWDA3pYn5KTnNST6x4a-wr-vf-FNVJIuNNednd4,7868 +textual/widgets/_tooltip.py,sha256=0_zjQ6axz1XoLaQdevD--51HKIDEqRnYS8BI5wbP3Vs,450 +textual/widgets/_tree.py,sha256=rCauiTVEt1deFKf6jqmrPXlNMs1TnEnJLtcIfLm9hR8,51508 +textual/widgets/_welcome.py,sha256=hAKv4kRhgXT62lJ_yyr0AQ4X_k3adZpGsX2DXCK8eLY,1535 +textual/widgets/button.py,sha256=XI_hItOeDSYGOvEHXPRM1mJixyh7B4gTv9epqTsarkI,79 +textual/widgets/data_table.py,sha256=fy95lQL4WZ17PKTHOP1bkidx-EJXm7LG1_yLn2YIHUQ,465 +textual/widgets/directory_tree.py,sha256=Oewg1taFCqi_olLdHu3FjmycMdD3bn3-z_192XT0QRw,77 +textual/widgets/input.py,sha256=fb7ubWtidEwVEAXU1rqjuOV4dTzSRT2Ld3ttTZpTRjQ,70 +textual/widgets/markdown.py,sha256=l8kf6G6p6yn8e2FYF_8uExkwTCVai-cBpfcRgz3PqdE,239 +textual/widgets/option_list.py,sha256=L970q2k999clE2d3HTLlgy1UjXhy9ZHlcBIibrlaT2o,185 +textual/widgets/rule.py,sha256=xGAmACHfJuGmzjvqIFKKuxebsFeOe5X3KhPG0EYeQt0,233 +textual/widgets/select.py,sha256=8wSkXCxigP0VVuYFO7v2S10H6sPIuo1lvH6N0nFGz9o,137 +textual/widgets/selection_list.py,sha256=qSnXxXFbDPUOqk41Zpm-redQNRgpxPA82dwnh84Zf9Q,212 +textual/widgets/tabbed_content.py,sha256=UkHQCXF7alJc9GIhxJC7bM0rRHPTywz3to-YGQcYV7Q,120 +textual/widgets/text_area.py,sha256=qg3c0uuM19ci4lLmNFxkFtvyXog6M00dOLzITVrab_w,1053 +textual/widgets/tree.py,sha256=F4YBlgT7CQ64tmhYgrrzZhTv7zxiF26IaJZEs75l9QU,372 +textual/worker.py,sha256=286qK6IDpaBR6yCSdHOTwWY3CHeBtwRobq42ip6pAKI,13715 +textual/worker_manager.py,sha256=vqvmkIqp5Jyb1lGXw2Yqz0av1uYPRgEiP3VQviz_bE0,5603 diff --git a/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/REQUESTED b/vllm/lib/python3.10/site-packages/textual-1.0.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e07356af5e94e6146532b8c6b2672ea57b7037a4 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/autograd.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/autograd.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67f2d61ecd215662d7b9d20917d96b478bb62f3f Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/autograd.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/cpp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/cpp.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..08e29769dc645d3117c34ae67574c1a2c3b196aa Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/cpp.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/functionalization.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/functionalization.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8006a77d5d6a30671fce1d3cfe149c2e6da7519 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/functionalization.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/lazy.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/lazy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad9d4d66cf29d125311b4238bd61c1d6ae00a534 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/lazy.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/meta.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/meta.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80a33d8874a5472f2cf5c500f332daff5833e894 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/meta.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/native.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/native.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f81274f596dced47dd4e05a05e41f5355ee62094 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/native.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/ufunc.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/ufunc.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29ca13df128121ed26b61023a93b70c191f7a235 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/ufunc.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/unboxing.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/unboxing.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02d642b8c52846bf8a8aadd1ca654d2e7f702ca5 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/api/__pycache__/unboxing.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/api/types/types_base.py b/vllm/lib/python3.10/site-packages/torchgen/api/types/types_base.py new file mode 100644 index 0000000000000000000000000000000000000000..e031b79485e057769302149369500cdb3df4c1e2 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/torchgen/api/types/types_base.py @@ -0,0 +1,276 @@ +""" +Where should I add a new type? `types_base.py` vs `types.py` + +This file defines data model classes for torchgen typing system, as well as some base types such as int32_t. + +`types.py` defines ATen Tensor type and some c10 types, along with signatures that use these types. + +The difference between these two files, is `types_base.py` should be implementation-agnostic, meaning it shouldn't +contain any type definition that is tight to a specific C++ library (e.g., ATen), so that it can be easily reused +if we want to generate code for another C++ library. + +Add new types to `types.py` if these types are ATen/c10 related. +Add new types to `types_base.py` if they are basic and not attached to ATen/c10. +""" + +from __future__ import annotations + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from enum import auto, Enum +from typing import TYPE_CHECKING, Union + + +if TYPE_CHECKING: + from torchgen.model import Argument, SelfArgument, TensorOptionsArguments + + +# An ArgName is just the str name of the argument in schema; +# but in some special circumstances, we may add a little extra +# context. The Enum SpecialArgName covers all of these cases; +# grep for their construction sites to see when they can occur. + + +class SpecialArgName(Enum): + possibly_redundant_memory_format = auto() + + +ArgName = Union[str, SpecialArgName] + + +# This class shouldn't be created directly; instead, use/create one of the singletons below. +@dataclass(frozen=True) +class BaseCppType: + ns: str | None + name: str + + def __str__(self) -> str: + if self.ns is None or self.ns == "": + return self.name + return f"{self.ns}::{self.name}" + + +# The set of all non-templated, valid, fully-qualified names of C++ types that are used in the codegen. +# Templated types get their own dataclass, mainly to make namespace parsing easier. +byteT = BaseCppType("", "uint8_t") +charT = BaseCppType("", "int8_t") +shortT = BaseCppType("", "int16_t") +# It would be more symmetric for this to be called intT, but it easy to mix +# this up with JIT int (which is int64_t in C++), so we intentionally don't +# define intT to make it obvious when you've stuffed it up +int32T = BaseCppType("", "int32_t") +longT = BaseCppType("", "int64_t") +doubleT = BaseCppType("", "double") +floatT = BaseCppType("", "float") +boolT = BaseCppType("", "bool") +voidT = BaseCppType("", "void") + + +class CType(ABC): + @abstractmethod + def cpp_type(self, *, strip_ref: bool = False) -> str: + raise NotImplementedError + + @abstractmethod + def cpp_type_registration_declarations(self) -> str: + raise NotImplementedError + + @abstractmethod + def remove_const_ref(self) -> CType: + return self + + +@dataclass(frozen=True) +class BaseCType(CType): + type: BaseCppType + + def cpp_type(self, *, strip_ref: bool = False) -> str: + return str(self.type) + + # For BC reasons, we don't want to introduce at:: namespaces to RegistrationDeclarations.yaml + # TODO: Kill this when we eventually remove it! + def cpp_type_registration_declarations(self) -> str: + return str(self.type).replace("at::", "") + + def remove_const_ref(self) -> CType: + return self + + +@dataclass(frozen=True) +class ConstRefCType(CType): + elem: CType + + def cpp_type(self, *, strip_ref: bool = False) -> str: + if strip_ref: + return self.elem.cpp_type(strip_ref=strip_ref) + return f"const {self.elem.cpp_type()} &" + + def cpp_type_registration_declarations(self) -> str: + return f"const {self.elem.cpp_type_registration_declarations()} &" + + def remove_const_ref(self) -> CType: + return self.elem.remove_const_ref() + + +@dataclass(frozen=True) +class VectorCType(CType): + elem: CType + + def cpp_type(self, *, strip_ref: bool = False) -> str: + # Do not pass `strip_ref` recursively. + return f"::std::vector<{self.elem.cpp_type()}>" + + def cpp_type_registration_declarations(self) -> str: + return f"::std::vector<{self.elem.cpp_type_registration_declarations()}>" + + def remove_const_ref(self) -> CType: + return VectorCType(self.elem.remove_const_ref()) + + +@dataclass(frozen=True) +class ArrayCType(CType): + elem: CType + size: int + + def cpp_type(self, *, strip_ref: bool = False) -> str: + # Do not pass `strip_ref` recursively. + return f"::std::array<{self.elem.cpp_type()},{self.size}>" + + def cpp_type_registration_declarations(self) -> str: + return f"::std::array<{self.elem.cpp_type_registration_declarations()},{self.size}>" + + def remove_const_ref(self) -> CType: + return ArrayCType(self.elem.remove_const_ref(), self.size) + + +@dataclass(frozen=True) +class TupleCType(CType): + elems: list[CType] + + def cpp_type(self, *, strip_ref: bool = False) -> str: + # Do not pass `strip_ref` recursively. + return f'::std::tuple<{",".join([e.cpp_type() for e in self.elems])}>' + + def cpp_type_registration_declarations(self) -> str: + return f'::std::tuple<{",".join([e.cpp_type_registration_declarations() for e in self.elems])}>' + + def remove_const_ref(self) -> CType: + return TupleCType([e.remove_const_ref() for e in self.elems]) + + +@dataclass(frozen=True) +class MutRefCType(CType): + elem: CType + + def cpp_type(self, *, strip_ref: bool = False) -> str: + if strip_ref: + return self.elem.cpp_type(strip_ref=strip_ref) + return f"{self.elem.cpp_type()} &" + + def cpp_type_registration_declarations(self) -> str: + return f"{self.elem.cpp_type_registration_declarations()} &" + + def remove_const_ref(self) -> CType: + return self.elem.remove_const_ref() + + +# A NamedCType is short for Named C++ semantic type. A NamedCType represents a C++ type, plus +# semantic information about what it represents. For example, consider the +# argument "bool pin_memory"; its normal C++ type is "bool", but its C++ +# semantic type also keeps track that this represents a "pin_memory"; you can't +# just use a random other boolean in a context where you need a "pin_memory"! +# + + +@dataclass(frozen=True) +class NamedCType: + name: ArgName + type: CType + + def cpp_type(self, *, strip_ref: bool = False) -> str: + return self.type.cpp_type(strip_ref=strip_ref) + + # For BC reasons, we don't want to introduce at:: namespaces to RegistrationDeclarations.yaml + # TODO: Kill this when we eventually remove it! + def cpp_type_registration_declarations(self) -> str: + return self.type.cpp_type_registration_declarations() + + def remove_const_ref(self) -> NamedCType: + return NamedCType(self.name, self.type.remove_const_ref()) + + def with_name(self, name: str) -> NamedCType: + return NamedCType(name, self.type) + + +# A binding represents any C++ binding site for a formal parameter. +# We don't distinguish between binding sites for different APIs; +# instead, all of the important distinctions are encoded in CType, +# which you can use to figure out if a given Binding is appropriate +# for use in another context. (See torchgen.api.translate) + + +@dataclass(frozen=True) +class Binding: + name: str + nctype: NamedCType + argument: Argument | TensorOptionsArguments | SelfArgument + # TODO: maybe don't represent default here + default: str | None = None + + def rename(self, name: str) -> Binding: + return Binding( + name=name, + nctype=self.nctype, + argument=self.argument, + default=self.default, + ) + + @property + def type(self) -> str: + return self.nctype.cpp_type() + + def no_default(self) -> Binding: + return Binding( + name=self.name, + nctype=self.nctype, + default=None, + argument=self.argument, + ) + + def decl(self, *, func_ptr_cast: bool = False) -> str: + mb_default = "" + if self.default is not None: + mb_default = f"={self.default}" + + # casting only needs to know the type + if func_ptr_cast: + return f"{self.type}" + else: + return f"{self.type} {self.name}{mb_default}" + + # For BC reasons, we don't want to introduce at:: namespaces to RegistrationDeclarations.yaml + # TODO: Kill this when we eventually remove it! + def decl_registration_declarations(self) -> str: + type_s = self.nctype.cpp_type_registration_declarations() + mb_default = "" + if self.default is not None: + mb_default = f"={self.default}" + return f"{type_s} {self.name}{mb_default}" + + def defn(self) -> str: + return f"{self.type} {self.name}" + + def with_name(self, name: str) -> Binding: + return Binding( + name=name, nctype=self.nctype, argument=self.argument, default=self.default + ) + + +# An Expr is a C++ expression. It has a C++ string representing its syntax, +# as well as a CType saying what it provides. + + +@dataclass(frozen=True) +class Expr: + expr: str + type: NamedCType diff --git a/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b490d265cf8bc839917a201af930e92da372dd0a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/operator.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/operator.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56e19f3969b81609fdc43b01fd35d498e0e09f33 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/operator.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/selector.cpython-310.pyc b/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/selector.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f957cd1787cb4577b3a1b42089eb19f818a6cff8 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/torchgen/selective_build/__pycache__/selector.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/torchgen/selective_build/operator.py b/vllm/lib/python3.10/site-packages/torchgen/selective_build/operator.py new file mode 100644 index 0000000000000000000000000000000000000000..0cb92dfc09e28c7c98ab7230af362c363a30d621 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/torchgen/selective_build/operator.py @@ -0,0 +1,171 @@ +from __future__ import annotations + +from dataclasses import dataclass + + +# This class holds information about a single operator used to determine +# the outcome of a selective/custom PyTorch build that doesn't include +# registration code for all the supported operators. This is done to +# reduce the size of the generated binary so that it can be deployed in +# situations where binary size comes at a premium. +# +@dataclass(frozen=True) +class SelectiveBuildOperator: + # The name of the operator. This includes the aten::, etc... prefix + # The operator name may or may not have the overload name. If this + # operator name does not specify an overload name, the way to determine + # if this entry refers to the family of operators with this base name + # or just the operator with this name is to look at the value of the + # 'include_all_overloads' flag in this class. + name: str + + # True if this is a root operator (i.e. called directly from a + # TorchScript model, etc...). An operator is considered to be a + # root operator if it is called directly from any one of the models + # that this instance of the pytorch library was built for. Hence, it + # may not be a root operator in all of the models that are used in + # this instance of the pytorch library. + is_root_operator: bool + + # Is this operator used for on-device training? If True, then we need to + # use the information to generate code in VariableType_N.cpp for registration + # of training related operators. Again, this is True if this operator + # is used for training in one or more models used by this instance of the + # pytorch library. + is_used_for_training: bool + + # If True, it indicates that this operator instance (object) refers to an + # operator without the overload name and should apply to all overloads + # which have this operator name as the base name. This flag is applicable + # only for objects that have operator names without a DOT (period) character + # in them. + # + # Note: This flag is a temporary workaround to grandfather in the current + # static selective (custom) build mechanism, which largely ignores overload + # names when determining whether to select operators for registration + # purposes. + include_all_overloads: bool + + # Debug Information at the operator level + _debug_info: tuple[str, ...] | None + + @staticmethod + def from_yaml_dict( + op_name: str, op_info: dict[str, object] + ) -> SelectiveBuildOperator: + allowed_keys = { + "name", + "is_root_operator", + "is_used_for_training", + "include_all_overloads", + "debug_info", + } + + if len(set(op_info.keys()) - allowed_keys) > 0: + raise Exception( # noqa: TRY002 + "Got unexpected top level keys: {}".format( + ",".join(set(op_info.keys()) - allowed_keys), + ) + ) + + if "name" in op_info: + assert op_name == op_info["name"] + + is_root_operator = op_info.get("is_root_operator", True) + assert isinstance(is_root_operator, bool) + + is_used_for_training = op_info.get("is_used_for_training", True) + assert isinstance(is_used_for_training, bool) + + include_all_overloads = op_info.get("include_all_overloads", True) + assert isinstance(include_all_overloads, bool) + + debug_info: tuple[str, ...] | None = None + if "debug_info" in op_info: + di_list = op_info["debug_info"] + assert isinstance(di_list, list) + debug_info = tuple(str(x) for x in di_list) + + return SelectiveBuildOperator( + name=op_name, + is_root_operator=is_root_operator, + is_used_for_training=is_used_for_training, + include_all_overloads=include_all_overloads, + _debug_info=debug_info, + ) + + @staticmethod + def from_legacy_operator_name_without_overload( + name: str, + ) -> SelectiveBuildOperator: + return SelectiveBuildOperator( + name=name, + is_root_operator=True, + is_used_for_training=True, + include_all_overloads=True, + _debug_info=None, + ) + + def to_dict(self) -> dict[str, object]: + ret: dict[str, object] = { + "is_root_operator": self.is_root_operator, + "is_used_for_training": self.is_used_for_training, + "include_all_overloads": self.include_all_overloads, + } + if self._debug_info is not None: + ret["debug_info"] = self._debug_info + + return ret + + +def merge_debug_info( + lhs: tuple[str, ...] | None, + rhs: tuple[str, ...] | None, +) -> tuple[str, ...] | None: + # Ensure that when merging, each entry shows up just once. + if lhs is None and rhs is None: + return None + + return tuple(set((lhs or ()) + (rhs or ()))) + + +def combine_operators( + lhs: SelectiveBuildOperator, rhs: SelectiveBuildOperator +) -> SelectiveBuildOperator: + if str(lhs.name) != str(rhs.name): + raise Exception( # noqa: TRY002 + f"Expected both arguments to have the same name, but got '{str(lhs.name)}' and '{str(rhs.name)}' instead" + ) + + return SelectiveBuildOperator( + name=lhs.name, + # Consider this operator to be a root operator if it is a + # root operator in any of the models used in this instance of + # the pytorch library. + is_root_operator=lhs.is_root_operator or rhs.is_root_operator, + # Consider this operator to be a training operator if it is + # an operator used for training in any of the models used + # in this instance of the pytorch library. + is_used_for_training=lhs.is_used_for_training or rhs.is_used_for_training, + include_all_overloads=lhs.include_all_overloads or rhs.include_all_overloads, + _debug_info=merge_debug_info(lhs._debug_info, rhs._debug_info), + ) + + +def merge_operator_dicts( + lhs: dict[str, SelectiveBuildOperator], + rhs: dict[str, SelectiveBuildOperator], +) -> dict[str, SelectiveBuildOperator]: + operators: dict[str, SelectiveBuildOperator] = {} + for op_name, op in list(lhs.items()) + list(rhs.items()): + new_op = op + if op_name in operators: + new_op = combine_operators(operators[op_name], op) + + operators[op_name] = new_op + + return operators + + +def strip_operator_overload_name(op_name: str) -> str: + return op_name.split(".")[0]