Add files using upload-large-folder tool

videollama2/lib/python3.10/site-packages/torch/ao/pruning/scheduler/base_scheduler.py

@@ -0,0 +1,159 @@
+
+from torch.ao.pruning import BaseSparsifier
+
+from functools import wraps
+import warnings
+import weakref
+
+__all__ = ["BaseScheduler"]
+
+class BaseScheduler:
+
+    def __init__(self, sparsifier, last_epoch=-1, verbose=False):
+
+        # Attach sparsifier
+        if not isinstance(sparsifier, BaseSparsifier):
+            raise TypeError(f'{type(sparsifier).__name__} is not an instance of torch.ao.pruning.BaseSparsifier')
+        self.sparsifier = sparsifier
+
+        # Initialize epoch and base sparsity levels
+
+        self.base_sl = [group['sparsity_level'] for group in sparsifier.groups]
+        self.last_epoch = last_epoch
+
+        # Following https://github.com/pytorch/pytorch/issues/20124
+        # We would like to ensure that `scheduler.step()` is called after
+        # `sparsifier.step()`
+        def with_counter(method):
+            if getattr(method, '_with_counter', False):
+                # `sparsifier.step()` has already been replaced, return.
+                return method
+
+            # Keep a weak reference to the sparsifier instance to prevent
+            # cyclic references.
+            instance_ref = weakref.ref(method.__self__)
+            # Get the unbound method for the same purpose.
+            func = method.__func__
+            cls = instance_ref().__class__
+            del method
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                instance = instance_ref()
+                instance._step_count += 1  # type: ignore[union-attr]
+                wrapped = func.__get__(instance, cls)
+                return wrapped(*args, **kwargs)
+
+            # Note that the returned function here is no longer a bound method,
+            # so attributes like `__func__` and `__self__` no longer exist.
+            wrapper._with_counter = True  # type: ignore[attr-defined]
+            return wrapper
+
+        self.sparsifier.step = with_counter(self.sparsifier.step)  # type: ignore[assignment]
+        self.sparsifier._step_count = 0  # type: ignore[attr-defined]
+        self._step_count: int = 0
+        self.verbose = verbose
+
+        # Housekeeping
+        self._get_sl_called_within_step: bool = False
+
+        self.step()
+
+    def state_dict(self):
+        """Returns the state of the scheduler as a :class:`dict`.
+
+        It contains an entry for every variable in self.__dict__ which
+        is not the sparsifier.
+        """
+        return {key: value for key, value in self.__dict__.items() if key != 'sparsifier'}
+
+    def load_state_dict(self, state_dict):
+        """Loads the schedulers state.
+
+        Args:
+            state_dict (dict): scheduler state. Should be an object returned
+                from a call to :meth:`state_dict`.
+        """
+        self.__dict__.update(state_dict)
+
+    def get_last_sl(self):
+        """ Return last computed sparsity level by current scheduler.
+        """
+        return self._last_sl
+
+    def get_sl(self):
+        # Compute sparsity level using chainable form of the scheduler
+        # Note: This method is not intended to be called directly, and is only
+        #       used by the ".step" method. Use .get_last_sl() instead.
+        if not self._get_sl_called_within_step:
+            warnings.warn(
+                "To get the last sparsity level computed by the scheduler, "
+                "please use `get_last_sl()`.")
+        raise NotImplementedError
+
+    def print_sl(self, is_verbose, group, sl, epoch=None):
+        """Display the current sparsity level.
+        """
+        if is_verbose:
+            if epoch is None:
+                print(f'Adjusting sparsity level of group {group} to {sl:.4e}.')
+            else:
+                print(f'Epoch {epoch:5d}: adjusting sparsity level of group {group} to {sl:.4e}.')
+
+    def __repr__(self):
+        format_string = self.__class__.__name__ + ' ('
+        format_string += '\n'
+        format_string += f'Sparsifier {self.sparsifier}\n'
+        format_string += f'    base_sl: {self.base_sl}\n'
+        format_string += ')'
+        return format_string
+
+    def step(self, epoch=None):
+        # Raise warning if trying to call scheduler step before the sparsifier.
+        # https://github.com/pytorch/pytorch/issues/20124
+        if self._step_count == 1:
+            if not hasattr(self.sparsifier.step, "_with_counter"):
+                warnings.warn("Seems like `sparsifier.step()` has been overridden after sparsity scheduler "
+                              "initialization. Please, make sure to call `sparsifier.step()` before "
+                              "`scheduler.step()`.", UserWarning)
+
+            # Just check if there were two first scheduler.step() calls before sparsifier.step()
+            elif self.sparsifier._step_count < 1:  # type: ignore[attr-defined]
+                warnings.warn("Detected call of `scheduler.step()` before `sparsifier.step()`. "
+                              "You have to make sure you run the sparsifier.step() BEFORE any "
+                              "calls to the scheduler.step().", UserWarning)
+        self._step_count += 1
+
+        class _enable_get_sl_call:
+
+            def __init__(self, o):
+                self.o = o
+
+            def __enter__(self):
+                self.o._get_sl_called_within_step = True
+                return self
+
+            def __exit__(self, type, value, traceback):
+                self.o._get_sl_called_within_step = False
+
+        with _enable_get_sl_call(self):
+            self.last_epoch += 1
+            values = self.get_sl()
+
+        for i, data in enumerate(zip(self.sparsifier.groups, values)):
+            param_group, sl = data
+            param_group['sparsity_level'] = sl
+            self.print_sl(self.verbose, i, sl, epoch)
+
+        self._last_sl = [group['sparsity_level'] for group in self.sparsifier.groups]
+        self.sparsifier.enable_mask_update = True
+
+    def _make_sure_a_list(self, var):
+        r"""Utility that extends it to the same length as the .groups, ensuring it is a list"""
+        n = len(self.sparsifier.groups)
+        if not isinstance(var, (list, tuple)):
+            return [var] * n
+        else:
+            if len(var) != n:
+                raise ValueError(f"Expected variable of length {n}, but got {len(var)}")
+            return list(var)  # We want the result to be in a list, not tuple

videollama2/lib/python3.10/site-packages/torch/ao/pruning/scheduler/cubic_scheduler.py

@@ -0,0 +1,107 @@
+import warnings
+
+from .base_scheduler import BaseScheduler
+
+__all__ = ["CubicSL"]
+
+def _clamp(x, lo, hi):
+    return max(lo, min(hi, x))
+
+
+class CubicSL(BaseScheduler):
+    r"""Sets the sparsity level of each parameter group to the final sl
+    plus a given exponential function.
+
+    .. math::
+
+        s_i = s_f + (s_0 - s_f) \cdot \left( 1 - \frac{t - t_0}{n\Delta t} \right)^3
+
+    where :math:`s_i` is the sparsity at epoch :math:`t`, :math;`s_f` is the final
+    sparsity level, :math:`f(i)` is the function to be applied to the current epoch
+    :math:`t`, initial epoch :math:`t_0`, and final epoch :math:`t_f`.
+    :math:`\Delta t` is used to control how often the update of the sparsity level
+    happens. By default,
+
+    Args:
+        sparsifier (BaseSparsifier): Wrapped sparsifier.
+        init_sl (int, list): Initial level of sparsity
+        init_t (int, list): Initial step, when pruning starts
+        delta_t (int, list): Pruning frequency
+        total_t (int, list): Total number of pruning steps
+        initially_zero (bool, list): If True, sets the level of sparsity to 0
+            before init_t (:math:`t_0`). Otherwise, the sparsity level before
+            init_t (:math:`t_0`) is set to init_sl(:math:`s_0`)
+        last_epoch (int): The index of last epoch. Default: -1.
+        verbose (bool): If ``True``, prints a message to stdout for
+            each update. Default: ``False``.
+    """
+    def __init__(self,
+                 sparsifier,
+                 init_sl=0.0,
+                 init_t=0,
+                 delta_t=10,
+                 total_t=100,
+                 initially_zero=False,
+                 last_epoch=-1,
+                 verbose=False
+                 ):
+        self.sparsifier = sparsifier
+
+        self.init_sl = self._make_sure_a_list(init_sl)
+        self.init_t = self._make_sure_a_list(init_t)
+        self.delta_t = self._make_sure_a_list(delta_t)
+        self.total_t = self._make_sure_a_list(total_t)
+
+        self.initially_zero = self._make_sure_a_list(initially_zero)
+
+        super().__init__(sparsifier, last_epoch, verbose)
+
+    @staticmethod
+    def sparsity_compute_fn(s_0, s_f, t, t_0, dt, n, initially_zero=False):
+        r""""Computes the current level of sparsity.
+
+        Based on https://arxiv.org/pdf/1710.01878.pdf
+
+        Args:
+            s_0: Initial level of sparsity, :math:`s_i`
+            s_f: Target level of sparsity, :math:`s_f`
+            t: Current step, :math:`t`
+            t_0: Initial step, :math:`t_0`
+            dt: Pruning frequency, :math:`\Delta T`
+            n: Pruning steps, :math:`n`
+            initially_zero: Sets the level of sparsity to 0 before t_0.
+                If False, sets to s_0
+
+        Returns:
+            The sparsity level :math:`s_t` at the current step :math:`t`
+        """
+        if initially_zero and t < t_0:
+            return 0
+        s_t = s_f + (s_0 - s_f) * (1.0 - (t - t_0) / (dt * n)) ** 3
+        s_t = _clamp(s_t, s_0, s_f)
+        return s_t
+
+    def get_sl(self):
+        if not self._get_sl_called_within_step:
+            warnings.warn(
+                "To get the last sparsity level computed by the scheduler, "
+                "please use `get_last_sl()`.")
+        return [
+            self.sparsity_compute_fn(
+                s_0=initial_sparsity,
+                s_f=final_sparsity,
+                t=self.last_epoch,
+                t_0=initial_epoch,
+                dt=delta_epoch,
+                n=interval_epochs,
+                initially_zero=initially_zero
+            ) for initial_sparsity, final_sparsity, initial_epoch, delta_epoch, interval_epochs, initially_zero in
+            zip(
+                self.init_sl,
+                self.base_sl,
+                self.init_t,
+                self.delta_t,
+                self.total_t,
+                self.initially_zero
+            )
+        ]

videollama2/lib/python3.10/site-packages/torch/ao/pruning/scheduler/lambda_scheduler.py

@@ -0,0 +1,47 @@
+import warnings
+
+from .base_scheduler import BaseScheduler
+
+__all__ = ["LambdaSL"]
+
+class LambdaSL(BaseScheduler):
+    """Sets the sparsity level of each parameter group to the final sl
+    times a given function. When last_epoch=-1, sets initial sl as zero.
+    Args:
+        sparsifier (BaseSparsifier): Wrapped sparsifier.
+        sl_lambda (function or list): A function which computes a multiplicative
+            factor given an integer parameter epoch, or a list of such
+            functions, one for each group in sparsifier.param_groups.
+        last_epoch (int): The index of last epoch. Default: -1.
+        verbose (bool): If ``True``, prints a message to stdout for
+            each update. Default: ``False``.
+    Example:
+        >>> # Assuming sparsifier has two groups.
+        >>> lambda1 = lambda epoch: epoch // 30
+        >>> lambda2 = lambda epoch: 0.95 ** epoch
+        >>> # xdoctest: +SKIP
+        >>> scheduler = LambdaSL(sparsifier, sl_lambda=[lambda1, lambda2])
+        >>> for epoch in range(100):
+        >>>     train(...)
+        >>>     validate(...)
+        >>>     scheduler.step()
+    """
+
+    def __init__(self, sparsifier, sl_lambda, last_epoch=-1, verbose=False):
+        self.sparsifier = sparsifier
+
+        if not isinstance(sl_lambda, list) and not isinstance(sl_lambda, tuple):
+            self.sl_lambdas = [sl_lambda] * len(sparsifier.groups)
+        else:
+            if len(sl_lambda) != len(sparsifier.groups):
+                raise ValueError(f"Expected {len(sparsifier.groups)} lr_lambdas, but got {len(sl_lambda)}")
+            self.sl_lambdas = list(sl_lambda)
+        super().__init__(sparsifier, last_epoch, verbose)
+
+    def get_sl(self):
+        if not self._get_sl_called_within_step:
+            warnings.warn(
+                "To get the last sparsity level computed by the scheduler, "
+                "please use `get_last_sl()`.")
+        return [base_sl * lmbda(self.last_epoch)
+                for lmbda, base_sl in zip(self.sl_lambdas, self.base_sl)]

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_lu_factor_ex_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 <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor> linalg_lu_factor_ex(const at::Tensor & A, bool pivot=true, bool check_errors=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> linalg_lu_factor_ex_out(at::Tensor & LU, at::Tensor & pivots, at::Tensor & info, const at::Tensor & A, bool pivot=true, bool check_errors=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> linalg_lu_factor_ex_outf(const at::Tensor & A, bool pivot, bool check_errors, at::Tensor & LU, at::Tensor & pivots, at::Tensor & info);
+
+} // namespace cuda
+} // namespace at

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

@@ -0,0 +1,97 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/new_ones_ops.h>
+
+namespace at {
+
+
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor new_ones(const at::Tensor & self, at::IntArrayRef size, at::TensorOptions options={}) {
+    return at::_ops::new_ones::call(self, c10::fromIntArrayRefSlow(size), optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+  }
+}
+
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor new_ones(const at::Tensor & self, at::IntArrayRef size, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::new_ones::call(self, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
+  }
+}
+
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor new_ones(const at::Tensor & self, c10::SymIntArrayRef size, at::TensorOptions options={}) {
+    return at::_ops::new_ones::call(self, size, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+  }
+}
+
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor new_ones(const at::Tensor & self, c10::SymIntArrayRef size, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::new_ones::call(self, size, dtype, layout, device, pin_memory);
+  }
+}
+
+// aten::new_ones.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & new_ones_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
+    return at::_ops::new_ones_out::call(self, c10::fromIntArrayRefSlow(size), out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & new_ones_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
+    return at::_ops::new_ones_out::call(self, c10::fromIntArrayRefSlow(size), out);
+  }
+}
+
+// aten::new_ones.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & new_ones_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
+    return at::_ops::new_ones_out::call(self, c10::fromIntArrayRefSlow(size), out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & new_ones_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
+    return at::_ops::new_ones_out::call(self, c10::fromIntArrayRefSlow(size), out);
+  }
+}
+
+// aten::new_ones.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & new_ones_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
+    return at::_ops::new_ones_out::call(self, size, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & new_ones_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
+    return at::_ops::new_ones_out::call(self, size, out);
+  }
+}
+
+// aten::new_ones.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & new_ones_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
+    return at::_ops::new_ones_out::call(self, size, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & new_ones_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
+    return at::_ops::new_ones_out::call(self, size, out);
+  }
+}
+
+}

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

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

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

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

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

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor to_sparse(const at::Tensor & self, int64_t sparse_dim);
+TORCH_API at::Tensor to_sparse(const at::Tensor & self, c10::optional<at::Layout> layout=c10::nullopt, at::OptionalIntArrayRef blocksize=c10::nullopt, c10::optional<int64_t> dense_dim=c10::nullopt);
+} // namespace native
+} // namespace at

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

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/unflatten_dense_tensors_ops.h>
+
+namespace at {
+
+
+// aten::unflatten_dense_tensors(Tensor flat, Tensor[] tensors) -> Tensor[]
+inline ::std::vector<at::Tensor> unflatten_dense_tensors(const at::Tensor & flat, at::TensorList tensors) {
+    return at::_ops::unflatten_dense_tensors::call(flat, tensors);
+}
+
+}

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

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

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/error/base.py

@@ -0,0 +1,42 @@
+from ..language.location import get_location
+
+
+class GraphQLError(Exception):
+    __slots__ = 'message', 'nodes', 'stack', 'original_error', '_source', '_positions'
+
+    def __init__(self, message, nodes=None, stack=None, source=None, positions=None):
+        super(GraphQLError, self).__init__(message)
+        self.message = message
+        self.nodes = nodes
+        self.stack = stack
+        self._source = source
+        self._positions = positions
+
+    @property
+    def source(self):
+        if self._source:
+            return self._source
+        if self.nodes:
+            node = self.nodes[0]
+            return node and node.loc and node.loc.source
+
+    @property
+    def positions(self):
+        if self._positions:
+            return self._positions
+        if self.nodes is not None:
+            node_positions = [node.loc and node.loc.start for node in self.nodes]
+            if any(node_positions):
+                return node_positions
+
+    def reraise(self):
+        if self.stack:
+            raise self.with_traceback(self.stack)
+        else:
+            raise self
+
+    @property
+    def locations(self):
+        source = self.source
+        if self.positions and source:
+            return [get_location(source, pos) for pos in self.positions]

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/__init__.py

@@ -0,0 +1,67 @@
+# flake8: noqa
+from .definition import (  # no import order
+    GraphQLScalarType,
+    GraphQLObjectType,
+    GraphQLField,
+    GraphQLArgument,
+    GraphQLInterfaceType,
+    GraphQLUnionType,
+    GraphQLEnumType,
+    GraphQLEnumValue,
+    GraphQLInputObjectType,
+    GraphQLInputObjectField,
+    GraphQLList,
+    GraphQLNonNull,
+    get_named_type,
+    is_abstract_type,
+    is_composite_type,
+    is_input_type,
+    is_leaf_type,
+    is_type,
+    get_nullable_type,
+    is_output_type
+)
+from .directives import (
+    # "Enum" of Directive locations
+    DirectiveLocation,
+
+    # Directive definition
+    GraphQLDirective,
+
+    # Built-in directives defined by the Spec
+    specified_directives,
+    GraphQLSkipDirective,
+    GraphQLIncludeDirective,
+    GraphQLDeprecatedDirective,
+
+    # Constant Deprecation Reason
+    DEFAULT_DEPRECATION_REASON,
+)
+from .scalars import (  # no import order
+    GraphQLInt,
+    GraphQLFloat,
+    GraphQLString,
+    GraphQLBoolean,
+    GraphQLID,
+)
+from .schema import GraphQLSchema
+
+from .introspection import (
+    # "Enum" of Type Kinds
+    TypeKind,
+
+    # GraphQL Types for introspection.
+    __Schema,
+    __Directive,
+    __DirectiveLocation,
+    __Type,
+    __Field,
+    __InputValue,
+    __EnumValue,
+    __TypeKind,
+
+    # Meta-field definitions.
+    SchemaMetaFieldDef,
+    TypeMetaFieldDef,
+    TypeNameMetaFieldDef
+)

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/definition.py

@@ -0,0 +1,619 @@
+from collections.abc import Mapping, Hashable
+import collections
+import copy
+
+from ..language import ast
+from ..pyutils.cached_property import cached_property
+from ..pyutils.ordereddict import OrderedDict
+from ..utils.assert_valid_name import assert_valid_name
+
+
+def is_type(type):
+    return isinstance(type, (
+        GraphQLScalarType,
+        GraphQLObjectType,
+        GraphQLInterfaceType,
+        GraphQLUnionType,
+        GraphQLEnumType,
+        GraphQLInputObjectType,
+        GraphQLList,
+        GraphQLNonNull
+    ))
+
+
+def is_input_type(type):
+    named_type = get_named_type(type)
+    return isinstance(named_type, (
+        GraphQLScalarType,
+        GraphQLEnumType,
+        GraphQLInputObjectType,
+    ))
+
+
+def is_output_type(type):
+    named_type = get_named_type(type)
+    return isinstance(named_type, (
+        GraphQLScalarType,
+        GraphQLObjectType,
+        GraphQLInterfaceType,
+        GraphQLUnionType,
+        GraphQLEnumType
+    ))
+
+
+def is_leaf_type(type):
+    return isinstance(type, (
+        GraphQLScalarType,
+        GraphQLEnumType,
+    ))
+
+
+def is_composite_type(type):
+    named_type = get_named_type(type)
+    return isinstance(named_type, (
+        GraphQLObjectType,
+        GraphQLInterfaceType,
+        GraphQLUnionType,
+    ))
+
+
+def is_abstract_type(type):
+    return isinstance(type, (
+        GraphQLInterfaceType,
+        GraphQLUnionType
+    ))
+
+
+def get_nullable_type(type):
+    if isinstance(type, GraphQLNonNull):
+        return type.of_type
+    return type
+
+
+def get_named_type(type):
+    unmodified_type = type
+    while isinstance(unmodified_type, (GraphQLList, GraphQLNonNull)):
+        unmodified_type = unmodified_type.of_type
+
+    return unmodified_type
+
+
+class GraphQLType(object):
+    __slots__ = 'name',
+
+    def __str__(self):
+        return self.name
+
+    def is_same_type(self, other):
+        return self.__class__ is other.__class__ and self.name == other.name
+
+
+def none_func(x):
+    None
+
+
+class GraphQLScalarType(GraphQLType):
+    """Scalar Type Definition
+
+    The leaf values of any request and input values to arguments are
+    Scalars (or Enums) and are defined with a name and a series of coercion
+    functions used to ensure validity.
+
+    Example:
+
+        def coerce_odd(value):
+            if value % 2 == 1:
+                return value
+            return None
+
+        OddType = GraphQLScalarType(name='Odd', serialize=coerce_odd)
+    """
+
+    __slots__ = 'name', 'description', 'serialize', 'parse_value', 'parse_literal'
+
+    def __init__(self, name, description=None, serialize=None, parse_value=None, parse_literal=None):
+        assert name, 'Type must be named.'
+        assert_valid_name(name)
+        self.name = name
+        self.description = description
+
+        assert callable(serialize), (
+            '{} must provide "serialize" function. If this custom Scalar is '
+            'also used as an input type, ensure "parse_value" and "parse_literal" '
+            'functions are also provided.'
+        ).format(self)
+
+        if parse_value is not None or parse_literal is not None:
+            assert callable(parse_value) and callable(parse_literal), (
+                '{} must provide both "parse_value" and "parse_literal" functions.'.format(self)
+            )
+
+        self.serialize = serialize
+        self.parse_value = parse_value or none_func
+        self.parse_literal = parse_literal or none_func
+
+    def __str__(self):
+        return self.name
+
+
+class GraphQLObjectType(GraphQLType):
+    """Object Type Definition
+
+    Almost all of the GraphQL types you define will be object types.
+    Object types have a name, but most importantly describe their fields.
+
+    Example:
+
+        AddressType = GraphQLObjectType('Address', {
+            'street': GraphQLField(GraphQLString),
+            'number': GraphQLField(GraphQLInt),
+            'formatted': GraphQLField(GraphQLString,
+                resolver=lambda obj, args, context, info: obj.number + ' ' + obj.street),
+        })
+
+    When two types need to refer to each other, or a type needs to refer to
+    itself in a field, you can use a static method to supply the fields
+    lazily.
+
+    Example:
+
+        PersonType = GraphQLObjectType('Person', lambda: {
+            'name': GraphQLField(GraphQLString),
+            'bestFriend': GraphQLField(PersonType)
+        })
+    """
+    def __init__(self, name, fields, interfaces=None, is_type_of=None, description=None):
+        assert name, 'Type must be named.'
+        assert_valid_name(name)
+        self.name = name
+        self.description = description
+
+        if is_type_of is not None:
+            assert callable(is_type_of), '{} must provide "is_type_of" as a function.'.format(self)
+
+        self.is_type_of = is_type_of
+        self._fields = fields
+        self._provided_interfaces = interfaces
+        self._interfaces = None
+
+    @cached_property
+    def fields(self):
+        return define_field_map(self, self._fields)
+
+    @cached_property
+    def interfaces(self):
+        return define_interfaces(self, self._provided_interfaces)
+
+
+def define_field_map(type, field_map):
+    if callable(field_map):
+        field_map = field_map()
+
+    assert isinstance(field_map, Mapping) and len(field_map) > 0, (
+        '{} fields must be a mapping (dict / OrderedDict) with field names as keys or a '
+        'function which returns such a mapping.'
+    ).format(type)
+
+    for field_name, field in field_map.items():
+        assert_valid_name(field_name)
+        field_args = getattr(field, 'args', None)
+
+        if field_args:
+            assert isinstance(field_args, Mapping), (
+                '{}.{} args must be a mapping (dict / OrderedDict) with argument names as keys.'.format(type,
+                                                                                                        field_name)
+            )
+
+            for arg_name, arg in field_args.items():
+                assert_valid_name(arg_name)
+
+    return OrderedDict(field_map)
+
+
+def define_interfaces(type, interfaces):
+    if callable(interfaces):
+        interfaces = interfaces()
+
+    if interfaces is None:
+        interfaces = []
+
+    assert isinstance(interfaces, (list, tuple)), (
+        '{} interfaces must be a list/tuple or a function which returns a list/tuple.'.format(type)
+    )
+
+    for interface in interfaces:
+        assert isinstance(interface, GraphQLInterfaceType), (
+            '{} may only implement Interface types, it cannot implement: {}.'.format(type, interface)
+        )
+
+        if not callable(interface.resolve_type):
+            assert callable(type.is_type_of), (
+                'Interface Type {} does not provide a "resolve_type" function '
+                'and implementing Type {} does not provide a "is_type_of" '
+                'function. There is no way to resolve this implementing type '
+                'during execution.'
+            ).format(interface, type)
+
+    return interfaces
+
+
+class GraphQLField(object):
+    __slots__ = 'type', 'args', 'resolver', 'deprecation_reason', 'description'
+
+    def __init__(self, type, args=None, resolver=None, deprecation_reason=None, description=None):
+        self.type = type
+        self.args = args or OrderedDict()
+        self.resolver = resolver
+        self.deprecation_reason = deprecation_reason
+        self.description = description
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLField) and
+                self.type == other.type and
+                self.args == other.args and
+                self.resolver == other.resolver and
+                self.deprecation_reason == other.deprecation_reason and
+                self.description == other.description
+            )
+        )
+
+    def __hash__(self):
+        return id(self)
+
+
+class GraphQLArgument(object):
+    __slots__ = 'type', 'default_value', 'description', 'out_name'
+
+    def __init__(self, type, default_value=None, description=None, out_name=None):
+        self.type = type
+        self.default_value = default_value
+        self.description = description
+        self.out_name = out_name
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLArgument) and
+                self.type == other.type and
+                self.default_value == other.default_value and
+                self.description == other.description and
+                self.out_name == other.out_name
+            )
+        )
+
+    def __hash__(self):
+        return id(self)
+
+
+class GraphQLInterfaceType(GraphQLType):
+    """Interface Type Definition
+
+    When a field can return one of a heterogeneous set of types, a Interface type is used to describe what types are possible,
+    what fields are in common across all types, as well as a function to determine which type is actually used when the field is resolved.
+
+    Example:
+
+        EntityType = GraphQLInterfaceType(
+            name='Entity',
+            fields={
+                'name': GraphQLField(GraphQLString),
+            })
+    """
+
+    def __init__(self, name, fields=None, resolve_type=None, description=None):
+        assert name, 'Type must be named.'
+        assert_valid_name(name)
+        self.name = name
+        self.description = description
+
+        if resolve_type is not None:
+            assert callable(resolve_type), '{} must provide "resolve_type" as a function.'.format(self)
+
+        self.resolve_type = resolve_type
+        self._fields = fields
+
+    @cached_property
+    def fields(self):
+        return define_field_map(self, self._fields)
+
+
+class GraphQLUnionType(GraphQLType):
+    """Union Type Definition
+
+    When a field can return one of a heterogeneous set of types, a Union type is used to describe what types are possible
+    as well as providing a function to determine which type is actually used when the field is resolved.
+
+    Example:
+
+        class PetType(GraphQLUnionType):
+            name = 'Pet'
+            types = [DogType, CatType]
+
+            def resolve_type(self, value):
+                if isinstance(value, Dog):
+                    return DogType()
+                if isinstance(value, Cat):
+                    return CatType()
+    """
+
+    def __init__(self, name, types=None, resolve_type=None, description=None):
+        assert name, 'Type must be named.'
+        assert_valid_name(name)
+        self.name = name
+        self.description = description
+
+        if resolve_type is not None:
+            assert callable(resolve_type), '{} must provide "resolve_type" as a function.'.format(self)
+
+        self.resolve_type = resolve_type
+        self._types = types
+
+    @cached_property
+    def types(self):
+        return define_types(self, self._types)
+
+
+def define_types(union_type, types):
+    if callable(types):
+        types = types()
+
+    assert isinstance(types, (list, tuple)) and len(
+        types) > 0, 'Must provide types for Union {}.'.format(union_type.name)
+    has_resolve_type_fn = callable(union_type.resolve_type)
+
+    for type in types:
+        assert isinstance(type, GraphQLObjectType), (
+            '{} may only contain Object types, it cannot contain: {}.'.format(union_type, type)
+        )
+
+        if not has_resolve_type_fn:
+            assert callable(type.is_type_of), (
+                'Union Type {} does not provide a "resolve_type" function '
+                'and possible Type {} does not provide a "is_type_of" '
+                'function. There is no way to resolve this possible type '
+                'during execution.'
+            ).format(union_type, type)
+
+    return types
+
+
+class GraphQLEnumType(GraphQLType):
+    """Enum Type Definition
+
+    Some leaf values of requests and input values are Enums. GraphQL serializes Enum values as strings,
+    however internally Enums can be represented by any kind of type, often integers.
+
+    Example:
+
+        RGBType = GraphQLEnumType(
+            name='RGB',
+            values=OrderedDict([
+                ('RED', GraphQLEnumValue(0)),
+                ('GREEN', GraphQLEnumValue(1)),
+                ('BLUE', GraphQLEnumValue(2))
+            ])
+        )
+
+    Note: If a value is not provided in a definition, the name of the enum value will be used as it's internal value.
+    """
+
+    def __init__(self, name, values, description=None):
+        assert name, 'Type must provide name.'
+        assert_valid_name(name)
+        self.name = name
+        self.description = description
+
+        self.values = define_enum_values(self, values)
+
+    def serialize(self, value):
+        if isinstance(value, Hashable):
+            enum_value = self._value_lookup.get(value)
+
+            if enum_value:
+                return enum_value.name
+
+        return None
+
+    def parse_value(self, value):
+        if isinstance(value, Hashable):
+            enum_value = self._name_lookup.get(value)
+
+            if enum_value:
+                return enum_value.value
+
+        return None
+
+    def parse_literal(self, value_ast):
+        if isinstance(value_ast, ast.EnumValue):
+            enum_value = self._name_lookup.get(value_ast.value)
+
+            if enum_value:
+                return enum_value.value
+
+    @cached_property
+    def _value_lookup(self):
+        return {value.value: value for value in self.values}
+
+    @cached_property
+    def _name_lookup(self):
+        return {value.name: value for value in self.values}
+
+
+def define_enum_values(type, value_map):
+    assert isinstance(value_map, Mapping) and len(value_map) > 0, (
+        '{} values must be a mapping (dict / OrderedDict) with value names as keys.'.format(type)
+    )
+
+    values = []
+    if not isinstance(value_map, (collections.OrderedDict, OrderedDict)):
+        value_map = OrderedDict(sorted(list(value_map.items())))
+
+    for value_name, value in value_map.items():
+        assert_valid_name(value_name)
+        assert isinstance(value, GraphQLEnumValue), (
+            '{}.{} must be an instance of GraphQLEnumValue, but got: {}'.format(type, value_name, value)
+        )
+        value = copy.copy(value)
+        value.name = value_name
+        if value.value is None:
+            value.value = value_name
+
+        values.append(value)
+
+    return values
+
+
+class GraphQLEnumValue(object):
+    __slots__ = 'name', 'value', 'deprecation_reason', 'description'
+
+    def __init__(self, value=None, deprecation_reason=None, description=None, name=None):
+        self.name = name
+        self.value = value
+        self.deprecation_reason = deprecation_reason
+        self.description = description
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLEnumValue) and
+                self.name == other.name and
+                self.value == other.value and
+                self.deprecation_reason == other.deprecation_reason and
+                self.description == other.description
+            )
+        )
+
+
+class GraphQLInputObjectType(GraphQLType):
+    """Input Object Type Definition
+
+    An input object defines a structured collection of fields which may be
+    supplied to a field argument.
+
+    Using `NonNull` will ensure that a value must be provided by the query
+
+    Example:
+
+        NonNullFloat = GraphQLNonNull(GraphQLFloat())
+
+        class GeoPoint(GraphQLInputObjectType):
+            name = 'GeoPoint'
+            fields = {
+                'lat': GraphQLInputObjectField(NonNullFloat),
+                'lon': GraphQLInputObjectField(NonNullFloat),
+                'alt': GraphQLInputObjectField(GraphQLFloat(),
+                    default_value=0)
+            }
+    """
+    def __init__(self, name, fields, description=None):
+        assert name, 'Type must be named.'
+        self.name = name
+        self.description = description
+
+        self._fields = fields
+
+    @cached_property
+    def fields(self):
+        return self._define_field_map()
+
+    def _define_field_map(self):
+        fields = self._fields
+        if callable(fields):
+            fields = fields()
+
+        assert isinstance(fields, Mapping) and len(fields) > 0, (
+            '{} fields must be a mapping (dict / OrderedDict) with field names as keys or a '
+            'function which returns such a mapping.'
+        ).format(self)
+        if not isinstance(fields, (collections.OrderedDict, OrderedDict)):
+            fields = OrderedDict(sorted(list(fields.items())))
+
+        for field_name, field in fields.items():
+            assert_valid_name(field_name)
+
+        return fields
+
+
+class GraphQLInputObjectField(object):
+    __slots__ = 'type', 'default_value', 'description', 'out_name'
+
+    def __init__(self, type, default_value=None, description=None, out_name=None):
+        self.type = type
+        self.default_value = default_value
+        self.description = description
+        self.out_name = out_name
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLInputObjectField) and
+                self.type == other.type and
+                self.description == other.description and
+                self.out_name == other.out_name
+            )
+        )
+
+
+class GraphQLList(GraphQLType):
+    """List Modifier
+
+    A list is a kind of type marker, a wrapping type which points to another
+    type. Lists are often created within the context of defining the fields
+    of an object type.
+
+    Example:
+
+        class PersonType(GraphQLObjectType):
+            name = 'Person'
+
+            def get_fields(self):
+                return {
+                    'parents': GraphQLField(GraphQLList(PersonType())),
+                    'children': GraphQLField(GraphQLList(PersonType())),
+                }
+    """
+    __slots__ = 'of_type',
+
+    def __init__(self, type):
+        assert is_type(type), 'Can only create List of a GraphQLType but got: {}.'.format(type)
+        self.of_type = type
+
+    def __str__(self):
+        return '[' + str(self.of_type) + ']'
+
+    def is_same_type(self, other):
+        return isinstance(other, GraphQLList) and self.of_type.is_same_type(other.of_type)
+
+
+class GraphQLNonNull(GraphQLType):
+    """Non-Null Modifier
+
+    A non-null is a kind of type marker, a wrapping type which points to another type. Non-null types enforce that their values are never null
+    and can ensure an error is raised if this ever occurs during a request. It is useful for fields which you can make a strong guarantee on
+    non-nullability, for example usually the id field of a database row will never be null.
+
+    Example:
+
+        class RowType(GraphQLObjectType):
+            name = 'Row'
+            fields = {
+                'id': GraphQLField(type=GraphQLNonNull(GraphQLString()))
+            }
+
+    Note: the enforcement of non-nullability occurs within the executor.
+    """
+    __slots__ = 'of_type',
+
+    def __init__(self, type):
+        assert is_type(type) and not isinstance(type, GraphQLNonNull), (
+            'Can only create NonNull of a Nullable GraphQLType but got: {}.'.format(type)
+        )
+        self.of_type = type
+
+    def __str__(self):
+        return str(self.of_type) + '!'
+
+    def is_same_type(self, other):
+        return isinstance(other, GraphQLNonNull) and self.of_type.is_same_type(other.of_type)

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/directives.py

@@ -0,0 +1,132 @@
+from collections.abc import Iterable, Mapping
+
+from ..pyutils.ordereddict import OrderedDict
+from ..utils.assert_valid_name import assert_valid_name
+from .definition import GraphQLArgument, GraphQLNonNull, is_input_type
+from .scalars import GraphQLBoolean, GraphQLString
+
+
+class DirectiveLocation(object):
+    # Operations
+    QUERY = 'QUERY'
+    MUTATION = 'MUTATION'
+    SUBSCRIPTION = 'SUBSCRIPTION'
+    FIELD = 'FIELD'
+    FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION'
+    FRAGMENT_SPREAD = 'FRAGMENT_SPREAD'
+    INLINE_FRAGMENT = 'INLINE_FRAGMENT'
+
+    # Schema Definitions
+    SCHEMA = 'SCHEMA'
+    SCALAR = 'SCALAR'
+    OBJECT = 'OBJECT'
+    FIELD_DEFINITION = 'FIELD_DEFINITION'
+    ARGUMENT_DEFINITION = 'ARGUMENT_DEFINITION'
+    INTERFACE = 'INTERFACE'
+    UNION = 'UNION'
+    ENUM = 'ENUM'
+    ENUM_VALUE = 'ENUM_VALUE'
+    INPUT_OBJECT = 'INPUT_OBJECT'
+    INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION'
+
+    OPERATION_LOCATIONS = [
+        QUERY,
+        MUTATION,
+        SUBSCRIPTION
+    ]
+
+    FRAGMENT_LOCATIONS = [
+        FRAGMENT_DEFINITION,
+        FRAGMENT_SPREAD,
+        INLINE_FRAGMENT
+    ]
+
+    FIELD_LOCATIONS = [
+        FIELD
+    ]
+
+
+class GraphQLDirective(object):
+    __slots__ = 'name', 'args', 'description', 'locations'
+
+    def __init__(self, name, description=None, args=None, locations=None):
+        assert name, 'Directive must be named.'
+        assert_valid_name(name)
+        assert isinstance(locations, Iterable), 'Must provide locations for directive.'
+
+        self.name = name
+        self.description = description
+        self.locations = locations
+
+        if args:
+            assert isinstance(args, Mapping), '{} args must be a dict with argument names as keys.'.format(name)
+            for arg_name, _arg in args.items():
+                assert_valid_name(arg_name)
+                assert is_input_type(_arg.type), '{}({}) argument type must be Input Type but got {}.'.format(
+                    name,
+                    arg_name,
+                    _arg.type)
+        self.args = args or OrderedDict()
+
+
+"""Used to conditionally include fields or fragments."""
+GraphQLIncludeDirective = GraphQLDirective(
+    name='include',
+    description='Directs the executor to include this field or fragment only when the `if` argument is true.',
+    args={
+        'if': GraphQLArgument(
+            type=GraphQLNonNull(GraphQLBoolean),
+            description='Included when true.',
+        ),
+    },
+    locations=[
+        DirectiveLocation.FIELD,
+        DirectiveLocation.FRAGMENT_SPREAD,
+        DirectiveLocation.INLINE_FRAGMENT,
+    ]
+)
+
+"""Used to conditionally skip (exclude) fields or fragments."""
+GraphQLSkipDirective = GraphQLDirective(
+    name='skip',
+    description='Directs the executor to skip this field or fragment when the `if` argument is true.',
+    args={
+        'if': GraphQLArgument(
+            type=GraphQLNonNull(GraphQLBoolean),
+            description='Skipped when true.',
+        ),
+    },
+    locations=[
+        DirectiveLocation.FIELD,
+        DirectiveLocation.FRAGMENT_SPREAD,
+        DirectiveLocation.INLINE_FRAGMENT,
+    ]
+)
+
+"""Constant string used for default reason for a deprecation."""
+DEFAULT_DEPRECATION_REASON = 'No longer supported'
+
+"""Used to declare element of a GraphQL schema as deprecated."""
+GraphQLDeprecatedDirective = GraphQLDirective(
+    name='deprecated',
+    description='Marks an element of a GraphQL schema as no longer supported.',
+    args={
+        'reason': GraphQLArgument(
+            type=GraphQLString,
+            description=('Explains why this element was deprecated, usually also including a suggestion for how to'
+                         'access supported similar data. Formatted in [Markdown]'
+                         '(https://daringfireball.net/projects/markdown/).'),
+            default_value=DEFAULT_DEPRECATION_REASON
+        ),
+    },
+    locations=[
+        DirectiveLocation.FIELD_DEFINITION,
+        DirectiveLocation.ENUM_VALUE,
+    ]
+)
+
+specified_directives = [
+    GraphQLIncludeDirective,
+    GraphQLSkipDirective,
+    GraphQLDeprecatedDirective
+]

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/introspection.py

@@ -0,0 +1,440 @@
+from collections import OrderedDict, namedtuple
+
+from ..language.printer import print_ast
+from ..utils.ast_from_value import ast_from_value
+from .definition import (GraphQLArgument, GraphQLEnumType, GraphQLEnumValue,
+                         GraphQLField, GraphQLInputObjectType,
+                         GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                         GraphQLObjectType, GraphQLScalarType,
+                         GraphQLUnionType)
+from .directives import DirectiveLocation
+from .scalars import GraphQLBoolean, GraphQLString
+
+InputField = namedtuple('InputField', ['name', 'description', 'type', 'default_value'])
+Field = namedtuple('Field', ['name', 'type', 'description', 'args', 'deprecation_reason'])
+
+
+def input_fields_to_list(input_fields):
+    fields = []
+    for field_name, field in input_fields.items():
+        fields.append(InputField(
+            name=field_name,
+            description=field.description,
+            type=field.type,
+            default_value=field.default_value))
+    return fields
+
+
+__Schema = GraphQLObjectType(
+    '__Schema',
+    description='A GraphQL Schema defines the capabilities of a GraphQL server. It '
+                'exposes all available types and directives on the server, as well as '
+                'the entry points for query, mutation and subscription operations.',
+    fields=lambda: OrderedDict([
+        ('types', GraphQLField(
+            description='A list of all types supported by this server.',
+            type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__Type))),
+            resolver=lambda schema, *_: schema.get_type_map().values(),
+        )),
+        ('queryType', GraphQLField(
+            description='The type that query operations will be rooted at.',
+            type=GraphQLNonNull(__Type),
+            resolver=lambda schema, *_: schema.get_query_type(),
+        )),
+        ('mutationType', GraphQLField(
+            description='If this server supports mutation, the type that '
+                        'mutation operations will be rooted at.',
+            type=__Type,
+            resolver=lambda schema, *_: schema.get_mutation_type(),
+        )),
+        ('subscriptionType', GraphQLField(
+            description='If this server support subscription, the type '
+                        'that subscription operations will be rooted at.',
+            type=__Type,
+            resolver=lambda schema, *_: schema.get_subscription_type(),
+        )),
+        ('directives', GraphQLField(
+            description='A list of all directives supported by this server.',
+            type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__Directive))),
+            resolver=lambda schema, *_: schema.get_directives(),
+        )),
+    ]))
+
+_on_operation_locations = set(DirectiveLocation.OPERATION_LOCATIONS)
+_on_fragment_locations = set(DirectiveLocation.FRAGMENT_LOCATIONS)
+_on_field_locations = set(DirectiveLocation.FIELD_LOCATIONS)
+
+__Directive = GraphQLObjectType(
+    '__Directive',
+    description='A Directive provides a way to describe alternate runtime execution and '
+                'type validation behavior in a GraphQL document.'
+                '\n\nIn some cases, you need to provide options to alter GraphQL\'s '
+                'execution behavior in ways field arguments will not suffice, such as '
+                'conditionally including or skipping a field. Directives provide this by '
+                'describing additional information to the executor.',
+    fields=lambda: OrderedDict([
+        ('name', GraphQLField(GraphQLNonNull(GraphQLString))),
+        ('description', GraphQLField(GraphQLString)),
+        ('locations', GraphQLField(
+            type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__DirectiveLocation))),
+        )),
+        ('args', GraphQLField(
+            type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue))),
+            resolver=lambda directive, *args: input_fields_to_list(directive.args),
+        )),
+        ('onOperation', GraphQLField(
+            type=GraphQLNonNull(GraphQLBoolean),
+            deprecation_reason='Use `locations`.',
+            resolver=lambda directive, *args: set(directive.locations) & _on_operation_locations,
+        )),
+        ('onFragment', GraphQLField(
+            type=GraphQLNonNull(GraphQLBoolean),
+            deprecation_reason='Use `locations`.',
+            resolver=lambda directive, *args: set(directive.locations) & _on_fragment_locations,
+        )),
+        ('onField', GraphQLField(
+            type=GraphQLNonNull(GraphQLBoolean),
+            deprecation_reason='Use `locations`.',
+            resolver=lambda directive, *args: set(directive.locations) & _on_field_locations,
+        ))
+    ]))
+
+__DirectiveLocation = GraphQLEnumType(
+    '__DirectiveLocation',
+    description=(
+        'A Directive can be adjacent to many parts of the GraphQL language, a ' +
+        '__DirectiveLocation describes one such possible adjacencies.'
+    ),
+    values=OrderedDict([
+        ('QUERY', GraphQLEnumValue(
+            DirectiveLocation.QUERY,
+            description='Location adjacent to a query operation.'
+        )),
+        ('MUTATION', GraphQLEnumValue(
+            DirectiveLocation.MUTATION,
+            description='Location adjacent to a mutation operation.'
+        )),
+        ('SUBSCRIPTION', GraphQLEnumValue(
+            DirectiveLocation.SUBSCRIPTION,
+            description='Location adjacent to a subscription operation.'
+        )),
+        ('FIELD', GraphQLEnumValue(
+            DirectiveLocation.FIELD,
+            description='Location adjacent to a field.'
+        )),
+        ('FRAGMENT_DEFINITION', GraphQLEnumValue(
+            DirectiveLocation.FRAGMENT_DEFINITION,
+            description='Location adjacent to a fragment definition.'
+        )),
+        ('FRAGMENT_SPREAD', GraphQLEnumValue(
+            DirectiveLocation.FRAGMENT_SPREAD,
+            description='Location adjacent to a fragment spread.'
+        )),
+        ('INLINE_FRAGMENT', GraphQLEnumValue(
+            DirectiveLocation.INLINE_FRAGMENT,
+            description='Location adjacent to an inline fragment.'
+        )),
+        ('SCHEMA', GraphQLEnumValue(
+            DirectiveLocation.SCHEMA,
+            description='Location adjacent to a schema definition.'
+        )),
+        ('SCALAR', GraphQLEnumValue(
+            DirectiveLocation.SCALAR,
+            description='Location adjacent to a scalar definition.'
+        )),
+        ('OBJECT', GraphQLEnumValue(
+            DirectiveLocation.OBJECT,
+            description='Location adjacent to an object definition.'
+        )),
+        ('FIELD_DEFINITION', GraphQLEnumValue(
+            DirectiveLocation.FIELD_DEFINITION,
+            description='Location adjacent to a field definition.'
+        )),
+        ('ARGUMENT_DEFINITION', GraphQLEnumValue(
+            DirectiveLocation.ARGUMENT_DEFINITION,
+            description='Location adjacent to an argument definition.'
+        )),
+        ('INTERFACE', GraphQLEnumValue(
+            DirectiveLocation.INTERFACE,
+            description='Location adjacent to an interface definition.'
+        )),
+        ('UNION', GraphQLEnumValue(
+            DirectiveLocation.UNION,
+            description='Location adjacent to a union definition.'
+        )),
+        ('ENUM', GraphQLEnumValue(
+            DirectiveLocation.ENUM,
+            description='Location adjacent to an enum definition.'
+        )),
+        ('ENUM_VALUE', GraphQLEnumValue(
+            DirectiveLocation.ENUM_VALUE,
+            description='Location adjacent to an enum value definition.'
+        )),
+        ('INPUT_OBJECT', GraphQLEnumValue(
+            DirectiveLocation.INPUT_OBJECT,
+            description='Location adjacent to an input object definition.'
+        )),
+        ('INPUT_FIELD_DEFINITION', GraphQLEnumValue(
+            DirectiveLocation.INPUT_FIELD_DEFINITION,
+            description='Location adjacent to an input object field definition.'
+        )),
+    ]))
+
+
+class TypeKind(object):
+    SCALAR = 'SCALAR'
+    OBJECT = 'OBJECT'
+    INTERFACE = 'INTERFACE'
+    UNION = 'UNION'
+    ENUM = 'ENUM'
+    INPUT_OBJECT = 'INPUT_OBJECT'
+    LIST = 'LIST'
+    NON_NULL = 'NON_NULL'
+
+
+class TypeFieldResolvers(object):
+    _kinds = (
+        (GraphQLScalarType, TypeKind.SCALAR),
+        (GraphQLObjectType, TypeKind.OBJECT),
+        (GraphQLInterfaceType, TypeKind.INTERFACE),
+        (GraphQLUnionType, TypeKind.UNION),
+        (GraphQLEnumType, TypeKind.ENUM),
+        (GraphQLInputObjectType, TypeKind.INPUT_OBJECT),
+        (GraphQLList, TypeKind.LIST),
+        (GraphQLNonNull, TypeKind.NON_NULL),
+    )
+
+    @classmethod
+    def kind(cls, type, *_):
+        for klass, kind in cls._kinds:
+            if isinstance(type, klass):
+                return kind
+
+        raise Exception('Unknown kind of type: {}'.format(type))
+
+    @staticmethod
+    def fields(type, args, *_):
+        if isinstance(type, (GraphQLObjectType, GraphQLInterfaceType)):
+            fields = []
+            include_deprecated = args.get('includeDeprecated')
+            for field_name, field in type.fields.items():
+                if field.deprecation_reason and not include_deprecated:
+                    continue
+                fields.append(Field(
+                    name=field_name,
+                    description=field.description,
+                    type=field.type,
+                    args=field.args,
+                    deprecation_reason=field.deprecation_reason
+                ))
+            return fields
+        return None
+
+    @staticmethod
+    def interfaces(type, *_):
+        if isinstance(type, GraphQLObjectType):
+            return type.interfaces
+
+    @staticmethod
+    def possible_types(type, args, context, info):
+        if isinstance(type, (GraphQLInterfaceType, GraphQLUnionType)):
+            return info.schema.get_possible_types(type)
+
+    @staticmethod
+    def enum_values(type, args, *_):
+        if isinstance(type, GraphQLEnumType):
+            values = type.values
+            if not args.get('includeDeprecated'):
+                values = [v for v in values if not v.deprecation_reason]
+
+            return values
+
+    @staticmethod
+    def input_fields(type, *_):
+        if isinstance(type, GraphQLInputObjectType):
+            return input_fields_to_list(type.fields)
+
+
+__Type = GraphQLObjectType(
+    '__Type',
+    description='The fundamental unit of any GraphQL Schema is the type. There are '
+                'many kinds of types in GraphQL as represented by the `__TypeKind` enum.'
+                '\n\nDepending on the kind of a type, certain fields describe '
+                'information about that type. Scalar types provide no information '
+                'beyond a name and description, while Enum types provide their values. '
+                'Object and Interface types provide the fields they describe. Abstract '
+                'types, Union and Interface, provide the Object types possible '
+                'at runtime. List and NonNull types compose other types.',
+    fields=lambda: OrderedDict([
+        ('kind', GraphQLField(
+            type=GraphQLNonNull(__TypeKind),
+            resolver=TypeFieldResolvers.kind
+        )),
+        ('name', GraphQLField(GraphQLString)),
+        ('description', GraphQLField(GraphQLString)),
+        ('fields', GraphQLField(
+            type=GraphQLList(GraphQLNonNull(__Field)),
+            args={
+                'includeDeprecated': GraphQLArgument(
+                    GraphQLBoolean,
+                    default_value=False
+                )
+            },
+            resolver=TypeFieldResolvers.fields
+        )),
+        ('interfaces', GraphQLField(
+            type=GraphQLList(GraphQLNonNull(__Type)),
+            resolver=TypeFieldResolvers.interfaces
+        )),
+        ('possibleTypes', GraphQLField(
+            type=GraphQLList(GraphQLNonNull(__Type)),
+            resolver=TypeFieldResolvers.possible_types
+        )),
+        ('enumValues', GraphQLField(
+            type=GraphQLList(GraphQLNonNull(__EnumValue)),
+            args={
+                'includeDeprecated': GraphQLArgument(
+                    GraphQLBoolean,
+                    default_value=False
+                )
+            },
+            resolver=TypeFieldResolvers.enum_values
+        )),
+        ('inputFields', GraphQLField(
+            type=GraphQLList(GraphQLNonNull(__InputValue)),
+            resolver=TypeFieldResolvers.input_fields
+        )),
+        ('ofType', GraphQLField(
+            type=__Type,
+            resolver=lambda type, *_: getattr(type, 'of_type', None)
+        )),
+    ]))
+
+__Field = GraphQLObjectType(
+    '__Field',
+    description='Object and Interface types are described by a list of Fields, each of '
+                'which has a name, potentially a list of arguments, and a return type.',
+    fields=lambda: OrderedDict([
+        ('name', GraphQLField(GraphQLNonNull(GraphQLString))),
+        ('description', GraphQLField(GraphQLString)),
+        ('args', GraphQLField(
+            type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue))),
+            resolver=lambda field, *_: input_fields_to_list(field.args)
+        )),
+        ('type', GraphQLField(GraphQLNonNull(__Type))),
+        ('isDeprecated', GraphQLField(
+            type=GraphQLNonNull(GraphQLBoolean),
+            resolver=lambda field, *_: bool(field.deprecation_reason)
+        )),
+        ('deprecationReason', GraphQLField(
+            type=GraphQLString,
+            resolver=lambda field, *_: field.deprecation_reason
+        ))
+    ])
+)
+
+__InputValue = GraphQLObjectType(
+    '__InputValue',
+    description='Arguments provided to Fields or Directives and the input fields of an '
+                'InputObject are represented as Input Values which describe their type '
+                'and optionally a default value.',
+    fields=lambda: OrderedDict([
+        ('name', GraphQLField(GraphQLNonNull(GraphQLString))),
+        ('description', GraphQLField(GraphQLString)),
+        ('type', GraphQLField(GraphQLNonNull(__Type))),
+        ('defaultValue', GraphQLField(
+            type=GraphQLString,
+            resolver=lambda input_val, *_:
+            None if input_val.default_value is None
+            else print_ast(ast_from_value(input_val.default_value, input_val))
+        ))
+    ]))
+
+__EnumValue = GraphQLObjectType(
+    '__EnumValue',
+    description='One possible value for a given Enum. Enum values are unique values, not '
+                'a placeholder for a string or numeric value. However an Enum value is '
+                'returned in a JSON response as a string.',
+    fields=lambda: OrderedDict([
+        ('name', GraphQLField(GraphQLNonNull(GraphQLString))),
+        ('description', GraphQLField(GraphQLString)),
+        ('isDeprecated', GraphQLField(
+            type=GraphQLNonNull(GraphQLBoolean),
+            resolver=lambda field, *_: bool(field.deprecation_reason)
+        )),
+        ('deprecationReason', GraphQLField(
+            type=GraphQLString,
+            resolver=lambda enum_value, *_: enum_value.deprecation_reason,
+        ))
+    ]))
+
+__TypeKind = GraphQLEnumType(
+    '__TypeKind',
+    description='An enum describing what kind of type a given `__Type` is',
+    values=OrderedDict([
+        ('SCALAR', GraphQLEnumValue(
+            TypeKind.SCALAR,
+            description='Indicates this type is a scalar.'
+        )),
+        ('OBJECT', GraphQLEnumValue(
+            TypeKind.OBJECT,
+            description='Indicates this type is an object. '
+                        '`fields` and `interfaces` are valid fields.'
+        )),
+        ('INTERFACE', GraphQLEnumValue(
+            TypeKind.INTERFACE,
+            description='Indicates this type is an interface. '
+                        '`fields` and `possibleTypes` are valid fields.'
+        )),
+        ('UNION', GraphQLEnumValue(
+            TypeKind.UNION,
+            description='Indicates this type is a union. '
+                        '`possibleTypes` is a valid field.'
+        )),
+        ('ENUM', GraphQLEnumValue(
+            TypeKind.ENUM,
+            description='Indicates this type is an enum. '
+                        '`enumValues` is a valid field.'
+        )),
+        ('INPUT_OBJECT', GraphQLEnumValue(
+            TypeKind.INPUT_OBJECT,
+            description='Indicates this type is an input object. '
+                        '`inputFields` is a valid field.'
+        )),
+        ('LIST', GraphQLEnumValue(
+            TypeKind.LIST,
+            description='Indicates this type is a list. '
+                        '`ofType` is a valid field.'
+        )),
+        ('NON_NULL', GraphQLEnumValue(
+            TypeKind.NON_NULL,
+            description='Indicates this type is a non-null. '
+                        '`ofType` is a valid field.'
+        )),
+    ]))
+
+IntrospectionSchema = __Schema
+
+SchemaMetaFieldDef = GraphQLField(
+    # name='__schema',
+    type=GraphQLNonNull(__Schema),
+    description='Access the current type schema of this server.',
+    resolver=lambda source, args, context, info: info.schema,
+    args={}
+)
+
+TypeMetaFieldDef = GraphQLField(
+    type=__Type,
+    # name='__type',
+    description='Request the type information of a single type.',
+    args={'name': GraphQLArgument(GraphQLNonNull(GraphQLString))},
+    resolver=lambda source, args, context, info: info.schema.get_type(args['name'])
+)
+
+TypeNameMetaFieldDef = GraphQLField(
+    type=GraphQLNonNull(GraphQLString),
+    # name='__typename',
+    description='The name of the current Object type at runtime.',
+    resolver=lambda source, args, context, info: info.parent_type.name,
+    args={}
+)

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/scalars.py

@@ -0,0 +1,131 @@
+from ..language.ast import BooleanValue, FloatValue, IntValue, StringValue
+from .definition import GraphQLScalarType
+
+# As per the GraphQL Spec, Integers are only treated as valid when a valid
+# 32-bit signed integer, providing the broadest support across platforms.
+#
+# n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
+# they are internally represented as IEEE 754 doubles.
+MAX_INT = 2147483647
+MIN_INT = -2147483648
+
+
+def coerce_int(value):
+    if isinstance(value, int):
+        num = value
+    else:
+        try:
+            num = int(value)
+        except ValueError:
+            num = int(float(value))
+    if MIN_INT <= num <= MAX_INT:
+        return num
+    raise Exception((
+        "Int cannot represent non 32-bit signed integer value: {}"
+    ).format(value))
+
+
+def parse_int_literal(ast):
+    if isinstance(ast, IntValue):
+        num = int(ast.value)
+        if MIN_INT <= num <= MAX_INT:
+            return num
+
+
+GraphQLInt = GraphQLScalarType(
+    name='Int',
+    description='The `Int` scalar type represents non-fractional signed whole numeric '
+                'values. Int can represent values between -(2^53 - 1) and 2^53 - 1 since '
+                'represented in JSON as double-precision floating point numbers specified'
+                'by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point).',
+    serialize=coerce_int,
+    parse_value=coerce_int,
+    parse_literal=parse_int_literal)
+
+
+def coerce_float(value):
+    if isinstance(value, float):
+        return value
+    return float(value)
+
+
+def parse_float_literal(ast):
+    if isinstance(ast, (FloatValue, IntValue)):
+        return float(ast.value)
+    return None
+
+
+GraphQLFloat = GraphQLScalarType(
+    name='Float',
+    description='The `Float` scalar type represents signed double-precision fractional '
+                'values as specified by '
+                '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ',
+    serialize=coerce_float,
+    parse_value=coerce_float,
+    parse_literal=parse_float_literal)
+
+
+def coerce_string(value):
+    if isinstance(value, str):
+        return value
+
+    if isinstance(value, bool):
+        return u'true' if value else u'false'
+
+    return str(value)
+
+
+def coerce_str(value):
+    if isinstance(value, str):
+        return value
+
+    return str(value)
+
+
+def parse_string_literal(ast):
+    if isinstance(ast, StringValue):
+        return ast.value
+
+    return None
+
+
+GraphQLString = GraphQLScalarType(
+    name='String',
+    description='The `String` scalar type represents textual data, represented as UTF-8 '
+                'character sequences. The String type is most often used by GraphQL to '
+                'represent free-form human-readable text.',
+    serialize=coerce_string,
+    parse_value=coerce_string,
+    parse_literal=parse_string_literal)
+
+
+def parse_boolean_literal(ast):
+    if isinstance(ast, BooleanValue):
+        return ast.value
+    return None
+
+
+GraphQLBoolean = GraphQLScalarType(
+    name='Boolean',
+    description='The `Boolean` scalar type represents `true` or `false`.',
+    serialize=bool,
+    parse_value=bool,
+    parse_literal=parse_boolean_literal)
+
+
+def parse_id_literal(ast):
+    if isinstance(ast, (StringValue, IntValue)):
+        return ast.value
+    return None
+
+
+GraphQLID = GraphQLScalarType(
+    name='ID',
+    description='The `ID` scalar type represents a unique identifier, often used to '
+                'refetch an object or as key for a cache. The ID type appears in a JSON '
+                'response as a String; however, it is not intended to be human-readable. '
+                'When expected as an input type, any string (such as `"4"`) or integer '
+                '(such as `4`) input value will be accepted as an ID.',
+    serialize=coerce_str,
+    parse_value=coerce_str,
+    parse_literal=parse_id_literal)

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/schema.py

@@ -0,0 +1,100 @@
+from collections.abc import Iterable
+
+from .definition import GraphQLObjectType
+from .directives import GraphQLDirective, specified_directives
+from .introspection import IntrospectionSchema
+from .typemap import GraphQLTypeMap
+
+
+class GraphQLSchema(object):
+    """Schema Definition
+
+    A Schema is created by supplying the root types of each type of operation, query and mutation (optional).
+    A schema definition is then supplied to the validator and executor.
+
+    Example:
+
+        MyAppSchema = GraphQLSchema(
+            query=MyAppQueryRootType,
+            mutation=MyAppMutationRootType,
+        )
+
+    Note: If an array of `directives` are provided to GraphQLSchema, that will be
+    the exact list of directives represented and allowed. If `directives` is not
+    provided then a default set of the specified directives (e.g. @include and
+    @skip) will be used. If you wish to provide *additional* directives to these
+    specified directives, you must explicitly declare them. Example:
+
+      MyAppSchema = GraphQLSchema(
+          ...
+          directives=specified_directives.extend([MyCustomerDirective]),
+      )
+    """
+    __slots__ = '_query', '_mutation', '_subscription', '_type_map', '_directives', '_implementations', '_possible_type_map'
+
+    def __init__(self, query, mutation=None, subscription=None, directives=None, types=None):
+        assert isinstance(query, GraphQLObjectType), 'Schema query must be Object Type but got: {}.'.format(query)
+        if mutation:
+            assert isinstance(mutation, GraphQLObjectType), \
+                'Schema mutation must be Object Type but got: {}.'.format(mutation)
+
+        if subscription:
+            assert isinstance(subscription, GraphQLObjectType), \
+                'Schema subscription must be Object Type but got: {}.'.format(subscription)
+
+        if types:
+            assert isinstance(types, Iterable), \
+                'Schema types must be iterable if provided but got: {}.'.format(types)
+
+        self._query = query
+        self._mutation = mutation
+        self._subscription = subscription
+        if directives is None:
+            directives = specified_directives
+
+        assert all(isinstance(d, GraphQLDirective) for d in directives), \
+            'Schema directives must be List[GraphQLDirective] if provided but got: {}.'.format(
+                directives
+        )
+        self._directives = directives
+
+        initial_types = [
+            query,
+            mutation,
+            subscription,
+            IntrospectionSchema
+        ]
+        if types:
+            initial_types += types
+        self._type_map = GraphQLTypeMap(initial_types)
+
+    def get_query_type(self):
+        return self._query
+
+    def get_mutation_type(self):
+        return self._mutation
+
+    def get_subscription_type(self):
+        return self._subscription
+
+    def get_type_map(self):
+        return self._type_map
+
+    def get_type(self, name):
+        return self._type_map.get(name)
+
+    def get_directives(self):
+        return self._directives
+
+    def get_directive(self, name):
+        for directive in self.get_directives():
+            if directive.name == name:
+                return directive
+
+        return None
+
+    def get_possible_types(self, abstract_type):
+        return self._type_map.get_possible_types(abstract_type)
+
+    def is_possible_type(self, abstract_type, possible_type):
+        return self._type_map.is_possible_type(abstract_type, possible_type)

vllm/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/type/typemap.py

@@ -0,0 +1,145 @@
+from collections import OrderedDict, defaultdict
+from collections.abc import Sequence
+from functools import reduce
+
+from ..utils.type_comparators import is_equal_type, is_type_sub_type_of
+from .definition import (GraphQLArgument, GraphQLField,
+                         GraphQLInputObjectField, GraphQLInputObjectType,
+                         GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                         GraphQLObjectType, GraphQLUnionType, is_input_type,
+                         is_output_type)
+
+
+class GraphQLTypeMap(OrderedDict):
+
+    def __init__(self, types):
+        super(GraphQLTypeMap, self).__init__()
+        self.update(reduce(self.reducer, types, OrderedDict()))
+        self._possible_type_map = defaultdict(set)
+
+        # Keep track of all implementations by interface name.
+        self._implementations = {}
+        for gql_type in self.values():
+            if isinstance(gql_type, GraphQLObjectType):
+                for interface in gql_type.interfaces:
+                    self._implementations.setdefault(interface.name, []).append(gql_type)
+
+        # Enforce correct interface implementations.
+        for type in self.values():
+            if isinstance(type, GraphQLObjectType):
+                for interface in type.interfaces:
+                    self.assert_object_implements_interface(self, type, interface)
+
+    def get_possible_types(self, abstract_type):
+        if isinstance(abstract_type, GraphQLUnionType):
+            return abstract_type.types
+        assert isinstance(abstract_type, GraphQLInterfaceType)
+        return self._implementations.get(abstract_type.name, None)
+
+    def is_possible_type(self, abstract_type, possible_type):
+        possible_types = self.get_possible_types(abstract_type)
+        assert isinstance(possible_types, Sequence), (
+            'Could not find possible implementing types for ${} in ' +
+            'schema. Check that schema.types is defined and is an array of' +
+            'all possible types in the schema.'
+            ).format(abstract_type)
+
+        if not self._possible_type_map[abstract_type.name]:
+            self._possible_type_map[abstract_type.name].update([p.name for p in possible_types])
+
+        return possible_type.name in self._possible_type_map[abstract_type.name]
+
+    @classmethod
+    def reducer(cls, map, type):
+        if not type:
+            return map
+
+        if isinstance(type, GraphQLList) or isinstance(type, GraphQLNonNull):
+            return cls.reducer(map, type.of_type)
+
+        if type.name in map:
+            assert map[type.name] == type, (
+                'Schema must contain unique named types but contains multiple types named "{}".'
+            ).format(type.name)
+
+            return map
+
+        map[type.name] = type
+
+        reduced_map = map
+
+        if isinstance(type, (GraphQLUnionType)):
+            for t in type.types:
+                reduced_map = cls.reducer(reduced_map, t)
+
+        if isinstance(type, GraphQLObjectType):
+            for t in type.interfaces:
+                reduced_map = cls.reducer(reduced_map, t)
+
+        if isinstance(type, (GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType)):
+            field_map = type.fields
+            type_is_input = isinstance(type, GraphQLInputObjectType)
+            for field_name, field in field_map.items():
+                if type_is_input:
+                    assert isinstance(field, GraphQLInputObjectField), (
+                        '{}.{} must be an instance of GraphQLInputObjectField.'.format(type, field_name)
+                    )
+                    assert is_input_type(field.type), (
+                        '{}.{} field type must be Input Type but got: {}.'.format(type, field_name, field.type)
+                    )
+                else:
+                    assert isinstance(field, (GraphQLField, GraphQLField)), (
+                        '{}.{} must be an instance of GraphQLField.'.format(type, field_name)
+                    )
+                    assert is_output_type(field.type), (
+                        '{}.{} field type must be Output Type but got: {}.'.format(type, field_name, field.type)
+                    )
+                    for arg_name, arg in field.args.items():
+                        assert isinstance(arg, (GraphQLArgument, GraphQLArgument)), (
+                            '{}.{}({}:) argument must be an instance of GraphQLArgument.'.format(type, field_name, arg_name)
+                        )
+                        assert is_input_type(arg.type), (
+                            '{}.{}({}:) argument type must be Input Type but got: {}.'.format(type, field_name, arg_name,
+                                                                                              arg.type)
+                        )
+                        reduced_map = cls.reducer(reduced_map, arg.type)
+
+                reduced_map = cls.reducer(reduced_map, getattr(field, 'type', None))
+
+        return reduced_map
+
+    @classmethod
+    def assert_object_implements_interface(cls, schema, object, interface):
+        object_field_map = object.fields
+        interface_field_map = interface.fields
+
+        for field_name, interface_field in interface_field_map.items():
+            object_field = object_field_map.get(field_name)
+
+            assert object_field, '"{}" expects field "{}" but "{}" does not provide it.'.format(
+                interface, field_name, object
+            )
+
+            assert is_type_sub_type_of(schema, object_field.type, interface_field.type), (
+                '{}.{} expects type "{}" but {}.{} provides type "{}".'
+            ).format(interface, field_name, interface_field.type, object, field_name, object_field.type)
+
+            for arg_name, interface_arg in interface_field.args.items():
+                object_arg = object_field.args.get(arg_name)
+
+                assert object_arg, (
+                    '{}.{} expects argument "{}" but {}.{} does not provide it.'
+                ).format(interface, field_name, arg_name, object, field_name)
+
+                assert is_equal_type(interface_arg.type, object_arg.type), (
+                    '{}.{}({}:) expects type "{}" but {}.{}({}:) provides type "{}".'
+                ).format(interface, field_name, arg_name, interface_arg.type, object, field_name, arg_name, object_arg.type)
+
+            for arg_name, object_arg in object_field.args.items():
+                interface_arg = interface_field.args.get(arg_name)
+                if not interface_arg:
+                    assert not isinstance(object_arg.type, GraphQLNonNull), (
+                        '{}.{}({}:) is of required type '
+                        '"{}" but is not also provided by the '
+                        'interface {}.{}.'
+                    ).format(object, field_name, arg_name, object_arg.type, interface, field_name)

vllm/lib/python3.10/site-packages/wandb/vendor/watchdog_0_9_0/wandb_watchdog/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+#
+# 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.

vllm/lib/python3.10/site-packages/wandb/vendor/watchdog_0_9_0/wandb_watchdog/events.py

@@ -0,0 +1,615 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+#
+# 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.
+
+"""
+:module: watchdog.events
+:synopsis: File system events and event handlers.
+:author: yesudeep@google.com (Yesudeep Mangalapilly)
+
+Event Classes
+-------------
+.. autoclass:: FileSystemEvent
+   :members:
+   :show-inheritance:
+   :inherited-members:
+
+.. autoclass:: FileSystemMovedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: FileMovedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: DirMovedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: FileModifiedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: DirModifiedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: FileCreatedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: DirCreatedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: FileDeletedEvent
+   :members:
+   :show-inheritance:
+
+.. autoclass:: DirDeletedEvent
+   :members:
+   :show-inheritance:
+
+
+Event Handler Classes
+---------------------
+.. autoclass:: FileSystemEventHandler
+   :members:
+   :show-inheritance:
+
+.. autoclass:: PatternMatchingEventHandler
+   :members:
+   :show-inheritance:
+
+.. autoclass:: RegexMatchingEventHandler
+   :members:
+   :show-inheritance:
+
+.. autoclass:: LoggingEventHandler
+   :members:
+   :show-inheritance:
+
+"""
+
+import os.path
+import logging
+import re
+from .patterns import match_any_paths
+from wandb_watchdog.utils import has_attribute
+from wandb_watchdog.utils import unicode_paths
+
+
+EVENT_TYPE_MOVED = 'moved'
+EVENT_TYPE_DELETED = 'deleted'
+EVENT_TYPE_CREATED = 'created'
+EVENT_TYPE_MODIFIED = 'modified'
+
+
+class FileSystemEvent(object):
+    """
+    Immutable type that represents a file system event that is triggered
+    when a change occurs on the monitored file system.
+
+    All FileSystemEvent objects are required to be immutable and hence
+    can be used as keys in dictionaries or be added to sets.
+    """
+
+    event_type = None
+    """The type of the event as a string."""
+
+    is_directory = False
+    """True if event was emitted for a directory; False otherwise."""
+
+    def __init__(self, src_path):
+        self._src_path = src_path
+
+    @property
+    def src_path(self):
+        """Source path of the file system object that triggered this event."""
+        return self._src_path
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return ("<%(class_name)s: event_type=%(event_type)s, "
+                "src_path=%(src_path)r, "
+                "is_directory=%(is_directory)s>"
+                ) % (dict(
+                     class_name=self.__class__.__name__,
+                     event_type=self.event_type,
+                     src_path=self.src_path,
+                     is_directory=self.is_directory))
+
+    # Used for comparison of events.
+    @property
+    def key(self):
+        return (self.event_type, self.src_path, self.is_directory)
+
+    def __eq__(self, event):
+        return self.key == event.key
+
+    def __ne__(self, event):
+        return self.key != event.key
+
+    def __hash__(self):
+        return hash(self.key)
+
+
+class FileSystemMovedEvent(FileSystemEvent):
+    """
+    File system event representing any kind of file system movement.
+    """
+
+    event_type = EVENT_TYPE_MOVED
+
+    def __init__(self, src_path, dest_path):
+        super(FileSystemMovedEvent, self).__init__(src_path)
+        self._dest_path = dest_path
+
+    @property
+    def dest_path(self):
+        """The destination path of the move event."""
+        return self._dest_path
+
+    # Used for hashing this as an immutable object.
+    @property
+    def key(self):
+        return (self.event_type, self.src_path, self.dest_path, self.is_directory)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r, "
+                "dest_path=%(dest_path)r, "
+                "is_directory=%(is_directory)s>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path,
+                          dest_path=self.dest_path,
+                          is_directory=self.is_directory))
+
+
+# File events.
+
+
+class FileDeletedEvent(FileSystemEvent):
+    """File system event representing file deletion on the file system."""
+
+    event_type = EVENT_TYPE_DELETED
+
+    def __init__(self, src_path):
+        super(FileDeletedEvent, self).__init__(src_path)
+
+    def __repr__(self):
+        return "<%(class_name)s: src_path=%(src_path)r>" %\
+               dict(class_name=self.__class__.__name__,
+                    src_path=self.src_path)
+
+
+class FileModifiedEvent(FileSystemEvent):
+    """File system event representing file modification on the file system."""
+
+    event_type = EVENT_TYPE_MODIFIED
+
+    def __init__(self, src_path):
+        super(FileModifiedEvent, self).__init__(src_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path))
+
+
+class FileCreatedEvent(FileSystemEvent):
+    """File system event representing file creation on the file system."""
+
+    event_type = EVENT_TYPE_CREATED
+
+    def __init__(self, src_path):
+        super(FileCreatedEvent, self).__init__(src_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path))
+
+
+class FileMovedEvent(FileSystemMovedEvent):
+    """File system event representing file movement on the file system."""
+
+    def __init__(self, src_path, dest_path):
+        super(FileMovedEvent, self).__init__(src_path, dest_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r, "
+                "dest_path=%(dest_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path,
+                          dest_path=self.dest_path))
+
+
+# Directory events.
+
+
+class DirDeletedEvent(FileSystemEvent):
+    """File system event representing directory deletion on the file system."""
+
+    event_type = EVENT_TYPE_DELETED
+    is_directory = True
+
+    def __init__(self, src_path):
+        super(DirDeletedEvent, self).__init__(src_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path))
+
+
+class DirModifiedEvent(FileSystemEvent):
+    """
+    File system event representing directory modification on the file system.
+    """
+
+    event_type = EVENT_TYPE_MODIFIED
+    is_directory = True
+
+    def __init__(self, src_path):
+        super(DirModifiedEvent, self).__init__(src_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path))
+
+
+class DirCreatedEvent(FileSystemEvent):
+    """File system event representing directory creation on the file system."""
+
+    event_type = EVENT_TYPE_CREATED
+    is_directory = True
+
+    def __init__(self, src_path):
+        super(DirCreatedEvent, self).__init__(src_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path))
+
+
+class DirMovedEvent(FileSystemMovedEvent):
+    """File system event representing directory movement on the file system."""
+
+    is_directory = True
+
+    def __init__(self, src_path, dest_path):
+        super(DirMovedEvent, self).__init__(src_path, dest_path)
+
+    def __repr__(self):
+        return ("<%(class_name)s: src_path=%(src_path)r, "
+                "dest_path=%(dest_path)r>"
+                ) % (dict(class_name=self.__class__.__name__,
+                          src_path=self.src_path,
+                          dest_path=self.dest_path))
+
+
+class FileSystemEventHandler(object):
+    """
+    Base file system event handler that you can override methods from.
+    """
+
+    def dispatch(self, event):
+        """Dispatches events to the appropriate methods.
+
+        :param event:
+            The event object representing the file system event.
+        :type event:
+            :class:`FileSystemEvent`
+        """
+        self.on_any_event(event)
+        _method_map = {
+            EVENT_TYPE_MODIFIED: self.on_modified,
+            EVENT_TYPE_MOVED: self.on_moved,
+            EVENT_TYPE_CREATED: self.on_created,
+            EVENT_TYPE_DELETED: self.on_deleted,
+        }
+        event_type = event.event_type
+        _method_map[event_type](event)
+
+    def on_any_event(self, event):
+        """Catch-all event handler.
+
+        :param event:
+            The event object representing the file system event.
+        :type event:
+            :class:`FileSystemEvent`
+        """
+
+    def on_moved(self, event):
+        """Called when a file or a directory is moved or renamed.
+
+        :param event:
+            Event representing file/directory movement.
+        :type event:
+            :class:`DirMovedEvent` or :class:`FileMovedEvent`
+        """
+
+    def on_created(self, event):
+        """Called when a file or directory is created.
+
+        :param event:
+            Event representing file/directory creation.
+        :type event:
+            :class:`DirCreatedEvent` or :class:`FileCreatedEvent`
+        """
+
+    def on_deleted(self, event):
+        """Called when a file or directory is deleted.
+
+        :param event:
+            Event representing file/directory deletion.
+        :type event:
+            :class:`DirDeletedEvent` or :class:`FileDeletedEvent`
+        """
+
+    def on_modified(self, event):
+        """Called when a file or directory is modified.
+
+        :param event:
+            Event representing file/directory modification.
+        :type event:
+            :class:`DirModifiedEvent` or :class:`FileModifiedEvent`
+        """
+
+
+class PatternMatchingEventHandler(FileSystemEventHandler):
+    """
+    Matches given patterns with file paths associated with occurring events.
+    """
+
+    def __init__(self, patterns=None, ignore_patterns=None,
+                 ignore_directories=False, case_sensitive=False):
+        super(PatternMatchingEventHandler, self).__init__()
+
+        self._patterns = patterns
+        self._ignore_patterns = ignore_patterns
+        self._ignore_directories = ignore_directories
+        self._case_sensitive = case_sensitive
+
+    @property
+    def patterns(self):
+        """
+        (Read-only)
+        Patterns to allow matching event paths.
+        """
+        return self._patterns
+
+    @property
+    def ignore_patterns(self):
+        """
+        (Read-only)
+        Patterns to ignore matching event paths.
+        """
+        return self._ignore_patterns
+
+    @property
+    def ignore_directories(self):
+        """
+        (Read-only)
+        ``True`` if directories should be ignored; ``False`` otherwise.
+        """
+        return self._ignore_directories
+
+    @property
+    def case_sensitive(self):
+        """
+        (Read-only)
+        ``True`` if path names should be matched sensitive to case; ``False``
+        otherwise.
+        """
+        return self._case_sensitive
+
+    def dispatch(self, event):
+        """Dispatches events to the appropriate methods.
+
+        :param event:
+            The event object representing the file system event.
+        :type event:
+            :class:`FileSystemEvent`
+        """
+        if self.ignore_directories and event.is_directory:
+            return
+
+        paths = []
+        if has_attribute(event, 'dest_path'):
+            paths.append(unicode_paths.decode(event.dest_path))
+        if event.src_path:
+            paths.append(unicode_paths.decode(event.src_path))
+
+        if match_any_paths(paths,
+                           included_patterns=self.patterns,
+                           excluded_patterns=self.ignore_patterns,
+                           case_sensitive=self.case_sensitive):
+            self.on_any_event(event)
+            _method_map = {
+                EVENT_TYPE_MODIFIED: self.on_modified,
+                EVENT_TYPE_MOVED: self.on_moved,
+                EVENT_TYPE_CREATED: self.on_created,
+                EVENT_TYPE_DELETED: self.on_deleted,
+            }
+            event_type = event.event_type
+            _method_map[event_type](event)
+
+
+class RegexMatchingEventHandler(FileSystemEventHandler):
+    """
+    Matches given regexes with file paths associated with occurring events.
+    """
+
+    def __init__(self, regexes=[r".*"], ignore_regexes=[],
+                 ignore_directories=False, case_sensitive=False):
+        super(RegexMatchingEventHandler, self).__init__()
+
+        if case_sensitive:
+            self._regexes = [re.compile(r) for r in regexes]
+            self._ignore_regexes = [re.compile(r) for r in ignore_regexes]
+        else:
+            self._regexes = [re.compile(r, re.I) for r in regexes]
+            self._ignore_regexes = [re.compile(r, re.I) for r in ignore_regexes]
+        self._ignore_directories = ignore_directories
+        self._case_sensitive = case_sensitive
+
+    @property
+    def regexes(self):
+        """
+        (Read-only)
+        Regexes to allow matching event paths.
+        """
+        return self._regexes
+
+    @property
+    def ignore_regexes(self):
+        """
+        (Read-only)
+        Regexes to ignore matching event paths.
+        """
+        return self._ignore_regexes
+
+    @property
+    def ignore_directories(self):
+        """
+        (Read-only)
+        ``True`` if directories should be ignored; ``False`` otherwise.
+        """
+        return self._ignore_directories
+
+    @property
+    def case_sensitive(self):
+        """
+        (Read-only)
+        ``True`` if path names should be matched sensitive to case; ``False``
+        otherwise.
+        """
+        return self._case_sensitive
+
+    def dispatch(self, event):
+        """Dispatches events to the appropriate methods.
+
+        :param event:
+            The event object representing the file system event.
+        :type event:
+            :class:`FileSystemEvent`
+        """
+        if self.ignore_directories and event.is_directory:
+            return
+
+        paths = []
+        if has_attribute(event, 'dest_path'):
+            paths.append(unicode_paths.decode(event.dest_path))
+        if event.src_path:
+            paths.append(unicode_paths.decode(event.src_path))
+
+        if any(r.match(p) for r in self.ignore_regexes for p in paths):
+            return
+
+        if any(r.match(p) for r in self.regexes for p in paths):
+            self.on_any_event(event)
+            _method_map = {
+                EVENT_TYPE_MODIFIED: self.on_modified,
+                EVENT_TYPE_MOVED: self.on_moved,
+                EVENT_TYPE_CREATED: self.on_created,
+                EVENT_TYPE_DELETED: self.on_deleted,
+            }
+            event_type = event.event_type
+            _method_map[event_type](event)
+
+
+class LoggingEventHandler(FileSystemEventHandler):
+    """Logs all the events captured."""
+
+    def on_moved(self, event):
+        super(LoggingEventHandler, self).on_moved(event)
+
+        what = 'directory' if event.is_directory else 'file'
+        logging.info("Moved %s: from %s to %s", what, event.src_path,
+                     event.dest_path)
+
+    def on_created(self, event):
+        super(LoggingEventHandler, self).on_created(event)
+
+        what = 'directory' if event.is_directory else 'file'
+        logging.info("Created %s: %s", what, event.src_path)
+
+    def on_deleted(self, event):
+        super(LoggingEventHandler, self).on_deleted(event)
+
+        what = 'directory' if event.is_directory else 'file'
+        logging.info("Deleted %s: %s", what, event.src_path)
+
+    def on_modified(self, event):
+        super(LoggingEventHandler, self).on_modified(event)
+
+        what = 'directory' if event.is_directory else 'file'
+        logging.info("Modified %s: %s", what, event.src_path)
+
+
+class LoggingFileSystemEventHandler(LoggingEventHandler):
+    """
+    For backwards-compatibility. Please use :class:`LoggingEventHandler`
+    instead.
+    """
+
+
+def generate_sub_moved_events(src_dir_path, dest_dir_path):
+    """Generates an event list of :class:`DirMovedEvent` and
+    :class:`FileMovedEvent` objects for all the files and directories within
+    the given moved directory that were moved along with the directory.
+
+    :param src_dir_path:
+        The source path of the moved directory.
+    :param dest_dir_path:
+        The destination path of the moved directory.
+    :returns:
+        An iterable of file system events of type :class:`DirMovedEvent` and
+        :class:`FileMovedEvent`.
+    """
+    for root, directories, filenames in os.walk(dest_dir_path):
+        for directory in directories:
+            full_path = os.path.join(root, directory)
+            renamed_path = full_path.replace(dest_dir_path, src_dir_path) if src_dir_path else None
+            yield DirMovedEvent(renamed_path, full_path)
+        for filename in filenames:
+            full_path = os.path.join(root, filename)
+            renamed_path = full_path.replace(dest_dir_path, src_dir_path) if src_dir_path else None
+            yield FileMovedEvent(renamed_path, full_path)
+
+
+def generate_sub_created_events(src_dir_path):
+    """Generates an event list of :class:`DirCreatedEvent` and
+    :class:`FileCreatedEvent` objects for all the files and directories within
+    the given moved directory that were moved along with the directory.
+
+    :param src_dir_path:
+        The source path of the created directory.
+    :returns:
+        An iterable of file system events of type :class:`DirCreatedEvent` and
+        :class:`FileCreatedEvent`.
+    """
+    for root, directories, filenames in os.walk(src_dir_path):
+        for directory in directories:
+            yield DirCreatedEvent(os.path.join(root, directory))
+        for filename in filenames:
+            yield FileCreatedEvent(os.path.join(root, filename))

vllm/lib/python3.10/site-packages/wandb/vendor/watchdog_0_9_0/wandb_watchdog/observers/__init__.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+#
+# 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.
+
+"""
+:module: watchdog.observers
+:synopsis: Observer that picks a native implementation if available.
+:author: yesudeep@google.com (Yesudeep Mangalapilly)
+
+
+Classes
+=======
+.. autoclass:: Observer
+   :members:
+   :show-inheritance:
+   :inherited-members:
+   
+Observer thread that schedules watching directories and dispatches
+calls to event handlers.
+
+You can also import platform specific classes directly and use it instead
+of :class:`Observer`.  Here is a list of implemented observer classes.:
+
+============== ================================ ==============================
+Class          Platforms                        Note
+============== ================================ ==============================
+|Inotify|      Linux 2.6.13+                    ``inotify(7)`` based observer
+|FSEvents|     Mac OS X                         FSEvents based observer
+|Kqueue|       Mac OS X and BSD with kqueue(2)  ``kqueue(2)`` based observer
+|WinApi|       MS Windows                       Windows API-based observer
+|Polling|      Any                              fallback implementation
+============== ================================ ==============================
+
+.. |Inotify|     replace:: :class:`.inotify.InotifyObserver`
+.. |FSEvents|    replace:: :class:`.fsevents.FSEventsObserver`
+.. |Kqueue|      replace:: :class:`.kqueue.KqueueObserver`
+.. |WinApi|      replace:: :class:`.read_directory_changes.WindowsApiObserver`
+.. |WinApiAsync| replace:: :class:`.read_directory_changes_async.WindowsApiAsyncObserver`
+.. |Polling|     replace:: :class:`.polling.PollingObserver`
+
+"""
+
+import warnings
+from wandb_watchdog.utils import platform
+from wandb_watchdog.utils import UnsupportedLibc
+
+if platform.is_linux():
+    try:
+        from .inotify import InotifyObserver as Observer
+    except UnsupportedLibc:
+        from .polling import PollingObserver as Observer
+
+elif platform.is_darwin():
+    # FIXME: catching too broad. Error prone
+    try:
+        from .fsevents import FSEventsObserver as Observer
+    except:
+        try:
+            from .kqueue import KqueueObserver as Observer
+            # Note: (tim): Commenting out these warnings since the _watchdog_fsevents
+            # module is not available unless installed directly.
+            # warnings.warn("Failed to import fsevents. Fall back to kqueue")
+        except:
+            from .polling import PollingObserver as Observer
+            # Note: (tim): Commenting out these warnings since the _watchdog_fsevents
+            # module is not available unless installed directly.
+            # warnings.warn("Failed to import fsevents and kqueue. Fall back to polling.")
+
+elif platform.is_bsd():
+    from .kqueue import KqueueObserver as Observer
+
+elif platform.is_windows():
+    # TODO: find a reliable way of checking Windows version and import
+    # polling explicitly for Windows XP
+    try:
+        from .read_directory_changes import WindowsApiObserver as Observer
+    except:
+        from .polling import PollingObserver as Observer
+        warnings.warn("Failed to import read_directory_changes. Fall back to polling.")
+
+else:
+    from .polling import PollingObserver as Observer
+
+__all__ = ["Observer"]