Add files using upload-large-folder tool

.gitattributes

@@ -489,3 +489,4 @@ videollama2/lib/python3.10/site-packages/cv2/qt/fonts/DejaVuSans-Oblique.ttf fil
 videollama2/lib/python3.10/site-packages/cv2/qt/fonts/DejaVuSansCondensed-Oblique.ttf filter=lfs diff=lfs merge=lfs -text
 videollama2/lib/python3.10/site-packages/cv2/qt/fonts/DejaVuSansCondensed.ttf filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/xformers/_C.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libasan.so.6 filter=lfs diff=lfs merge=lfs -text

parrot/lib/libasan.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a8a7995a4d84a8817af8d1604bef621e99d0622df4eda14f6fe5245735a952e
+size 7575272

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/ApplyGridUtils.cuh

@@ -0,0 +1,47 @@
+#include <ATen/cuda/CUDAContext.h>
+
+#include <cuda_runtime.h>
+
+namespace at::cuda {
+
+/**
+   Computes ceil(a / b)
+*/
+template <typename T>
+__host__ __device__ __forceinline__ T ATenCeilDiv(T a, T b) {
+  return (a + b - 1) / b;
+}
+
+namespace {
+
+// Threads per block for our apply kernel
+// FIXME: use occupancy calculator instead
+constexpr uint32_t AT_APPLY_THREADS_PER_BLOCK = 512;
+constexpr uint32_t AT_APPLY_BLOCKS_PER_SM = 4;
+
+template <int step = 1>
+inline bool getApplyGrid(uint64_t totalElements, dim3& grid, c10::DeviceIndex curDevice, int max_threads_per_block=AT_APPLY_THREADS_PER_BLOCK) {
+  if (curDevice == -1) return false;
+  uint64_t numel_per_thread = static_cast<uint64_t>(max_threads_per_block) * static_cast<uint64_t>(step);
+  uint64_t numBlocks = ATenCeilDiv(totalElements, numel_per_thread);
+  uint64_t maxGridX = at::cuda::getDeviceProperties(curDevice)->maxGridSize[0];
+  if (numBlocks > maxGridX)
+    numBlocks = maxGridX;
+  grid = dim3(numBlocks);
+  return true;
+}
+
+constexpr int getApplyBlocksPerSM() {
+  return AT_APPLY_BLOCKS_PER_SM;
+}
+
+constexpr int getApplyBlockSize() {
+  return AT_APPLY_THREADS_PER_BLOCK;
+}
+
+inline dim3 getApplyBlock(int max_threads_per_block=AT_APPLY_THREADS_PER_BLOCK) {
+  return dim3(max_threads_per_block);
+}
+
+} // anonymous namespace
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/AsmUtils.cuh

@@ -0,0 +1,149 @@
+#pragma once
+#include <cstdint>
+
+// Collection of direct PTX functions
+
+namespace at::cuda {
+
+template <typename T>
+struct Bitfield {};
+
+template <>
+struct Bitfield<unsigned int> {
+  static __device__ __host__ __forceinline__
+  unsigned int getBitfield(unsigned int val, int pos, int len) {
+#if !defined(__CUDA_ARCH__)
+    pos &= 0xff;
+    len &= 0xff;
+
+    unsigned int m = (1u << len) - 1u;
+    return (val >> pos) & m;
+#else
+    unsigned int ret;
+    asm("bfe.u32 %0, %1, %2, %3;" : "=r"(ret) : "r"(val), "r"(pos), "r"(len));
+    return ret;
+#endif
+  }
+
+  static __device__ __host__ __forceinline__
+  unsigned int setBitfield(unsigned int val, unsigned int toInsert, int pos, int len) {
+#if !defined(__CUDA_ARCH__)
+    pos &= 0xff;
+    len &= 0xff;
+
+    unsigned int m = (1u << len) - 1u;
+    toInsert &= m;
+    toInsert <<= pos;
+    m <<= pos;
+
+    return (val & ~m) | toInsert;
+#else
+    unsigned int ret;
+    asm("bfi.b32 %0, %1, %2, %3, %4;" :
+        "=r"(ret) : "r"(toInsert), "r"(val), "r"(pos), "r"(len));
+    return ret;
+#endif
+  }
+};
+
+template <>
+struct Bitfield<uint64_t> {
+  static __device__ __host__ __forceinline__
+  uint64_t getBitfield(uint64_t val, int pos, int len) {
+#if !defined(__CUDA_ARCH__)
+    pos &= 0xff;
+    len &= 0xff;
+
+    uint64_t m = (1u << len) - 1u;
+    return (val >> pos) & m;
+#else
+    uint64_t ret;
+    asm("bfe.u64 %0, %1, %2, %3;" : "=l"(ret) : "l"(val), "r"(pos), "r"(len));
+    return ret;
+#endif
+  }
+
+  static __device__ __host__ __forceinline__
+  uint64_t setBitfield(uint64_t val, uint64_t toInsert, int pos, int len) {
+#if !defined(__CUDA_ARCH__)
+    pos &= 0xff;
+    len &= 0xff;
+
+    uint64_t m = (1u << len) - 1u;
+    toInsert &= m;
+    toInsert <<= pos;
+    m <<= pos;
+
+    return (val & ~m) | toInsert;
+#else
+    uint64_t ret;
+    asm("bfi.b64 %0, %1, %2, %3, %4;" :
+        "=l"(ret) : "l"(toInsert), "l"(val), "r"(pos), "r"(len));
+    return ret;
+#endif
+  }
+};
+
+__device__ __forceinline__ int getLaneId() {
+#if defined(USE_ROCM)
+  return __lane_id();
+#else
+  int laneId;
+  asm("mov.s32 %0, %%laneid;" : "=r"(laneId) );
+  return laneId;
+#endif
+}
+
+#if defined(USE_ROCM)
+__device__ __forceinline__ unsigned long long int getLaneMaskLt() {
+  const std::uint64_t m = (1ull << getLaneId()) - 1ull;
+  return m;
+}
+#else
+__device__ __forceinline__ unsigned getLaneMaskLt() {
+  unsigned mask;
+  asm("mov.u32 %0, %%lanemask_lt;" : "=r"(mask));
+  return mask;
+}
+#endif
+
+#if defined (USE_ROCM)
+__device__ __forceinline__ unsigned long long int getLaneMaskLe() {
+  std::uint64_t m = UINT64_MAX >> (sizeof(std::uint64_t) * CHAR_BIT - (getLaneId() + 1));
+  return m;
+}
+#else
+__device__ __forceinline__ unsigned getLaneMaskLe() {
+  unsigned mask;
+  asm("mov.u32 %0, %%lanemask_le;" : "=r"(mask));
+  return mask;
+}
+#endif
+
+#if defined(USE_ROCM)
+__device__ __forceinline__ unsigned long long int getLaneMaskGt() {
+  const std::uint64_t m = getLaneMaskLe();
+  return m ? ~m : m;
+}
+#else
+__device__ __forceinline__ unsigned getLaneMaskGt() {
+  unsigned mask;
+  asm("mov.u32 %0, %%lanemask_gt;" : "=r"(mask));
+  return mask;
+}
+#endif
+
+#if defined(USE_ROCM)
+__device__ __forceinline__ unsigned long long int getLaneMaskGe() {
+  const std::uint64_t m = getLaneMaskLt();
+  return ~m;
+}
+#else
+__device__ __forceinline__ unsigned getLaneMaskGe() {
+  unsigned mask;
+  asm("mov.u32 %0, %%lanemask_ge;" : "=r"(mask));
+  return mask;
+}
+#endif
+
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CUDAContextLight.h

@@ -0,0 +1,91 @@
+#pragma once
+// Light-weight version of CUDAContext.h with fewer transitive includes
+
+#include <cstdint>
+
+#include <cuda_runtime_api.h>
+#include <cusparse.h>
+#include <cublas_v2.h>
+
+// cublasLT was introduced in CUDA 10.1 but we enable only for 11.1 that also
+// added bf16 support
+#include <cublasLt.h>
+
+#ifdef CUDART_VERSION
+#include <cusolverDn.h>
+#endif
+
+#if defined(USE_ROCM)
+#include <hipsolver/hipsolver.h>
+#endif
+
+#include <c10/core/Allocator.h>
+#include <c10/cuda/CUDAFunctions.h>
+
+namespace c10 {
+struct Allocator;
+}
+
+namespace at::cuda {
+
+/*
+A common CUDA interface for ATen.
+
+This interface is distinct from CUDAHooks, which defines an interface that links
+to both CPU-only and CUDA builds. That interface is intended for runtime
+dispatch and should be used from files that are included in both CPU-only and
+CUDA builds.
+
+CUDAContext, on the other hand, should be preferred by files only included in
+CUDA builds. It is intended to expose CUDA functionality in a consistent
+manner.
+
+This means there is some overlap between the CUDAContext and CUDAHooks, but
+the choice of which to use is simple: use CUDAContext when in a CUDA-only file,
+use CUDAHooks otherwise.
+
+Note that CUDAContext simply defines an interface with no associated class.
+It is expected that the modules whose functions compose this interface will
+manage their own state. There is only a single CUDA context/state.
+*/
+
+/**
+ * DEPRECATED: use device_count() instead
+ */
+inline int64_t getNumGPUs() {
+    return c10::cuda::device_count();
+}
+
+/**
+ * CUDA is available if we compiled with CUDA, and there are one or more
+ * devices.  If we compiled with CUDA but there is a driver problem, etc.,
+ * this function will report CUDA is not available (rather than raise an error.)
+ */
+inline bool is_available() {
+    return c10::cuda::device_count() > 0;
+}
+
+TORCH_CUDA_CPP_API cudaDeviceProp* getCurrentDeviceProperties();
+
+TORCH_CUDA_CPP_API int warp_size();
+
+TORCH_CUDA_CPP_API cudaDeviceProp* getDeviceProperties(c10::DeviceIndex device);
+
+TORCH_CUDA_CPP_API bool canDeviceAccessPeer(
+    c10::DeviceIndex device,
+    c10::DeviceIndex peer_device);
+
+TORCH_CUDA_CPP_API c10::Allocator* getCUDADeviceAllocator();
+
+/* Handles */
+TORCH_CUDA_CPP_API cusparseHandle_t getCurrentCUDASparseHandle();
+TORCH_CUDA_CPP_API cublasHandle_t getCurrentCUDABlasHandle();
+TORCH_CUDA_CPP_API cublasLtHandle_t getCurrentCUDABlasLtHandle();
+
+TORCH_CUDA_CPP_API void clearCublasWorkspaces();
+
+#if defined(CUDART_VERSION) || defined(USE_ROCM)
+TORCH_CUDA_CPP_API cusolverDnHandle_t getCurrentCUDASolverDnHandle();
+#endif
+
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CUDADataType.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <c10/core/ScalarType.h>
+
+#include <cuda.h>
+#include <library_types.h>
+
+namespace at::cuda {
+
+template <typename scalar_t>
+cudaDataType getCudaDataType() {
+  static_assert(false && sizeof(scalar_t), "Cannot convert type to cudaDataType.");
+  return {};
+}
+
+template<> inline cudaDataType getCudaDataType<at::Half>() {
+  return CUDA_R_16F;
+}
+template<> inline cudaDataType getCudaDataType<float>() {
+  return CUDA_R_32F;
+}
+template<> inline cudaDataType getCudaDataType<double>() {
+  return CUDA_R_64F;
+}
+template<> inline cudaDataType getCudaDataType<c10::complex<c10::Half>>() {
+  return CUDA_C_16F;
+}
+template<> inline cudaDataType getCudaDataType<c10::complex<float>>() {
+  return CUDA_C_32F;
+}
+template<> inline cudaDataType getCudaDataType<c10::complex<double>>() {
+  return CUDA_C_64F;
+}
+
+template<> inline cudaDataType getCudaDataType<uint8_t>() {
+  return CUDA_R_8U;
+}
+template<> inline cudaDataType getCudaDataType<int8_t>() {
+  return CUDA_R_8I;
+}
+template<> inline cudaDataType getCudaDataType<int>() {
+  return CUDA_R_32I;
+}
+
+template<> inline cudaDataType getCudaDataType<int16_t>() {
+  return CUDA_R_16I;
+}
+template<> inline cudaDataType getCudaDataType<int64_t>() {
+  return CUDA_R_64I;
+}
+template<> inline cudaDataType getCudaDataType<at::BFloat16>() {
+  return CUDA_R_16BF;
+}
+
+inline cudaDataType ScalarTypeToCudaDataType(const c10::ScalarType& scalar_type) {
+  switch (scalar_type) {
+    case c10::ScalarType::Byte:
+      return CUDA_R_8U;
+    case c10::ScalarType::Char:
+      return CUDA_R_8I;
+    case c10::ScalarType::Int:
+      return CUDA_R_32I;
+    case c10::ScalarType::Half:
+      return CUDA_R_16F;
+    case c10::ScalarType::Float:
+      return CUDA_R_32F;
+    case c10::ScalarType::Double:
+      return CUDA_R_64F;
+    case c10::ScalarType::ComplexHalf:
+      return CUDA_C_16F;
+    case c10::ScalarType::ComplexFloat:
+      return CUDA_C_32F;
+    case c10::ScalarType::ComplexDouble:
+      return CUDA_C_64F;
+    case c10::ScalarType::Short:
+      return CUDA_R_16I;
+    case c10::ScalarType::Long:
+      return CUDA_R_64I;
+    case c10::ScalarType::BFloat16:
+      return CUDA_R_16BF;
+#if defined(CUDA_VERSION) && CUDA_VERSION >= 11080
+    case c10::ScalarType::Float8_e4m3fn:
+      return CUDA_R_8F_E4M3;
+    case c10::ScalarType::Float8_e5m2:
+      return CUDA_R_8F_E5M2;
+#endif
+#if defined(USE_ROCM)
+#if defined(HIP_NEW_TYPE_ENUMS)
+    case c10::ScalarType::Float8_e4m3fnuz:
+      return HIP_R_8F_E4M3_FNUZ;
+    case c10::ScalarType::Float8_e5m2fnuz:
+      return HIP_R_8F_E5M2_FNUZ;
+#else
+    case c10::ScalarType::Float8_e4m3fnuz:
+      return static_cast<hipDataType>(1000);
+    case c10::ScalarType::Float8_e5m2fnuz:
+      return static_cast<hipDataType>(1001);
+#endif
+#endif
+    default:
+      TORCH_INTERNAL_ASSERT(false, "Cannot convert ScalarType ", scalar_type, " to cudaDataType.")
+  }
+}
+
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CUDADevice.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <ATen/cuda/Exceptions.h>
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+namespace at::cuda {
+
+inline Device getDeviceFromPtr(void* ptr) {
+  cudaPointerAttributes attr{};
+
+  AT_CUDA_CHECK(cudaPointerGetAttributes(&attr, ptr));
+
+#if !defined(USE_ROCM)
+  TORCH_CHECK(attr.type != cudaMemoryTypeUnregistered,
+    "The specified pointer resides on host memory and is not registered with any CUDA device.");
+#endif
+
+  return {c10::DeviceType::CUDA, static_cast<DeviceIndex>(attr.device)};
+}
+
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CUDAGraph.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <ATen/Tensor.h>
+#include <c10/core/Device.h>
+#include <c10/cuda/CUDAGraphsC10Utils.h>
+#include <c10/cuda/CUDAStream.h>
+#include <c10/util/flat_hash_map.h>
+
+namespace at {
+
+struct Generator;
+struct CUDAGeneratorImpl;
+struct CUDAGeneratorState;
+
+namespace cuda {
+
+// Standalone way to get a unique mempool id usable as a pool=... argument
+// to CUDAGraph::capture_begin
+TORCH_CUDA_CPP_API MempoolId_t graph_pool_handle();
+
+struct TORCH_CUDA_CPP_API CUDAGraph {
+  CUDAGraph();
+  ~CUDAGraph();
+
+  static void inc_pending_event_queries();
+  static void dec_pending_event_queries();
+  static int num_pending_event_queries();
+  // See Note [Explicit Registration of Generators to the CUDA Graph]
+  void register_generator_state(c10::intrusive_ptr<at::CUDAGeneratorState> state);
+  void register_generator_state(const at::Generator& generator);
+  void capture_begin(
+      MempoolId_t pool = {0, 0},
+      cudaStreamCaptureMode capture_mode = cudaStreamCaptureModeGlobal);
+  void capture_end();
+  void replay();
+  void reset();
+  MempoolId_t pool();
+  void enable_debug_mode();
+  void debug_dump(const std::string& debug_path);
+
+ protected:
+  cudaGraph_t graph_ = nullptr;
+  cudaGraphExec_t graph_exec_ = nullptr;
+
+  static std::atomic<int> pending_event_queries;
+
+  // internal states so reset() can do its best cleaning up
+  // Set to true in capture_end if cudaStreamEndCapture succeeded
+  // Set back to false soon after, when graph_ is consumed by cudaGraphInstantiate
+  // to create graph_exec_, then graph_ is deleted
+  bool has_graph_ = false;
+  // Set to true in capture_end if cudaGraphInstantiate succeeded
+  bool has_graph_exec_ = false;
+
+  // uuid of this instance's current capture, used to
+  // specify the pool.
+  CaptureId_t id_;
+
+  // the ID assigned by cuda during graph capture,
+  // used to identify when a stream is participating in capture
+  CaptureId_t capture_id_ = -1;
+
+  // uuid used to request a particular private mempool from CUDACachingAllocator.
+  // By default, this will be set to {id_, 0}.
+  //
+  // If capture_begin is called with "pool=other_graph.pool()", this graph's mempool_id_
+  // will be set to the other graph's mempool_id_, and therefore share a mempool with the
+  // other graph.
+  //
+  // If capture_begin is called with "pool=handle" where "handle" came from graph_pool_handle(),
+  // it will share a mempool with any other captures that used "pool=handle".
+  //
+  // Sharing a mempool across graphs saves memory, and it's safe if you
+  // know you'll replay those graphs in the same order you captured them.
+  MempoolId_t mempool_id_;
+
+  // Stream on which capture began
+  at::cuda::CUDAStream capture_stream_;
+
+  // multiple generator states and their wholegraph_increments in this graph
+  // that are managed by the CUDA Graph
+  ska::flat_hash_map<c10::intrusive_ptr<at::CUDAGeneratorState>, uint64_t>
+      captured_generator_states_;
+
+  // Device where capture occurred. Right now, for simplicity, we require all ops
+  // in a capture to run on the same device, but this is a limitation of CUDAGraph,
+  // not CUDA itself.  We can straightforwardly modify CUDAGraph to support multi-device
+  // captures if needed.
+  int capture_dev_;
+};
+
+} // namespace cuda
+} // namespace at

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CUDASparse.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <ATen/cuda/CUDAContext.h>
+#if defined(USE_ROCM)
+#include <hipsparse/hipsparse-version.h>
+#define HIPSPARSE_VERSION ((hipsparseVersionMajor*100000) + (hipsparseVersionMinor*100) + hipsparseVersionPatch)
+#endif
+
+// cuSparse Generic API added in CUDA 10.1
+// Windows support added in CUDA 11.0
+#if defined(CUDART_VERSION) && defined(CUSPARSE_VERSION) && ((CUSPARSE_VERSION >= 10300) || (CUSPARSE_VERSION >= 11000 && defined(_WIN32)))
+#define AT_USE_CUSPARSE_GENERIC_API() 1
+#else
+#define AT_USE_CUSPARSE_GENERIC_API() 0
+#endif
+
+// cuSparse Generic API descriptor pointers were changed to const in CUDA 12.0
+#if defined(CUDART_VERSION) && defined(CUSPARSE_VERSION) && \
+    (CUSPARSE_VERSION < 12000)
+#define AT_USE_CUSPARSE_NON_CONST_DESCRIPTORS() 1
+#else
+#define AT_USE_CUSPARSE_NON_CONST_DESCRIPTORS() 0
+#endif
+
+#if defined(CUDART_VERSION) && defined(CUSPARSE_VERSION) && \
+    (CUSPARSE_VERSION >= 12000)
+#define AT_USE_CUSPARSE_CONST_DESCRIPTORS() 1
+#else
+#define AT_USE_CUSPARSE_CONST_DESCRIPTORS() 0
+#endif
+
+#if defined(USE_ROCM)
+// hipSparse const API added in v2.4.0
+#if HIPSPARSE_VERSION >= 200400
+#define AT_USE_HIPSPARSE_CONST_DESCRIPTORS() 1
+#define AT_USE_HIPSPARSE_NON_CONST_DESCRIPTORS() 0
+#define AT_USE_HIPSPARSE_GENERIC_API() 1
+#else
+#define AT_USE_HIPSPARSE_CONST_DESCRIPTORS() 0
+#define AT_USE_HIPSPARSE_NON_CONST_DESCRIPTORS() 1
+#define AT_USE_HIPSPARSE_GENERIC_API() 1
+#endif
+#else // USE_ROCM
+#define AT_USE_HIPSPARSE_CONST_DESCRIPTORS() 0
+#define AT_USE_HIPSPARSE_NON_CONST_DESCRIPTORS() 0
+#define AT_USE_HIPSPARSE_GENERIC_API() 0
+#endif // USE_ROCM
+
+// cuSparse Generic API spsv function was added in CUDA 11.3.0
+#if defined(CUDART_VERSION) && defined(CUSPARSE_VERSION) && (CUSPARSE_VERSION >= 11500)
+#define AT_USE_CUSPARSE_GENERIC_SPSV() 1
+#else
+#define AT_USE_CUSPARSE_GENERIC_SPSV() 0
+#endif
+
+// cuSparse Generic API spsm function was added in CUDA 11.3.1
+#if defined(CUDART_VERSION) && defined(CUSPARSE_VERSION) && (CUSPARSE_VERSION >= 11600)
+#define AT_USE_CUSPARSE_GENERIC_SPSM() 1
+#else
+#define AT_USE_CUSPARSE_GENERIC_SPSM() 0
+#endif
+
+// cuSparse Generic API sddmm function was added in CUDA 11.2.1 (cuSparse version 11400)
+#if defined(CUDART_VERSION) && defined(CUSPARSE_VERSION) && (CUSPARSE_VERSION >= 11400)
+#define AT_USE_CUSPARSE_GENERIC_SDDMM() 1
+#else
+#define AT_USE_CUSPARSE_GENERIC_SDDMM() 0
+#endif
+
+// BSR triangular solve functions were added in hipSPARSE 1.11.2 (ROCm 4.5.0)
+#if defined(CUDART_VERSION) || defined(USE_ROCM)
+#define AT_USE_HIPSPARSE_TRIANGULAR_SOLVE() 1
+#else
+#define AT_USE_HIPSPARSE_TRIANGULAR_SOLVE() 0
+#endif

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CUDASparseBlas.h

@@ -0,0 +1,318 @@
+#pragma once
+
+/*
+  Provides a subset of cuSPARSE functions as templates:
+
+    csrgeam2<scalar_t>(...)
+
+  where scalar_t is double, float, c10::complex<double> or c10::complex<float>.
+  The functions are available in at::cuda::sparse namespace.
+*/
+
+#include <ATen/cuda/CUDAContext.h>
+#include <ATen/cuda/CUDASparse.h>
+
+namespace at::cuda::sparse {
+
+#define CUSPARSE_CSRGEAM2_BUFFERSIZE_ARGTYPES(scalar_t)             \
+  cusparseHandle_t handle, int m, int n, const scalar_t *alpha,     \
+      const cusparseMatDescr_t descrA, int nnzA,                    \
+      const scalar_t *csrSortedValA, const int *csrSortedRowPtrA,   \
+      const int *csrSortedColIndA, const scalar_t *beta,            \
+      const cusparseMatDescr_t descrB, int nnzB,                    \
+      const scalar_t *csrSortedValB, const int *csrSortedRowPtrB,   \
+      const int *csrSortedColIndB, const cusparseMatDescr_t descrC, \
+      const scalar_t *csrSortedValC, const int *csrSortedRowPtrC,   \
+      const int *csrSortedColIndC, size_t *pBufferSizeInBytes
+
+template <typename scalar_t>
+inline void csrgeam2_bufferSizeExt(
+    CUSPARSE_CSRGEAM2_BUFFERSIZE_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::csrgeam2_bufferSizeExt: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void csrgeam2_bufferSizeExt<float>(
+    CUSPARSE_CSRGEAM2_BUFFERSIZE_ARGTYPES(float));
+template <>
+void csrgeam2_bufferSizeExt<double>(
+    CUSPARSE_CSRGEAM2_BUFFERSIZE_ARGTYPES(double));
+template <>
+void csrgeam2_bufferSizeExt<c10::complex<float>>(
+    CUSPARSE_CSRGEAM2_BUFFERSIZE_ARGTYPES(c10::complex<float>));
+template <>
+void csrgeam2_bufferSizeExt<c10::complex<double>>(
+    CUSPARSE_CSRGEAM2_BUFFERSIZE_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_CSRGEAM2_NNZ_ARGTYPES()                                      \
+  cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,     \
+      int nnzA, const int *csrSortedRowPtrA, const int *csrSortedColIndA,     \
+      const cusparseMatDescr_t descrB, int nnzB, const int *csrSortedRowPtrB, \
+      const int *csrSortedColIndB, const cusparseMatDescr_t descrC,           \
+      int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *workspace
+
+template <typename scalar_t>
+inline void csrgeam2Nnz(CUSPARSE_CSRGEAM2_NNZ_ARGTYPES()) {
+  TORCH_CUDASPARSE_CHECK(cusparseXcsrgeam2Nnz(
+      handle,
+      m,
+      n,
+      descrA,
+      nnzA,
+      csrSortedRowPtrA,
+      csrSortedColIndA,
+      descrB,
+      nnzB,
+      csrSortedRowPtrB,
+      csrSortedColIndB,
+      descrC,
+      csrSortedRowPtrC,
+      nnzTotalDevHostPtr,
+      workspace));
+}
+
+#define CUSPARSE_CSRGEAM2_ARGTYPES(scalar_t)                                 \
+  cusparseHandle_t handle, int m, int n, const scalar_t *alpha,              \
+      const cusparseMatDescr_t descrA, int nnzA,                             \
+      const scalar_t *csrSortedValA, const int *csrSortedRowPtrA,            \
+      const int *csrSortedColIndA, const scalar_t *beta,                     \
+      const cusparseMatDescr_t descrB, int nnzB,                             \
+      const scalar_t *csrSortedValB, const int *csrSortedRowPtrB,            \
+      const int *csrSortedColIndB, const cusparseMatDescr_t descrC,          \
+      scalar_t *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC, \
+      void *pBuffer
+
+template <typename scalar_t>
+inline void csrgeam2(CUSPARSE_CSRGEAM2_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::csrgeam2: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void csrgeam2<float>(CUSPARSE_CSRGEAM2_ARGTYPES(float));
+template <>
+void csrgeam2<double>(CUSPARSE_CSRGEAM2_ARGTYPES(double));
+template <>
+void csrgeam2<c10::complex<float>>(
+    CUSPARSE_CSRGEAM2_ARGTYPES(c10::complex<float>));
+template <>
+void csrgeam2<c10::complex<double>>(
+    CUSPARSE_CSRGEAM2_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRMM_ARGTYPES(scalar_t)                                    \
+  cusparseHandle_t handle, cusparseDirection_t dirA,                         \
+      cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n, \
+      int kb, int nnzb, const scalar_t *alpha,                               \
+      const cusparseMatDescr_t descrA, const scalar_t *bsrValA,              \
+      const int *bsrRowPtrA, const int *bsrColIndA, int blockDim,            \
+      const scalar_t *B, int ldb, const scalar_t *beta, scalar_t *C, int ldc
+
+template <typename scalar_t>
+inline void bsrmm(CUSPARSE_BSRMM_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrmm: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrmm<float>(CUSPARSE_BSRMM_ARGTYPES(float));
+template <>
+void bsrmm<double>(CUSPARSE_BSRMM_ARGTYPES(double));
+template <>
+void bsrmm<c10::complex<float>>(CUSPARSE_BSRMM_ARGTYPES(c10::complex<float>));
+template <>
+void bsrmm<c10::complex<double>>(CUSPARSE_BSRMM_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRMV_ARGTYPES(scalar_t)                                    \
+  cusparseHandle_t handle, cusparseDirection_t dirA,                         \
+      cusparseOperation_t transA, int mb, int nb, int nnzb,                  \
+      const scalar_t *alpha, const cusparseMatDescr_t descrA,                \
+      const scalar_t *bsrValA, const int *bsrRowPtrA, const int *bsrColIndA, \
+      int blockDim, const scalar_t *x, const scalar_t *beta, scalar_t *y
+
+template <typename scalar_t>
+inline void bsrmv(CUSPARSE_BSRMV_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrmv: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrmv<float>(CUSPARSE_BSRMV_ARGTYPES(float));
+template <>
+void bsrmv<double>(CUSPARSE_BSRMV_ARGTYPES(double));
+template <>
+void bsrmv<c10::complex<float>>(CUSPARSE_BSRMV_ARGTYPES(c10::complex<float>));
+template <>
+void bsrmv<c10::complex<double>>(CUSPARSE_BSRMV_ARGTYPES(c10::complex<double>));
+
+#if AT_USE_HIPSPARSE_TRIANGULAR_SOLVE()
+
+#define CUSPARSE_BSRSV2_BUFFER_ARGTYPES(scalar_t)                 \
+  cusparseHandle_t handle, cusparseDirection_t dirA,              \
+      cusparseOperation_t transA, int mb, int nnzb,               \
+      const cusparseMatDescr_t descrA, scalar_t *bsrValA,         \
+      const int *bsrRowPtrA, const int *bsrColIndA, int blockDim, \
+      bsrsv2Info_t info, int *pBufferSizeInBytes
+
+template <typename scalar_t>
+inline void bsrsv2_bufferSize(CUSPARSE_BSRSV2_BUFFER_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrsv2_bufferSize: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrsv2_bufferSize<float>(CUSPARSE_BSRSV2_BUFFER_ARGTYPES(float));
+template <>
+void bsrsv2_bufferSize<double>(CUSPARSE_BSRSV2_BUFFER_ARGTYPES(double));
+template <>
+void bsrsv2_bufferSize<c10::complex<float>>(
+    CUSPARSE_BSRSV2_BUFFER_ARGTYPES(c10::complex<float>));
+template <>
+void bsrsv2_bufferSize<c10::complex<double>>(
+    CUSPARSE_BSRSV2_BUFFER_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRSV2_ANALYSIS_ARGTYPES(scalar_t)               \
+  cusparseHandle_t handle, cusparseDirection_t dirA,              \
+      cusparseOperation_t transA, int mb, int nnzb,               \
+      const cusparseMatDescr_t descrA, const scalar_t *bsrValA,   \
+      const int *bsrRowPtrA, const int *bsrColIndA, int blockDim, \
+      bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer
+
+template <typename scalar_t>
+inline void bsrsv2_analysis(CUSPARSE_BSRSV2_ANALYSIS_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrsv2_analysis: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrsv2_analysis<float>(CUSPARSE_BSRSV2_ANALYSIS_ARGTYPES(float));
+template <>
+void bsrsv2_analysis<double>(CUSPARSE_BSRSV2_ANALYSIS_ARGTYPES(double));
+template <>
+void bsrsv2_analysis<c10::complex<float>>(
+    CUSPARSE_BSRSV2_ANALYSIS_ARGTYPES(c10::complex<float>));
+template <>
+void bsrsv2_analysis<c10::complex<double>>(
+    CUSPARSE_BSRSV2_ANALYSIS_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRSV2_SOLVE_ARGTYPES(scalar_t)                           \
+  cusparseHandle_t handle, cusparseDirection_t dirA,                       \
+      cusparseOperation_t transA, int mb, int nnzb, const scalar_t *alpha, \
+      const cusparseMatDescr_t descrA, const scalar_t *bsrValA,            \
+      const int *bsrRowPtrA, const int *bsrColIndA, int blockDim,          \
+      bsrsv2Info_t info, const scalar_t *x, scalar_t *y,                   \
+      cusparseSolvePolicy_t policy, void *pBuffer
+
+template <typename scalar_t>
+inline void bsrsv2_solve(CUSPARSE_BSRSV2_SOLVE_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrsv2_solve: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrsv2_solve<float>(CUSPARSE_BSRSV2_SOLVE_ARGTYPES(float));
+template <>
+void bsrsv2_solve<double>(CUSPARSE_BSRSV2_SOLVE_ARGTYPES(double));
+template <>
+void bsrsv2_solve<c10::complex<float>>(
+    CUSPARSE_BSRSV2_SOLVE_ARGTYPES(c10::complex<float>));
+template <>
+void bsrsv2_solve<c10::complex<double>>(
+    CUSPARSE_BSRSV2_SOLVE_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRSM2_BUFFER_ARGTYPES(scalar_t)                            \
+  cusparseHandle_t handle, cusparseDirection_t dirA,                         \
+      cusparseOperation_t transA, cusparseOperation_t transX, int mb, int n, \
+      int nnzb, const cusparseMatDescr_t descrA, scalar_t *bsrValA,          \
+      const int *bsrRowPtrA, const int *bsrColIndA, int blockDim,            \
+      bsrsm2Info_t info, int *pBufferSizeInBytes
+
+template <typename scalar_t>
+inline void bsrsm2_bufferSize(CUSPARSE_BSRSM2_BUFFER_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrsm2_bufferSize: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrsm2_bufferSize<float>(CUSPARSE_BSRSM2_BUFFER_ARGTYPES(float));
+template <>
+void bsrsm2_bufferSize<double>(CUSPARSE_BSRSM2_BUFFER_ARGTYPES(double));
+template <>
+void bsrsm2_bufferSize<c10::complex<float>>(
+    CUSPARSE_BSRSM2_BUFFER_ARGTYPES(c10::complex<float>));
+template <>
+void bsrsm2_bufferSize<c10::complex<double>>(
+    CUSPARSE_BSRSM2_BUFFER_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRSM2_ANALYSIS_ARGTYPES(scalar_t)                          \
+  cusparseHandle_t handle, cusparseDirection_t dirA,                         \
+      cusparseOperation_t transA, cusparseOperation_t transX, int mb, int n, \
+      int nnzb, const cusparseMatDescr_t descrA, const scalar_t *bsrValA,    \
+      const int *bsrRowPtrA, const int *bsrColIndA, int blockDim,            \
+      bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer
+
+template <typename scalar_t>
+inline void bsrsm2_analysis(CUSPARSE_BSRSM2_ANALYSIS_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrsm2_analysis: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrsm2_analysis<float>(CUSPARSE_BSRSM2_ANALYSIS_ARGTYPES(float));
+template <>
+void bsrsm2_analysis<double>(CUSPARSE_BSRSM2_ANALYSIS_ARGTYPES(double));
+template <>
+void bsrsm2_analysis<c10::complex<float>>(
+    CUSPARSE_BSRSM2_ANALYSIS_ARGTYPES(c10::complex<float>));
+template <>
+void bsrsm2_analysis<c10::complex<double>>(
+    CUSPARSE_BSRSM2_ANALYSIS_ARGTYPES(c10::complex<double>));
+
+#define CUSPARSE_BSRSM2_SOLVE_ARGTYPES(scalar_t)                             \
+  cusparseHandle_t handle, cusparseDirection_t dirA,                         \
+      cusparseOperation_t transA, cusparseOperation_t transX, int mb, int n, \
+      int nnzb, const scalar_t *alpha, const cusparseMatDescr_t descrA,      \
+      const scalar_t *bsrValA, const int *bsrRowPtrA, const int *bsrColIndA, \
+      int blockDim, bsrsm2Info_t info, const scalar_t *B, int ldb,           \
+      scalar_t *X, int ldx, cusparseSolvePolicy_t policy, void *pBuffer
+
+template <typename scalar_t>
+inline void bsrsm2_solve(CUSPARSE_BSRSM2_SOLVE_ARGTYPES(scalar_t)) {
+  TORCH_INTERNAL_ASSERT(
+      false,
+      "at::cuda::sparse::bsrsm2_solve: not implemented for ",
+      typeid(scalar_t).name());
+}
+
+template <>
+void bsrsm2_solve<float>(CUSPARSE_BSRSM2_SOLVE_ARGTYPES(float));
+template <>
+void bsrsm2_solve<double>(CUSPARSE_BSRSM2_SOLVE_ARGTYPES(double));
+template <>
+void bsrsm2_solve<c10::complex<float>>(
+    CUSPARSE_BSRSM2_SOLVE_ARGTYPES(c10::complex<float>));
+template <>
+void bsrsm2_solve<c10::complex<double>>(
+    CUSPARSE_BSRSM2_SOLVE_ARGTYPES(c10::complex<double>));
+
+#endif // AT_USE_HIPSPARSE_TRIANGULAR_SOLVE
+
+} // namespace at::cuda::sparse

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/CachingHostAllocator.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <ATen/core/CachingHostAllocator.h>
+#include <c10/core/Allocator.h>
+#include <c10/cuda/CUDAStream.h>
+
+namespace at::cuda {
+
+//
+// A caching allocator for CUDA host allocations (pinned memory).
+//
+// This provides a drop-in replacement for THCudaHostAllocator, which re-uses
+// freed pinned (page-locked) memory allocations. This avoids device
+// synchronizations due to cudaFreeHost calls.
+//
+// To ensure correct behavior, THCCachingHostAllocator_recordEvent must be
+// called anytime a pointer from this allocator is used in a cudaMemcpyAsync
+// call between host and device, and passed the corresponding context from the
+// allocation. This is currently invoked by at::native::copy_kernel_cuda.
+//
+TORCH_CUDA_CPP_API c10::Allocator* getCachingHostAllocator();
+
+// Records an event in the specified stream. The allocation corresponding to the
+// input `ptr`/`ctx` will not be re-used until the event has occurred.
+TORCH_CUDA_CPP_API bool CachingHostAllocator_recordEvent(
+    void* ptr,
+    void* ctx,
+    c10::cuda::CUDAStream stream);
+
+// Releases cached pinned memory allocations via cudaHostFree
+TORCH_CUDA_CPP_API void CachingHostAllocator_emptyCache();
+
+inline TORCH_CUDA_CPP_API at::DataPtr HostAlloc(size_t size) {
+  return getCachingHostAllocator()->allocate(size);
+}
+
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/Exceptions.h

@@ -0,0 +1,174 @@
+#pragma once
+
+#include <cublas_v2.h>
+#include <cusparse.h>
+#include <c10/macros/Export.h>
+
+#ifdef CUDART_VERSION
+#include <cusolver_common.h>
+#endif
+
+#include <ATen/Context.h>
+#include <c10/util/Exception.h>
+#include <c10/cuda/CUDAException.h>
+
+
+namespace c10 {
+
+class CuDNNError : public c10::Error {
+  using Error::Error;
+};
+
+}  // namespace c10
+
+#define AT_CUDNN_FRONTEND_CHECK(EXPR, ...)                                                      \
+  do {                                                                                          \
+    auto error_object = EXPR;                                                                   \
+    if (!error_object.is_good()) {                                                              \
+      TORCH_CHECK_WITH(CuDNNError, false,                                                       \
+            "cuDNN Frontend error: ", error_object.get_message());                              \
+    }                                                                                           \
+  } while (0)                                                                                   \
+
+#define AT_CUDNN_CHECK_WITH_SHAPES(EXPR, ...) AT_CUDNN_CHECK(EXPR, "\n", ##__VA_ARGS__)
+
+// See Note [CHECK macro]
+#define AT_CUDNN_CHECK(EXPR, ...)                                                               \
+  do {                                                                                          \
+    cudnnStatus_t status = EXPR;                                                                \
+    if (status != CUDNN_STATUS_SUCCESS) {                                                       \
+      if (status == CUDNN_STATUS_NOT_SUPPORTED) {                                               \
+        TORCH_CHECK_WITH(CuDNNError, false,                                                     \
+            "cuDNN error: ",                                                                    \
+            cudnnGetErrorString(status),                                                        \
+            ". This error may appear if you passed in a non-contiguous input.", ##__VA_ARGS__); \
+      } else {                                                                                  \
+        TORCH_CHECK_WITH(CuDNNError, false,                                                     \
+            "cuDNN error: ", cudnnGetErrorString(status), ##__VA_ARGS__);                       \
+      }                                                                                         \
+    }                                                                                           \
+  } while (0)
+
+namespace at::cuda::blas {
+C10_EXPORT const char* _cublasGetErrorEnum(cublasStatus_t error);
+} // namespace at::cuda::blas
+
+#define TORCH_CUDABLAS_CHECK(EXPR)                              \
+  do {                                                          \
+    cublasStatus_t __err = EXPR;                                \
+    TORCH_CHECK(__err == CUBLAS_STATUS_SUCCESS,                 \
+                "CUDA error: ",                                 \
+                at::cuda::blas::_cublasGetErrorEnum(__err),     \
+                " when calling `" #EXPR "`");                   \
+  } while (0)
+
+const char *cusparseGetErrorString(cusparseStatus_t status);
+
+#define TORCH_CUDASPARSE_CHECK(EXPR)                            \
+  do {                                                          \
+    cusparseStatus_t __err = EXPR;                              \
+    TORCH_CHECK(__err == CUSPARSE_STATUS_SUCCESS,               \
+                "CUDA error: ",                                 \
+                cusparseGetErrorString(__err),                  \
+                " when calling `" #EXPR "`");                   \
+  } while (0)
+
+// cusolver related headers are only supported on cuda now
+#ifdef CUDART_VERSION
+
+namespace at::cuda::solver {
+C10_EXPORT const char* cusolverGetErrorMessage(cusolverStatus_t status);
+
+constexpr const char* _cusolver_backend_suggestion =            \
+  "If you keep seeing this error, you may use "                 \
+  "`torch.backends.cuda.preferred_linalg_library()` to try "    \
+  "linear algebra operators with other supported backends. "    \
+  "See https://pytorch.org/docs/stable/backends.html#torch.backends.cuda.preferred_linalg_library";
+
+} // namespace at::cuda::solver
+
+// When cuda < 11.5, cusolver raises CUSOLVER_STATUS_EXECUTION_FAILED when input contains nan.
+// When cuda >= 11.5, cusolver normally finishes execution and sets info array indicating convergence issue.
+#define TORCH_CUSOLVER_CHECK(EXPR)                                      \
+  do {                                                                  \
+    cusolverStatus_t __err = EXPR;                                      \
+    if ((CUDA_VERSION < 11500 &&                                        \
+         __err == CUSOLVER_STATUS_EXECUTION_FAILED) ||                  \
+        (CUDA_VERSION >= 11500 &&                                       \
+         __err == CUSOLVER_STATUS_INVALID_VALUE)) {                     \
+      TORCH_CHECK_LINALG(                                               \
+          false,                                                        \
+          "cusolver error: ",                                           \
+          at::cuda::solver::cusolverGetErrorMessage(__err),             \
+          ", when calling `" #EXPR "`",                                 \
+          ". This error may appear if the input matrix contains NaN. ", \
+          at::cuda::solver::_cusolver_backend_suggestion);              \
+    } else {                                                            \
+      TORCH_CHECK(                                                      \
+          __err == CUSOLVER_STATUS_SUCCESS,                             \
+          "cusolver error: ",                                           \
+          at::cuda::solver::cusolverGetErrorMessage(__err),             \
+          ", when calling `" #EXPR "`. ",                               \
+          at::cuda::solver::_cusolver_backend_suggestion);              \
+    }                                                                   \
+  } while (0)
+
+#else
+#define TORCH_CUSOLVER_CHECK(EXPR) EXPR
+#endif
+
+#define AT_CUDA_CHECK(EXPR) C10_CUDA_CHECK(EXPR)
+
+// For CUDA Driver API
+//
+// This is here instead of in c10 because NVRTC is loaded dynamically via a stub
+// in ATen, and we need to use its nvrtcGetErrorString.
+// See NOTE [ USE OF NVRTC AND DRIVER API ].
+#if !defined(USE_ROCM)
+
+#define AT_CUDA_DRIVER_CHECK(EXPR)                                                                               \
+  do {                                                                                                           \
+    CUresult __err = EXPR;                                                                                       \
+    if (__err != CUDA_SUCCESS) {                                                                                 \
+      const char* err_str;                                                                                       \
+      CUresult get_error_str_err C10_UNUSED = at::globalContext().getNVRTC().cuGetErrorString(__err, &err_str);  \
+      if (get_error_str_err != CUDA_SUCCESS) {                                                                   \
+        AT_ERROR("CUDA driver error: unknown error");                                                            \
+      } else {                                                                                                   \
+        AT_ERROR("CUDA driver error: ", err_str);                                                                \
+      }                                                                                                          \
+    }                                                                                                            \
+  } while (0)
+
+#else
+
+#define AT_CUDA_DRIVER_CHECK(EXPR)                                                \
+  do {                                                                            \
+    CUresult __err = EXPR;                                                        \
+    if (__err != CUDA_SUCCESS) {                                                  \
+      AT_ERROR("CUDA driver error: ", static_cast<int>(__err));                   \
+    }                                                                             \
+  } while (0)
+
+#endif
+
+// For CUDA NVRTC
+//
+// Note: As of CUDA 10, nvrtc error code 7, NVRTC_ERROR_BUILTIN_OPERATION_FAILURE,
+// incorrectly produces the error string "NVRTC unknown error."
+// The following maps it correctly.
+//
+// This is here instead of in c10 because NVRTC is loaded dynamically via a stub
+// in ATen, and we need to use its nvrtcGetErrorString.
+// See NOTE [ USE OF NVRTC AND DRIVER API ].
+#define AT_CUDA_NVRTC_CHECK(EXPR)                                                                   \
+  do {                                                                                              \
+    nvrtcResult __err = EXPR;                                                                       \
+    if (__err != NVRTC_SUCCESS) {                                                                   \
+      if (static_cast<int>(__err) != 7) {                                                           \
+        AT_ERROR("CUDA NVRTC error: ", at::globalContext().getNVRTC().nvrtcGetErrorString(__err));  \
+      } else {                                                                                      \
+        AT_ERROR("CUDA NVRTC error: NVRTC_ERROR_BUILTIN_OPERATION_FAILURE");                        \
+      }                                                                                             \
+    }                                                                                               \
+  } while (0)

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/PeerToPeerAccess.h

@@ -0,0 +1,11 @@
+#include <c10/macros/Macros.h>
+#include <cstdint>
+
+namespace at::cuda {
+namespace detail {
+void init_p2p_access_cache(int64_t num_devices);
+}
+
+TORCH_CUDA_CPP_API bool get_p2p_access(int source_dev, int dest_dev);
+
+}  // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/PhiloxCudaState.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <cstdint>
+
+#include <ATen/cuda/detail/PhiloxCudaStateRaw.cuh>

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/PhiloxUtils.cuh

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <ATen/cuda/PhiloxCudaState.h>
+#include <ATen/cuda/detail/UnpackRaw.cuh>

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/PinnedMemoryAllocator.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <c10/core/Allocator.h>
+#include <ATen/cuda/CachingHostAllocator.h>
+
+namespace at::cuda {
+
+inline TORCH_CUDA_CPP_API at::Allocator* getPinnedMemoryAllocator() {
+  return getCachingHostAllocator();
+}
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/ScanUtils.cuh

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <ATen/ceil_div.h>
+#include <ATen/cuda/DeviceUtils.cuh>
+#include <ATen/cuda/AsmUtils.cuh>
+#include <c10/macros/Macros.h>
+
+// Collection of in-kernel scan / prefix sum utilities
+
+namespace at::cuda {
+
+// Inclusive prefix sum for binary vars using intra-warp voting +
+// shared memory
+template <typename T, bool KillWARDependency, class BinaryFunction>
+__device__ void inclusiveBinaryPrefixScan(T* smem, bool in, T* out, BinaryFunction binop) {
+  // Within-warp, we use warp voting.
+#if defined (USE_ROCM)
+  unsigned long long int vote = WARP_BALLOT(in);
+  T index = __popcll(getLaneMaskLe() & vote);
+  T carry = __popcll(vote);
+#else
+  T vote = WARP_BALLOT(in);
+  T index = __popc(getLaneMaskLe() & vote);
+  T carry = __popc(vote);
+#endif
+
+  int warp = threadIdx.x / C10_WARP_SIZE;
+
+  // Per each warp, write out a value
+  if (getLaneId() == 0) {
+    smem[warp] = carry;
+  }
+
+  __syncthreads();
+
+  // Sum across warps in one thread. This appears to be faster than a
+  // warp shuffle scan for CC 3.0+
+  if (threadIdx.x == 0) {
+    int current = 0;
+    for (int i = 0; i < blockDim.x / C10_WARP_SIZE; ++i) {
+      T v = smem[i];
+      smem[i] = binop(smem[i], current);
+      current = binop(current, v);
+    }
+  }
+
+  __syncthreads();
+
+  // load the carry from the preceding warp
+  if (warp >= 1) {
+    index = binop(index, smem[warp - 1]);
+  }
+
+  *out = index;
+
+  if (KillWARDependency) {
+    __syncthreads();
+  }
+}
+
+// Exclusive prefix sum for binary vars using intra-warp voting +
+// shared memory
+template <typename T, bool KillWARDependency, class BinaryFunction>
+__device__ void exclusiveBinaryPrefixScan(T* smem, bool in, T* out, T* carry, BinaryFunction binop) {
+  inclusiveBinaryPrefixScan<T, false, BinaryFunction>(smem, in, out, binop);
+
+  // Inclusive to exclusive
+  *out -= (T) in;
+
+  // The outgoing carry for all threads is the last warp's sum
+  *carry = smem[at::ceil_div<int>(blockDim.x, C10_WARP_SIZE) - 1];
+
+  if (KillWARDependency) {
+    __syncthreads();
+  }
+}
+
+}  // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/cub.h

@@ -0,0 +1,87 @@
+#pragma once
+#include <cstdint>
+#include <c10/core/ScalarType.h>
+#include <ATen/cuda/CUDAConfig.h>
+
+// NOTE: These templates are intentionally not defined in this header,
+// which aviods re-compiling them for each translation unit. If you get
+// a link error, you need to add an explicit instantiation for your
+// types in cub.cu
+
+namespace at::cuda::cub {
+
+inline int get_num_bits(uint64_t max_key) {
+  int num_bits = 1;
+  while (max_key > 1) {
+    max_key >>= 1;
+    num_bits++;
+  }
+  return num_bits;
+}
+
+namespace detail {
+
+// radix_sort_pairs doesn't interact with value_t other than to copy
+// the data, so we can save template instantiations by reinterpreting
+// it as an opaque type.
+template <int N> struct alignas(N) OpaqueType { char data[N]; };
+
+template<typename key_t, int value_size>
+void radix_sort_pairs_impl(
+    const key_t *keys_in, key_t *keys_out,
+    const OpaqueType<value_size> *values_in, OpaqueType<value_size> *values_out,
+    int64_t n, bool descending, int64_t begin_bit, int64_t end_bit);
+
+}  // namespace detail
+
+template<typename key_t, typename value_t>
+void radix_sort_pairs(
+    const key_t *keys_in, key_t *keys_out,
+    const value_t *values_in, value_t *values_out,
+    int64_t n, bool descending=false, int64_t begin_bit=0, int64_t end_bit=sizeof(key_t)*8) {
+  static_assert(std::is_trivially_copyable_v<value_t> ||
+                AT_ROCM_ENABLED(),  // ROCm incorrectly fails this check for vector types
+                "radix_sort_pairs value type must be trivially copyable");
+  // Make value type opaque, so all inputs of a certain size use the same template instantiation
+  using opaque_t = detail::OpaqueType<sizeof(value_t)>;
+  static_assert(sizeof(value_t) <= 8 && (sizeof(value_t) & (sizeof(value_t) - 1)) == 0,
+                "This size of value_t is not instantiated. Please instantiate it in cub.cu"
+                " and modify this check.");
+  static_assert(sizeof(value_t) == alignof(value_t), "Expected value_t to be size-aligned");
+  detail::radix_sort_pairs_impl(
+      keys_in, keys_out,
+      reinterpret_cast<const opaque_t*>(values_in),
+      reinterpret_cast<opaque_t*>(values_out),
+      n, descending, begin_bit, end_bit);
+}
+
+template<typename key_t>
+void radix_sort_keys(
+    const key_t *keys_in, key_t *keys_out,
+    int64_t n, bool descending=false, int64_t begin_bit=0, int64_t end_bit=sizeof(key_t)*8);
+
+// NOTE: Intermediate sums will be truncated to input_t precision
+template <typename input_t, typename output_t>
+void inclusive_sum_truncating(const input_t *input, output_t *output, int64_t n);
+
+template <typename scalar_t>
+void inclusive_sum(const scalar_t *input, scalar_t *output, int64_t n) {
+  return inclusive_sum_truncating(input, output, n);
+}
+
+// NOTE: Sums are done is common_type<input_t, output_t>
+template <typename input_t, typename output_t>
+void exclusive_sum_in_common_type(const input_t *input, output_t *output, int64_t n);
+
+template <typename scalar_t>
+void exclusive_sum(const scalar_t *input, scalar_t *output, int64_t n) {
+  return exclusive_sum_in_common_type(input, output, n);
+}
+
+void mask_exclusive_sum(const uint8_t *mask, int64_t *output_idx, int64_t n);
+inline void mask_exclusive_sum(const bool *mask, int64_t *output_idx, int64_t n) {
+  return mask_exclusive_sum(
+      reinterpret_cast<const uint8_t*>(mask), output_idx, n);
+}
+
+}  // namespace at::cuda::cub

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/cub_definitions.cuh

@@ -0,0 +1,53 @@
+#pragma once
+
+#if !defined(USE_ROCM)
+#include <cuda.h>  // for CUDA_VERSION
+#endif
+
+#if !defined(USE_ROCM)
+#include <cub/version.cuh>
+#else
+#define CUB_VERSION 0
+#endif
+
+// cub sort support for __nv_bfloat16 is added to cub 1.13 in:
+// https://github.com/NVIDIA/cub/pull/306
+#if CUB_VERSION >= 101300
+#define CUB_SUPPORTS_NV_BFLOAT16() true
+#else
+#define CUB_SUPPORTS_NV_BFLOAT16() false
+#endif
+
+// cub support for CUB_WRAPPED_NAMESPACE is added to cub 1.13.1 in:
+// https://github.com/NVIDIA/cub/pull/326
+// CUB_WRAPPED_NAMESPACE is defined globally in cmake/Dependencies.cmake
+// starting from CUDA 11.5
+#if defined(CUB_WRAPPED_NAMESPACE) || defined(THRUST_CUB_WRAPPED_NAMESPACE)
+#define USE_GLOBAL_CUB_WRAPPED_NAMESPACE() true
+#else
+#define USE_GLOBAL_CUB_WRAPPED_NAMESPACE() false
+#endif
+
+// cub support for UniqueByKey is added to cub 1.16 in:
+// https://github.com/NVIDIA/cub/pull/405
+#if CUB_VERSION >= 101600
+#define CUB_SUPPORTS_UNIQUE_BY_KEY() true
+#else
+#define CUB_SUPPORTS_UNIQUE_BY_KEY() false
+#endif
+
+// cub support for scan by key is added to cub 1.15
+// in https://github.com/NVIDIA/cub/pull/376
+#if CUB_VERSION >= 101500
+#define CUB_SUPPORTS_SCAN_BY_KEY() 1
+#else
+#define CUB_SUPPORTS_SCAN_BY_KEY() 0
+#endif
+
+// cub support for cub::FutureValue is added to cub 1.15 in:
+// https://github.com/NVIDIA/cub/pull/305
+#if CUB_VERSION >= 101500
+#define CUB_SUPPORTS_FUTURE_VALUE() true
+#else
+#define CUB_SUPPORTS_FUTURE_VALUE() false
+#endif

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/detail/LazyNVRTC.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <ATen/detail/CUDAHooksInterface.h>
+namespace at::cuda {
+// Forward-declares at::cuda::NVRTC
+struct NVRTC;
+
+namespace detail {
+extern NVRTC lazyNVRTC;
+} // namespace detail
+
+}  // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/detail/PhiloxCudaStateRaw.cuh

@@ -0,0 +1,43 @@
+// No "#pragma once" because this is a raw definition that can be copied by jit codegen.
+// Eager mode clients should not include this file directly, instead,
+// they should #include <ATen/cuda/PhiloxCudaState.h>, which has a #pragma once.
+
+// Stores RNG state values. Passed as a kernel argument.
+// See Note [CUDA Graph-safe RNG states].
+//
+// The raw definition lives in its own file so jit codegen can easily copy it.
+namespace at {
+
+struct PhiloxCudaState {
+  PhiloxCudaState() = default;
+  // Called if graph capture is not underway
+  PhiloxCudaState(uint64_t seed,
+                  uint64_t offset) {
+    seed_.val = seed;
+    offset_.val = offset;
+  }
+  // Called if graph capture is underway
+  PhiloxCudaState(int64_t* seed,
+                  int64_t* offset_extragraph,
+                  uint32_t offset_intragraph) {
+    seed_.ptr = seed;
+    offset_.ptr = offset_extragraph;
+    offset_intragraph_ = offset_intragraph;
+    captured_ = true;
+  }
+
+  // Public members, directly accessible by at::cuda::philox::unpack.
+  // If we made them private with getters/setters, the getters/setters
+  // would have to be __device__, and we can't declare __device__ in ATen.
+  union Payload {
+    uint64_t val;
+    int64_t* ptr;
+  };
+
+  Payload seed_{};
+  Payload offset_{};
+  uint32_t offset_intragraph_ = 0;
+  bool captured_ = false;
+};
+
+} // namespace at

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/jiterator_impl.h

@@ -0,0 +1,249 @@
+#pragma once
+#include <ATen/jit_macros.h>
+
+#if AT_USE_JITERATOR()
+
+#include <ATen/native/TensorIterator.h>
+#include <ATen/cuda/detail/OffsetCalculator.cuh>
+#include <ATen/native/cuda/jit_utils.h>
+#include <ATen/native/cuda/MemoryAccess.cuh>
+#include <ATen/native/cuda/JitLoops.cuh>
+
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace at::native {
+
+
+#define AT_FOR_8_CASES(_)  \
+  _(1)                      \
+  _(2)                      \
+  _(3)                      \
+  _(4)                      \
+  _(5)                      \
+  _(6)                      \
+  _(7)                      \
+  _(8)
+
+#define AT_FOR_8_CASES_WITH_COMMA(_)  \
+  _(1)     ,                           \
+  _(2)     ,                           \
+  _(3)     ,                           \
+  _(4)     ,                           \
+  _(5)     ,                           \
+  _(6)     ,                           \
+  _(7)     ,                           \
+  _(8)
+
+c10::SmallVector<std::string> get_extra_args_typenames(const c10::SmallVector<at::Scalar>& extra_args) {
+  c10::SmallVector<std::string> args_typenames(extra_args.size());
+  for (const auto i : c10::irange(extra_args.size())) {
+    args_typenames[i] = at::cuda::jit::typeName(extra_args[i].type());
+  }
+  return args_typenames;
+}
+
+int can_vectorize_up_to(at::ScalarType type, char* pointer) {
+  switch(type) {
+#define DEFINE_CASE(ctype, scalartype)                                   \
+    case ScalarType::scalartype : return memory::can_vectorize_up_to<ctype>(pointer);
+
+    AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_CASE)
+#undef DEFINE_CASE
+
+    default: TORCH_INTERNAL_ASSERT(false, "Unrecognized ScalarType: ", type);
+  }
+}
+
+// jitted version of the above
+// See Note [Jiterator], this relies on the assumptions enumerated there
+int jitted_can_vectorize_up_to(const TensorIteratorBase& iter) {
+  const at::ScalarType common_dtype = iter.common_dtype();
+  const at::ScalarType result_dtype = common_dtype;
+
+  // Deals with output
+  int result = can_vectorize_up_to(result_dtype, static_cast<char*>(iter.data_ptr(0)));
+
+  // Incorporates input(s)
+  for (auto i = 1; i < iter.ntensors(); ++i) {
+    result = std::min<int>(result, can_vectorize_up_to(common_dtype, static_cast<char*>(iter.data_ptr(i))));
+  }
+
+  return result;
+}
+
+template<bool IS_INPUT, int N>
+static std::unique_ptr<OffsetCalculator<N>> make_unique_offset_calculator(
+          const TensorIteratorBase& iter) {
+  // array size can not be 0, this happens when N == 0
+  constexpr int array_size = std::max<int>(N, 1);
+  TORCH_INTERNAL_ASSERT(N == (IS_INPUT ? iter.ninputs() : iter.noutputs()));
+
+  std::array<const int64_t*, array_size> strides;
+  int64_t element_sizes[array_size];
+  for (int i = 0; i < N; i++) {
+    int index = IS_INPUT ? i + iter.noutputs() : i;
+    strides[i] = iter.strides(index).data();
+    element_sizes[i] = iter.element_size(index);
+  }
+  return std::make_unique<OffsetCalculator<N>>(iter.ndim(), iter.shape().data(), strides.data(), element_sizes);
+}
+
+template <bool IS_INPUT>
+struct OffsetCalculatorVariant {
+#define DEFINE_CASE(index) std::unique_ptr<OffsetCalculator<index>>
+  using OffsetCalculatorTypes = std::variant<
+    AT_FOR_8_CASES_WITH_COMMA(DEFINE_CASE)
+  >;
+#undef DEFINE_CASE
+
+  OffsetCalculatorVariant(const TensorIteratorBase& iter) {
+    int num = IS_INPUT ? iter.ninputs() : iter.noutputs();
+
+    switch(num) {
+#define DEFINE_CASE(index)        \
+      case index : v = make_unique_offset_calculator<IS_INPUT, index>(iter); break;
+
+      AT_FOR_8_CASES(DEFINE_CASE)
+#undef DEFINE_CASE
+      default:
+        TORCH_CHECK(false, "OffsetCalculatorVariant is not implemented for num_tensor = ", num);
+    }
+  }
+
+  void* data_ptr() {
+    return std::visit([](auto & v){ return static_cast<void*>(v.get()); }, v);
+  }
+
+ private:
+  OffsetCalculatorTypes v{};
+};
+
+struct ArrayVariant {
+// works for up to 8 input + 8 outputs
+#define DEFINE_CASE(index) at::detail::Array<char*, index>, at::detail::Array<char*, index+8>
+  using ArrayTypes = std::variant<
+    AT_FOR_8_CASES_WITH_COMMA(DEFINE_CASE)
+  >;
+#undef DEFINE_CASE
+
+  ArrayVariant(const TensorIteratorBase& iter) {
+    int ntensors = iter.ntensors();
+    switch(ntensors) {
+#define DEFINE_CASE(index)                                            \
+      case index: array = at::detail::Array<char*, index>{}; break;   \
+      case index+8: array = at::detail::Array<char*, index+8>{}; break;
+
+      AT_FOR_8_CASES(DEFINE_CASE)
+#undef DEFINE_CASE
+
+      default:
+        TORCH_CHECK(false, "ArrayVariant is not implemented for ntensors = ", ntensors);
+    }
+
+    std::visit([&](auto& a) {
+      for (auto i = 0; i < ntensors; ++i) {
+        a[i] = (char*)iter.data_ptr(i);
+      }
+    }, array);
+  }
+
+  void* data_ptr() {
+    return std::visit([](auto & a){ return static_cast<void*>(&a); }, array);
+  }
+
+private:
+  ArrayTypes array;
+};
+
+struct TrivialOffsetCalculatorVariant {
+#define DEFINE_CASE(index) TrivialOffsetCalculator<index>
+  using TrivialOffsetCalculatorTypes = std::variant<
+    AT_FOR_8_CASES_WITH_COMMA(DEFINE_CASE)
+  >;
+#undef DEFINE_CASE
+
+  TrivialOffsetCalculatorVariant(int num) {
+    switch(num) {
+#define DEFINE_CASE(index)      \
+      case index: v = TrivialOffsetCalculator<index>(); break;
+
+      AT_FOR_8_CASES(DEFINE_CASE)
+#undef DEFINE_CASE
+
+      default:
+        TORCH_CHECK(false, "TrivialOffsetCalculatorVariant is not implemented for num_tensors = ", num);
+    }
+  }
+
+  void* data_ptr() {
+    return std::visit([](auto & v){ return static_cast<void*>(&v); }, v);
+  }
+
+private:
+  TrivialOffsetCalculatorTypes v{};
+};
+
+struct LoadWithCastVariant {
+#define DEFINE_CASE(index) std::unique_ptr<memory::LoadWithCast<index>>
+  using LoadWithCastPtr = std::variant<
+    AT_FOR_8_CASES_WITH_COMMA(DEFINE_CASE)
+  >;
+#undef DEFINE_CASE
+
+  LoadWithCastVariant(const TensorIteratorBase& iter) {
+    int arity = iter.ninputs();
+    switch(arity) {
+#define DEFINE_CASE(index)      \
+      case index: v = std::make_unique<memory::LoadWithCast<index>>(iter); break;
+
+      AT_FOR_8_CASES(DEFINE_CASE)
+#undef DEFINE_CASE
+
+      default:
+        TORCH_CHECK(false, "LoadWithCastVariant is not implemented for ninputs = ", arity);
+    }
+  }
+
+  void* data_ptr() {
+    return std::visit([](auto & v){ return static_cast<void*>(v.get()); }, v);
+  }
+
+private:
+  LoadWithCastPtr v{};
+};
+
+struct StoreWithCastVariant {
+#define DEFINE_CASE(index) std::unique_ptr<memory::StoreWithCast<index>>
+  using StoreWithCastPtr = std::variant<
+    AT_FOR_8_CASES_WITH_COMMA(DEFINE_CASE)
+  >;
+#undef DEFINE_CASE
+
+  StoreWithCastVariant(const TensorIteratorBase& iter) {
+    int num = iter.noutputs();
+    switch(num) {
+#define DEFINE_CASE(index)      \
+      case index: v = std::make_unique<memory::StoreWithCast<index>>(iter); break;
+
+      AT_FOR_8_CASES(DEFINE_CASE)
+#undef DEFINE_CASE
+
+      default:
+        TORCH_CHECK(false, "StoreWithCastVariant is not implemented for noutputs = ", num);
+    }
+  }
+
+  void* data_ptr() {
+    return std::visit([](auto & v){ return static_cast<void*>(v.get()); }, v);
+  }
+
+private:
+  StoreWithCastPtr v{};
+};
+
+} // namespace at::native
+
+
+#endif // AT_USE_JITERATOR()

parrot/lib/python3.10/site-packages/torch/include/ATen/cuda/llvm_jit_strings.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <string>
+#include <c10/macros/Export.h>
+
+namespace at::cuda {
+
+TORCH_CUDA_CPP_API const std::string &get_traits_string();
+TORCH_CUDA_CPP_API const std::string &get_cmath_string();
+TORCH_CUDA_CPP_API const std::string &get_complex_body_string();
+TORCH_CUDA_CPP_API const std::string &get_complex_half_body_string();
+TORCH_CUDA_CPP_API const std::string &get_complex_math_string();
+
+} // namespace at::cuda

parrot/lib/python3.10/site-packages/torch/include/ATen/miopen/Exceptions.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <ATen/miopen/miopen-wrapper.h>
+#include <string>
+#include <stdexcept>
+#include <sstream>
+
+namespace at { namespace native {
+
+class miopen_exception : public std::runtime_error {
+public:
+  miopenStatus_t status;
+  miopen_exception(miopenStatus_t status, const char* msg)
+      : std::runtime_error(msg)
+      , status(status) {}
+  miopen_exception(miopenStatus_t status, const std::string& msg)
+      : std::runtime_error(msg)
+      , status(status) {}
+};
+
+inline void MIOPEN_CHECK(miopenStatus_t status)
+{
+  if (status != miopenStatusSuccess) {
+    if (status == miopenStatusNotImplemented) {
+        throw miopen_exception(status, std::string(miopenGetErrorString(status)) +
+                ". This error may appear if you passed in a non-contiguous input.");
+    }
+    throw miopen_exception(status, miopenGetErrorString(status));
+  }
+}
+
+inline void HIP_CHECK(hipError_t error)
+{
+  if (error != hipSuccess) {
+    std::string msg("HIP error: ");
+    msg += hipGetErrorString(error);
+    throw std::runtime_error(msg);
+  }
+}
+
+}} // namespace at::native

videollama2/lib/python3.10/site-packages/latex2mathml/__init__.py

@@ -0,0 +1,3 @@
+from importlib import metadata
+
+__version__ = metadata.version("latex2mathml")

videollama2/lib/python3.10/site-packages/latex2mathml/commands.py

@@ -0,0 +1,506 @@
+from collections import OrderedDict, defaultdict
+from typing import DefaultDict, Dict, Optional, Tuple
+
+OPENING_BRACE = "{"
+CLOSING_BRACE = "}"
+BRACES = "{}"
+
+OPENING_BRACKET = "["
+CLOSING_BRACKET = "]"
+BRACKETS = "[]"
+
+OPENING_PARENTHESIS = "("
+CLOSING_PARENTHESIS = ")"
+PARENTHESES = "()"
+
+SUBSUP = "_^"
+SUBSCRIPT = "_"
+SUPERSCRIPT = "^"
+APOSTROPHE = "'"
+PRIME = r"\prime"
+DPRIME = r"\dprime"
+
+LEFT = r"\left"
+MIDDLE = r"\middle"
+RIGHT = r"\right"
+
+ABOVE = r"\above"
+ABOVEWITHDELIMS = r"\abovewithdelims"
+ATOP = r"\atop"
+ATOPWITHDELIMS = r"\atopwithdelims"
+BINOM = r"\binom"
+BRACE = r"\brace"
+BRACK = r"\brack"
+CFRAC = r"\cfrac"
+CHOOSE = r"\choose"
+DBINOM = r"\dbinom"
+DFRAC = r"\dfrac"
+FRAC = r"\frac"
+GENFRAC = r"\genfrac"
+OVER = r"\over"
+TBINOM = r"\tbinom"
+TFRAC = r"\tfrac"
+
+ROOT = r"\root"
+SQRT = r"\sqrt"
+
+OVERSET = r"\overset"
+UNDERSET = r"\underset"
+
+ACUTE = r"\acute"
+BAR = r"\bar"
+BREVE = r"\breve"
+CHECK = r"\check"
+DOT = r"\dot"
+DDOT = r"\ddot"
+DDDOT = r"\dddot"
+DDDDOT = r"\ddddot"
+GRAVE = r"\grave"
+HAT = r"\hat"
+MATHRING = r"\mathring"
+OVERBRACE = r"\overbrace"
+OVERLEFTARROW = r"\overleftarrow"
+OVERLEFTRIGHTARROW = r"\overleftrightarrow"
+OVERLINE = r"\overline"
+OVERPAREN = r"\overparen"
+OVERRIGHTARROW = r"\overrightarrow"
+TILDE = r"\tilde"
+UNDERBRACE = r"\underbrace"
+UNDERLEFTARROW = r"\underleftarrow"
+UNDERLINE = r"\underline"
+UNDERPAREN = r"\underparen"
+UNDERRIGHTARROW = r"\underrightarrow"
+UNDERLEFTRIGHTARROW = r"\underleftrightarrow"
+VEC = r"\vec"
+WIDEHAT = r"\widehat"
+WIDETILDE = r"\widetilde"
+XLEFTARROW = r"\xleftarrow"
+XRIGHTARROW = r"\xrightarrow"
+
+HREF = r"\href"
+TEXT = r"\text"
+TEXTBF = r"\textbf"
+TEXTIT = r"\textit"
+TEXTRM = r"\textrm"
+TEXTSF = r"\textsf"
+TEXTTT = r"\texttt"
+
+BEGIN = r"\begin"
+END = r"\end"
+
+LIMITS = r"\limits"
+INTEGRAL = r"\int"
+SUMMATION = r"\sum"
+LIMIT = (r"\lim", r"\sup", r"\inf", r"\max", r"\min")
+
+OPERATORNAME = r"\operatorname"
+
+LBRACE = r"\{"
+
+FUNCTIONS = (
+    r"\arccos",
+    r"\arcsin",
+    r"\arctan",
+    r"\cos",
+    r"\cosh",
+    r"\cot",
+    r"\coth",
+    r"\csc",
+    r"\deg",
+    r"\dim",
+    r"\exp",
+    r"\hom",
+    r"\ker",
+    r"\ln",
+    r"\lg",
+    r"\log",
+    r"\sec",
+    r"\sin",
+    r"\sinh",
+    r"\tan",
+    r"\tanh",
+)
+DETERMINANT = r"\det"
+GCD = r"\gcd"
+INTOP = r"\intop"
+INJLIM = r"\injlim"
+LIMINF = r"\liminf"
+LIMSUP = r"\limsup"
+PR = r"\Pr"
+PROJLIM = r"\projlim"
+MOD = r"\mod"
+PMOD = r"\pmod"
+BMOD = r"\bmod"
+
+HDASHLINE = r"\hdashline"
+HLINE = r"\hline"
+HFIL = r"\hfil"
+
+CASES = r"\cases"
+DISPLAYLINES = r"\displaylines"
+SMALLMATRIX = r"\smallmatrix"
+SUBSTACK = r"\substack"
+SPLIT = r"\split"
+ALIGN = r"\align*"
+MATRICES = (
+    r"\matrix",
+    r"\matrix*",
+    r"\pmatrix",
+    r"\pmatrix*",
+    r"\bmatrix",
+    r"\bmatrix*",
+    r"\Bmatrix",
+    r"\Bmatrix*",
+    r"\vmatrix",
+    r"\vmatrix*",
+    r"\Vmatrix",
+    r"\Vmatrix*",
+    r"\array",
+    SUBSTACK,
+    CASES,
+    DISPLAYLINES,
+    SMALLMATRIX,
+    SPLIT,
+    ALIGN,
+)
+
+BACKSLASH = "\\"
+CARRIAGE_RETURN = r"\cr"
+
+COLON = r"\:"
+COMMA = r"\,"
+DOUBLEBACKSLASH = r"\\"
+ENSPACE = r"\enspace"
+EXCLAMATION = r"\!"
+GREATER_THAN = r"\>"
+HSKIP = r"\hskip"
+HSPACE = r"\hspace"
+KERN = r"\kern"
+MKERN = r"\mkern"
+MSKIP = r"\mskip"
+MSPACE = r"\mspace"
+NEGTHINSPACE = r"\negthinspace"
+NEGMEDSPACE = r"\negmedspace"
+NEGTHICKSPACE = r"\negthickspace"
+NOBREAKSPACE = r"\nobreakspace"
+SPACE = r"\space"
+THINSPACE = r"\thinspace"
+QQUAD = r"\qquad"
+QUAD = r"\quad"
+SEMICOLON = r"\;"
+
+BLACKBOARD_BOLD = r"\Bbb"
+BOLD_SYMBOL = r"\boldsymbol"
+MIT = r"\mit"
+OLDSTYLE = r"\oldstyle"
+SCR = r"\scr"
+TT = r"\tt"
+
+MATH = r"\math"
+MATHBB = r"\mathbb"
+MATHBF = r"\mathbf"
+MATHCAL = r"\mathcal"
+MATHFRAK = r"\mathfrak"
+MATHIT = r"\mathit"
+MATHRM = r"\mathrm"
+MATHSCR = r"\mathscr"
+MATHSF = r"\mathsf"
+MATHTT = r"\mathtt"
+
+BOXED = r"\boxed"
+FBOX = r"\fbox"
+HBOX = r"\hbox"
+MBOX = r"\mbox"
+
+COLOR = r"\color"
+DISPLAYSTYLE = r"\displaystyle"
+TEXTSTYLE = r"\textstyle"
+SCRIPTSTYLE = r"\scriptstyle"
+SCRIPTSCRIPTSTYLE = r"\scriptscriptstyle"
+STYLE = r"\style"
+
+HPHANTOM = r"\hphantom"
+PHANTOM = r"\phantom"
+VPHANTOM = r"\vphantom"
+
+IDOTSINT = r"\idotsint"
+LATEX = r"\LaTeX"
+TEX = r"\TeX"
+
+SIDESET = r"\sideset"
+
+SKEW = r"\skew"
+NOT = r"\not"
+
+
+def font_factory(default: Optional[str], replacement: Dict[str, Optional[str]]) -> DefaultDict[str, Optional[str]]:
+    fonts = defaultdict(lambda: default, replacement)
+    return fonts
+
+
+LOCAL_FONTS: Dict[str, DefaultDict[str, Optional[str]]] = {
+    BLACKBOARD_BOLD: font_factory("double-struck", {"fence": None}),
+    BOLD_SYMBOL: font_factory("bold", {"mi": "bold-italic", "mtext": None}),
+    MATHBB: font_factory("double-struck", {"fence": None}),
+    MATHBF: font_factory("bold", {"fence": None}),
+    MATHCAL: font_factory("script", {"fence": None}),
+    MATHFRAK: font_factory("fraktur", {"fence": None}),
+    MATHIT: font_factory("italic", {"fence": None}),
+    MATHRM: font_factory(None, {"mi": "normal"}),
+    MATHSCR: font_factory("script", {"fence": None}),
+    MATHSF: font_factory(None, {"mi": "sans-serif"}),
+    MATHTT: font_factory("monospace", {"fence": None}),
+    MIT: font_factory("italic", {"fence": None, "mi": None}),
+    OLDSTYLE: font_factory("normal", {"fence": None}),
+    SCR: font_factory("script", {"fence": None}),
+    TT: font_factory("monospace", {"fence": None}),
+}
+
+OLD_STYLE_FONTS: Dict[str, DefaultDict[str, Optional[str]]] = {
+    r"\rm": font_factory(None, {"mi": "normal"}),
+    r"\bf": font_factory(None, {"mi": "bold"}),
+    r"\it": font_factory(None, {"mi": "italic"}),
+    r"\sf": font_factory(None, {"mi": "sans-serif"}),
+    r"\tt": font_factory(None, {"mi": "monospace"}),
+}
+
+GLOBAL_FONTS = {
+    **OLD_STYLE_FONTS,
+    r"\cal": font_factory("script", {"fence": None}),
+    r"\frak": font_factory("fraktur", {"fence": None}),
+}
+
+COMMANDS_WITH_ONE_PARAMETER = (
+    ACUTE,
+    BAR,
+    BLACKBOARD_BOLD,
+    BOLD_SYMBOL,
+    BOXED,
+    BREVE,
+    CHECK,
+    DOT,
+    DDOT,
+    DDDOT,
+    DDDDOT,
+    GRAVE,
+    HAT,
+    HPHANTOM,
+    MATHRING,
+    MIT,
+    MOD,
+    OLDSTYLE,
+    OVERBRACE,
+    OVERLEFTARROW,
+    OVERLEFTRIGHTARROW,
+    OVERLINE,
+    OVERPAREN,
+    OVERRIGHTARROW,
+    PHANTOM,
+    PMOD,
+    SCR,
+    TILDE,
+    TT,
+    UNDERBRACE,
+    UNDERLEFTARROW,
+    UNDERLINE,
+    UNDERPAREN,
+    UNDERRIGHTARROW,
+    UNDERLEFTRIGHTARROW,
+    VEC,
+    VPHANTOM,
+    WIDEHAT,
+    WIDETILDE,
+)
+COMMANDS_WITH_TWO_PARAMETERS = (
+    BINOM,
+    CFRAC,
+    DBINOM,
+    DFRAC,
+    FRAC,
+    OVERSET,
+    TBINOM,
+    TFRAC,
+    UNDERSET,
+)
+
+BIG: Dict[str, Tuple[str, dict]] = {
+    # command: (mathml_equivalent, attributes)
+    r"\Bigg": ("mo", OrderedDict([("minsize", "2.470em"), ("maxsize", "2.470em")])),
+    r"\bigg": ("mo", OrderedDict([("minsize", "2.047em"), ("maxsize", "2.047em")])),
+    r"\Big": ("mo", OrderedDict([("minsize", "1.623em"), ("maxsize", "1.623em")])),
+    r"\big": ("mo", OrderedDict([("minsize", "1.2em"), ("maxsize", "1.2em")])),
+}
+
+BIG_OPEN_CLOSE = {
+    command + postfix: (tag, OrderedDict([("stretchy", "true"), ("fence", "true"), *attrib.items()]))
+    for command, (tag, attrib) in BIG.items()
+    for postfix in "lmr"
+}
+
+MSTYLE_SIZES: Dict[str, Tuple[str, dict]] = {
+    # command: (mathml_equivalent, attributes)
+    r"\Huge": ("mstyle", {"mathsize": "2.49em"}),
+    r"\huge": ("mstyle", {"mathsize": "2.07em"}),
+    r"\LARGE": ("mstyle", {"mathsize": "1.73em"}),
+    r"\Large": ("mstyle", {"mathsize": "1.44em"}),
+    r"\large": ("mstyle", {"mathsize": "1.2em"}),
+    r"\normalsize": ("mstyle", {"mathsize": "1em"}),
+    r"\scriptsize": ("mstyle", {"mathsize": "0.7em"}),
+    r"\small": ("mstyle", {"mathsize": "0.85em"}),
+    r"\tiny": ("mstyle", {"mathsize": "0.5em"}),
+    r"\Tiny": ("mstyle", {"mathsize": "0.6em"}),
+}
+
+STYLES: Dict[str, Tuple[str, dict]] = {
+    DISPLAYSTYLE: ("mstyle", {"displaystyle": "true", "scriptlevel": "0"}),
+    TEXTSTYLE: ("mstyle", {"displaystyle": "false", "scriptlevel": "0"}),
+    SCRIPTSTYLE: ("mstyle", {"displaystyle": "false", "scriptlevel": "1"}),
+    SCRIPTSCRIPTSTYLE: ("mstyle", {"displaystyle": "false", "scriptlevel": "2"}),
+}
+
+CONVERSION_MAP: Dict[str, Tuple[str, dict]] = {
+    # command: (mathml_equivalent, attributes)
+    # tables
+    **{matrix: ("mtable", {}) for matrix in MATRICES},
+    DISPLAYLINES: ("mtable", {"rowspacing": "0.5em", "columnspacing": "1em", "displaystyle": "true"}),
+    SMALLMATRIX: ("mtable", {"rowspacing": "0.1em", "columnspacing": "0.2778em"}),
+    SPLIT: (
+        "mtable",
+        {"displaystyle": "true", "columnspacing": "0em", "rowspacing": "3pt"},
+    ),
+    ALIGN: (
+        "mtable",
+        {"displaystyle": "true", "rowspacing": "3pt"},
+    ),
+    # subscripts/superscripts
+    SUBSCRIPT: ("msub", {}),
+    SUPERSCRIPT: ("msup", {}),
+    SUBSUP: ("msubsup", {}),
+    # fractions
+    BINOM: ("mfrac", {"linethickness": "0"}),
+    CFRAC: ("mfrac", {}),
+    DBINOM: ("mfrac", {"linethickness": "0"}),
+    DFRAC: ("mfrac", {}),
+    FRAC: ("mfrac", {}),
+    GENFRAC: ("mfrac", {}),
+    TBINOM: ("mfrac", {"linethickness": "0"}),
+    TFRAC: ("mfrac", {}),
+    # over/under
+    ACUTE: ("mover", {}),
+    BAR: ("mover", {}),
+    BREVE: ("mover", {}),
+    CHECK: ("mover", {}),
+    DOT: ("mover", {}),
+    DDOT: ("mover", {}),
+    DDDOT: ("mover", {}),
+    DDDDOT: ("mover", {}),
+    GRAVE: ("mover", {}),
+    HAT: ("mover", {}),
+    LIMITS: ("munderover", {}),
+    MATHRING: ("mover", {}),
+    OVERBRACE: ("mover", {}),
+    OVERLEFTARROW: ("mover", {}),
+    OVERLEFTRIGHTARROW: ("mover", {}),
+    OVERLINE: ("mover", {}),
+    OVERPAREN: ("mover", {}),
+    OVERRIGHTARROW: ("mover", {}),
+    TILDE: ("mover", {}),
+    OVERSET: ("mover", {}),
+    UNDERBRACE: ("munder", {}),
+    UNDERLEFTARROW: ("munder", {}),
+    UNDERLINE: ("munder", {}),
+    UNDERPAREN: ("munder", {}),
+    UNDERRIGHTARROW: ("munder", {}),
+    UNDERLEFTRIGHTARROW: ("munder", {}),
+    UNDERSET: ("munder", {}),
+    VEC: ("mover", {}),
+    WIDEHAT: ("mover", {}),
+    WIDETILDE: ("mover", {}),
+    # spaces
+    COLON: ("mspace", {"width": "0.222em"}),
+    COMMA: ("mspace", {"width": "0.167em"}),
+    DOUBLEBACKSLASH: ("mspace", {"linebreak": "newline"}),
+    ENSPACE: ("mspace", {"width": "0.5em"}),
+    EXCLAMATION: ("mspace", {"width": "negativethinmathspace"}),
+    GREATER_THAN: ("mspace", {"width": "0.222em"}),
+    HSKIP: ("mspace", {}),
+    HSPACE: ("mspace", {}),
+    KERN: ("mspace", {}),
+    MKERN: ("mspace", {}),
+    MSKIP: ("mspace", {}),
+    MSPACE: ("mspace", {}),
+    NEGTHINSPACE: ("mspace", {"width": "negativethinmathspace"}),
+    NEGMEDSPACE: ("mspace", {"width": "negativemediummathspace"}),
+    NEGTHICKSPACE: ("mspace", {"width": "negativethickmathspace"}),
+    THINSPACE: ("mspace", {"width": "thinmathspace"}),
+    QQUAD: ("mspace", {"width": "2em"}),
+    QUAD: ("mspace", {"width": "1em"}),
+    SEMICOLON: ("mspace", {"width": "0.278em"}),
+    # enclose
+    BOXED: ("menclose", {"notation": "box"}),
+    FBOX: ("menclose", {"notation": "box"}),
+    # operators
+    **BIG,
+    **BIG_OPEN_CLOSE,
+    **MSTYLE_SIZES,
+    **{limit: ("mo", {}) for limit in LIMIT},
+    LEFT: ("mo", OrderedDict([("stretchy", "true"), ("fence", "true"), ("form", "prefix")])),
+    MIDDLE: ("mo", OrderedDict([("stretchy", "true"), ("fence", "true"), ("lspace", "0.05em"), ("rspace", "0.05em")])),
+    RIGHT: ("mo", OrderedDict([("stretchy", "true"), ("fence", "true"), ("form", "postfix")])),
+    # styles
+    COLOR: ("mstyle", {}),
+    **STYLES,
+    # others
+    SQRT: ("msqrt", {}),
+    ROOT: ("mroot", {}),
+    HREF: ("mtext", {}),
+    TEXT: ("mtext", {}),
+    TEXTBF: ("mtext", {"mathvariant": "bold"}),
+    TEXTIT: ("mtext", {"mathvariant": "italic"}),
+    TEXTRM: ("mtext", {}),
+    TEXTSF: ("mtext", {"mathvariant": "sans-serif"}),
+    TEXTTT: ("mtext", {"mathvariant": "monospace"}),
+    HBOX: ("mtext", {}),
+    MBOX: ("mtext", {}),
+    HPHANTOM: ("mphantom", {}),
+    PHANTOM: ("mphantom", {}),
+    VPHANTOM: ("mphantom", {}),
+    SIDESET: ("mrow", {}),
+    SKEW: ("mrow", {}),
+    MOD: ("mi", {}),
+    PMOD: ("mi", {}),
+    BMOD: ("mo", {}),
+    XLEFTARROW: ("mover", {}),
+    XRIGHTARROW: ("mover", {}),
+}
+
+
+DIACRITICS: Dict[str, Tuple[str, Dict[str, str]]] = {
+    ACUTE: ("´", {}),
+    BAR: ("¯", {"stretchy": "true"}),
+    BREVE: ("˘", {}),
+    CHECK: ("ˇ", {}),
+    DOT: ("˙", {}),
+    DDOT: ("¨", {}),
+    DDDOT: ("⃛", {}),
+    DDDDOT: ("⃜", {}),
+    GRAVE: ("`", {}),
+    HAT: ("^", {"stretchy": "false"}),
+    MATHRING: ("˚", {}),
+    OVERBRACE: ("⏞", {}),
+    OVERLEFTARROW: ("←", {}),
+    OVERLEFTRIGHTARROW: ("↔", {}),
+    OVERLINE: ("―", {"accent": "true"}),
+    OVERPAREN: ("⏜", {}),
+    OVERRIGHTARROW: ("→", {}),
+    TILDE: ("~", {"stretchy": "false"}),
+    UNDERBRACE: ("⏟", {}),
+    UNDERLEFTARROW: ("←", {}),
+    UNDERLEFTRIGHTARROW: ("↔", {}),
+    UNDERLINE: ("―", {"accent": "true"}),
+    UNDERPAREN: ("⏝", {}),
+    UNDERRIGHTARROW: ("→", {}),
+    VEC: ("→", {"stretchy": "true"}),
+    WIDEHAT: ("^", {}),
+    WIDETILDE: ("~", {}),
+}

videollama2/lib/python3.10/site-packages/latex2mathml/converter.py

@@ -0,0 +1,595 @@
+import copy
+import enum
+import re
+from collections import OrderedDict
+from typing import Dict, Iterable, Iterator, List, Optional, Tuple
+from xml.etree.cElementTree import Element, SubElement, tostring
+from xml.sax.saxutils import unescape
+
+from latex2mathml import commands
+from latex2mathml.symbols_parser import convert_symbol
+from latex2mathml.walker import Node, walk
+
+COLUMN_ALIGNMENT_MAP = {"r": "right", "l": "left", "c": "center"}
+OPERATORS = (
+    "+",
+    "-",
+    "*",
+    "/",
+    "(",
+    ")",
+    "=",
+    ",",
+    "?",
+    "[",
+    "]",
+    "|",
+    r"\|",
+    "!",
+    r"\{",
+    r"\}",
+    r">",
+    r"<",
+    r".",
+    r"\bigotimes",
+    r"\centerdot",
+    r"\dots",
+    r"\dotsc",
+    r"\dotso",
+    r"\gt",
+    r"\ldotp",
+    r"\lt",
+    r"\lvert",
+    r"\lVert",
+    r"\lvertneqq",
+    r"\ngeqq",
+    r"\omicron",
+    r"\rvert",
+    r"\rVert",
+    r"\S",
+    r"\smallfrown",
+    r"\smallint",
+    r"\smallsmile",
+    r"\surd",
+    r"\varsubsetneqq",
+    r"\varsupsetneqq",
+)
+MATH_MODE_PATTERN = re.compile(r"\\\$|\$|\\?[^\\$]+")
+
+
+class Mode(enum.Enum):
+    TEXT = enum.auto()
+    MATH = enum.auto()
+
+
+def convert(
+    latex: str,
+    xmlns: str = "http://www.w3.org/1998/Math/MathML",
+    display: str = "inline",
+    parent: Optional[Element] = None,
+) -> str:
+    math = convert_to_element(latex, xmlns, display, parent)
+    return _convert(math)
+
+
+def convert_to_element(
+    latex: str,
+    xmlns: str = "http://www.w3.org/1998/Math/MathML",
+    display: str = "inline",
+    parent: Optional[Element] = None,
+) -> Element:
+    tag = "math"
+    attrib = {"xmlns": xmlns, "display": display}
+    math = Element(tag, attrib) if parent is None else SubElement(parent, tag, attrib)
+    row = SubElement(math, "mrow")
+    _convert_group(iter(walk(latex)), row)
+    return math
+
+
+def _convert(tree: Element) -> str:
+    return unescape(tostring(tree, encoding="unicode"))
+
+
+def _convert_matrix(nodes: Iterator[Node], parent: Element, command: str, alignment: Optional[str] = None) -> None:
+    row = None
+    cell = None
+
+    col_index = 0
+    col_alignment = None
+
+    max_col_size = 0
+
+    row_index = 0
+    row_lines = []
+
+    hfil_indexes: List[bool] = []
+
+    for node in nodes:
+        if row is None:
+            row = SubElement(parent, "mtr")
+
+        if cell is None:
+            col_alignment, col_index = _get_column_alignment(alignment, col_alignment, col_index)
+            cell = _make_matrix_cell(row, col_alignment)
+
+        if node.token == commands.BRACES:
+            _convert_group(iter([node]), cell)
+        elif node.token == "&":
+            _set_cell_alignment(cell, hfil_indexes)
+            hfil_indexes = []
+            col_alignment, col_index = _get_column_alignment(alignment, col_alignment, col_index)
+            cell = _make_matrix_cell(row, col_alignment)
+            if command in (commands.SPLIT, commands.ALIGN) and col_index % 2 == 0:
+                SubElement(cell, "mi")
+        elif node.token in (commands.DOUBLEBACKSLASH, commands.CARRIAGE_RETURN):
+            _set_cell_alignment(cell, hfil_indexes)
+            hfil_indexes = []
+            row_index += 1
+            if col_index > max_col_size:
+                max_col_size = col_index
+            col_index = 0
+            col_alignment, col_index = _get_column_alignment(alignment, col_alignment, col_index)
+            row = SubElement(parent, "mtr")
+            cell = _make_matrix_cell(row, col_alignment)
+        elif node.token == commands.HLINE:
+            row_lines.append("solid")
+        elif node.token == commands.HDASHLINE:
+            row_lines.append("dashed")
+        elif node.token == commands.HFIL:
+            hfil_indexes.append(True)
+        else:
+            if row_index > len(row_lines):
+                row_lines.append("none")
+            hfil_indexes.append(False)
+            _convert_group(iter([node]), cell)
+
+    if col_index > max_col_size:
+        max_col_size = col_index
+
+    if any(r == "solid" for r in row_lines):
+        parent.set("rowlines", " ".join(row_lines))
+
+    if row is not None and cell is not None and len(cell) == 0:
+        # Remove last row if it does not contain anything
+        parent.remove(row)
+
+    if max_col_size and command == commands.ALIGN:
+        spacing = ("0em", "2em")
+        multiplier = max_col_size // len(spacing)
+        parent.set("columnspacing", " ".join(spacing * multiplier))
+
+
+def _set_cell_alignment(cell: Element, hfil_indexes: List[bool]) -> None:
+    if cell is not None and any(hfil_indexes) and len(hfil_indexes) > 1:
+        if hfil_indexes[0] and not hfil_indexes[-1]:
+            cell.attrib["columnalign"] = "right"
+        elif not hfil_indexes[0] and hfil_indexes[-1]:
+            cell.attrib["columnalign"] = "left"
+
+
+def _get_column_alignment(
+    alignment: Optional[str], column_alignment: Optional[str], column_index: int
+) -> Tuple[Optional[str], int]:
+    if alignment:
+        try:
+            column_alignment = COLUMN_ALIGNMENT_MAP.get(alignment[column_index])
+        except IndexError:
+            column_alignment = COLUMN_ALIGNMENT_MAP.get(alignment[column_index % len(alignment)])
+        column_index += 1
+    return column_alignment, column_index
+
+
+def _make_matrix_cell(row: Element, column_alignment: Optional[str]) -> Element:
+    if column_alignment:
+        return SubElement(row, "mtd", columnalign=column_alignment)
+    return SubElement(row, "mtd")
+
+
+def _convert_group(nodes: Iterable[Node], parent: Element, font: Optional[Dict[str, Optional[str]]] = None) -> None:
+    _font = font
+    for node in nodes:
+        token = node.token
+        if token in (*commands.MSTYLE_SIZES, *commands.STYLES):
+            node = Node(token=token, children=tuple(n for n in nodes))
+            _convert_command(node, parent, _font)
+        elif token in commands.CONVERSION_MAP or token in (commands.MOD, commands.PMOD):
+            _convert_command(node, parent, _font)
+        elif token in commands.LOCAL_FONTS and node.children is not None:
+            _convert_group(iter(node.children), parent, commands.LOCAL_FONTS[token])
+        elif token.startswith(commands.MATH) and node.children is not None:
+            _convert_group(iter(node.children), parent, _font)
+        elif token in commands.GLOBAL_FONTS.keys():
+            _font = commands.GLOBAL_FONTS.get(token)
+        elif node.children is None:
+            _convert_symbol(node, parent, _font)
+        elif node.children is not None:
+            attributes = node.attributes or {}
+            _row = SubElement(parent, "mrow", attrib=attributes)
+            _convert_group(iter(node.children), _row, _font)
+
+
+def _get_alignment_and_column_lines(alignment: Optional[str] = None) -> Tuple[Optional[str], Optional[str]]:
+    if alignment is None:
+        return None, None
+    if "|" not in alignment:
+        return alignment, None
+    _alignment = ""
+    column_lines = []
+    for c in alignment:
+        if c == "|":
+            column_lines.append("solid")
+        else:
+            _alignment += c
+        if len(_alignment) - len(column_lines) == 2:
+            column_lines.append("none")
+    return _alignment, " ".join(column_lines)
+
+
+def separate_by_mode(text: str) -> Iterator[Tuple[str, Mode]]:
+    string = ""
+    is_math_mode = False
+    for match in MATH_MODE_PATTERN.findall(text):
+        if match == "$":  # should match both $ and  $$
+            yield string, Mode.MATH if is_math_mode else Mode.TEXT
+            string = ""
+            is_math_mode = not is_math_mode
+        else:
+            string += match
+    if len(string):
+        yield string, Mode.MATH if is_math_mode else Mode.TEXT
+    # TODO: if stays in math mode, means not terminated properly, raise error
+
+
+def _convert_command(node: Node, parent: Element, font: Optional[Dict[str, Optional[str]]] = None) -> None:
+    command = node.token
+    modifier = node.modifier
+
+    if command in (commands.SUBSTACK, commands.SMALLMATRIX):
+        parent = SubElement(parent, "mstyle", scriptlevel="1")
+    elif command == commands.CASES:
+        parent = SubElement(parent, "mrow")
+        lbrace = SubElement(parent, "mo", OrderedDict([("stretchy", "true"), ("fence", "true"), ("form", "prefix")]))
+        lbrace.text = "&#x{};".format(convert_symbol(commands.LBRACE))
+    elif command in (commands.DBINOM, commands.DFRAC):
+        parent = SubElement(parent, "mstyle", displaystyle="true", scriptlevel="0")
+    elif command == commands.HPHANTOM:
+        parent = SubElement(parent, "mpadded", height="0", depth="0")
+    elif command == commands.VPHANTOM:
+        parent = SubElement(parent, "mpadded", width="0")
+    elif command in (commands.TBINOM, commands.HBOX, commands.MBOX, commands.TFRAC):
+        parent = SubElement(parent, "mstyle", displaystyle="false", scriptlevel="0")
+    elif command in (commands.MOD, commands.PMOD):
+        SubElement(parent, "mspace", width="1em")
+
+    tag, attributes = copy.deepcopy(commands.CONVERSION_MAP[command])
+
+    if node.attributes is not None and node.token != commands.SKEW:
+        attributes.update(node.attributes)
+
+    if command == commands.LEFT:
+        parent = SubElement(parent, "mrow")
+
+    _append_prefix_element(node, parent)
+
+    alignment, column_lines = _get_alignment_and_column_lines(node.alignment)
+
+    if column_lines:
+        attributes["columnlines"] = column_lines
+
+    if command == commands.SUBSUP and node.children is not None and node.children[0].token == commands.GCD:
+        tag = "munderover"
+    elif command == commands.SUPERSCRIPT and modifier in (commands.LIMITS, commands.OVERBRACE):
+        tag = "mover"
+    elif command == commands.SUBSCRIPT and modifier in (commands.LIMITS, commands.UNDERBRACE):
+        tag = "munder"
+    elif command == commands.SUBSUP and modifier in (commands.LIMITS, commands.OVERBRACE, commands.UNDERBRACE):
+        tag = "munderover"
+    elif (
+        command in (commands.XLEFTARROW, commands.XRIGHTARROW) and node.children is not None and len(node.children) == 2
+    ):
+        tag = "munderover"
+
+    element = SubElement(parent, tag, attributes)
+
+    if command in commands.LIMIT:
+        element.text = command[1:]
+    elif command in (commands.MOD, commands.PMOD):
+        element.text = "mod"
+        SubElement(parent, "mspace", width="0.333em")
+    elif command == commands.BMOD:
+        element.text = "mod"
+    elif command in (commands.XLEFTARROW, commands.XRIGHTARROW):
+        style = SubElement(element, "mstyle", scriptlevel="0")
+        arrow = SubElement(style, "mo")
+        if command == commands.XLEFTARROW:
+            arrow.text = "&#x2190;"
+        elif command == commands.XRIGHTARROW:
+            arrow.text = "&#x2192;"
+    elif node.text is not None:
+        if command == commands.MIDDLE:
+            element.text = "&#x{};".format(convert_symbol(node.text))
+        elif command == commands.HBOX:
+            mtext: Optional[Element] = element
+            for text, mode in separate_by_mode(node.text):
+                if mode == Mode.TEXT:
+                    if mtext is None:
+                        mtext = SubElement(parent, tag, attributes)
+                    mtext.text = text.replace(" ", "&#x000A0;")
+                    _set_font(mtext, "mtext", font)
+                    mtext = None
+                else:
+                    _row = SubElement(parent, "mrow")
+                    _convert_group(iter(walk(text)), _row)
+        else:
+            if command == commands.FBOX:
+                element = SubElement(element, "mtext")
+            element.text = node.text.replace(" ", "&#x000A0;")
+            _set_font(element, "mtext", font)
+    elif node.delimiter is not None and command not in (commands.FRAC, commands.GENFRAC):
+        if node.delimiter != ".":
+            symbol = convert_symbol(node.delimiter)
+            element.text = node.delimiter if symbol is None else "&#x{};".format(symbol)
+
+    if node.children is not None:
+        _parent = element
+        if command in (commands.LEFT, commands.MOD, commands.PMOD):
+            _parent = parent
+        if command in commands.MATRICES:
+            if command == commands.CASES:
+                alignment = "l"
+            elif command in (commands.SPLIT, commands.ALIGN):
+                alignment = "rl"
+            _convert_matrix(iter(node.children), _parent, command, alignment=alignment)
+        elif command == commands.CFRAC:
+            for child in node.children:
+                p = SubElement(_parent, "mstyle", displaystyle="false", scriptlevel="0")
+                _convert_group(iter([child]), p, font)
+        elif command == commands.SIDESET:
+            Node(
+                r"\style",
+                children=(Node(r"\mspace", attributes={"width": "-0.167em"}),),
+                attributes={"scriptlevel": "0"},
+            ),
+            left, right = node.children
+            _convert_group(iter([left]), _parent, font)
+            fill = SubElement(_parent, "mstyle", scriptlevel="0")
+            SubElement(fill, "mspace", width="-0.167em")
+            _convert_group(iter([right]), _parent, font)
+        elif command == commands.SKEW:
+            child = node.children[0]
+            new_node = Node(
+                token=child.token,
+                children=(
+                    Node(
+                        token=commands.BRACES,
+                        children=(*child.children, Node(token=commands.MKERN, attributes=node.attributes)),
+                    ),
+                ),
+            )
+            _convert_group(iter([new_node]), _parent, font)
+        elif command in (commands.XLEFTARROW, commands.XRIGHTARROW):
+            for child in node.children:
+                padded = SubElement(
+                    _parent,
+                    "mpadded",
+                    OrderedDict(
+                        [("width", "+0.833em"), ("lspace", "0.556em"), ("voffset", "-.2em"), ("height", "-.2em")]
+                    ),
+                )
+                _convert_group(iter([child]), padded, font)
+                SubElement(padded, "mspace", depth=".25em")
+        else:
+            _convert_group(iter(node.children), _parent, font)
+
+    _add_diacritic(command, element)
+
+    _append_postfix_element(node, parent)
+
+
+def _add_diacritic(command: str, parent: Element) -> None:
+    if command in commands.DIACRITICS:
+        text, attributes = copy.deepcopy(commands.DIACRITICS[command])
+        element = SubElement(parent, "mo", attributes)
+        element.text = text
+
+
+def _convert_and_append_command(command: str, parent: Element, attributes: Optional[Dict[str, str]] = None) -> None:
+    code_point = convert_symbol(command)
+    mo = SubElement(parent, "mo", attributes if attributes is not None else {})
+    mo.text = "&#x{};".format(code_point) if code_point else command
+
+
+def _append_prefix_element(node: Node, parent: Element) -> None:
+    size = "2.047em"
+    if parent.attrib.get("displaystyle") == "false" or node.token == commands.TBINOM:
+        size = "1.2em"
+    if node.token in (r"\pmatrix", commands.PMOD):
+        _convert_and_append_command(r"\lparen", parent)
+    elif node.token in (commands.BINOM, commands.DBINOM, commands.TBINOM):
+        _convert_and_append_command(r"\lparen", parent, {"minsize": size, "maxsize": size})
+    elif node.token == r"\bmatrix":
+        _convert_and_append_command(r"\lbrack", parent)
+    elif node.token == r"\Bmatrix":
+        _convert_and_append_command(r"\lbrace", parent)
+    elif node.token == r"\vmatrix":
+        _convert_and_append_command(r"\vert", parent)
+    elif node.token == r"\Vmatrix":
+        _convert_and_append_command(r"\Vert", parent)
+    elif node.token in (commands.FRAC, commands.GENFRAC) and node.delimiter is not None and node.delimiter[0] != ".":
+        # TODO: use 1.2em if inline
+        _convert_and_append_command(node.delimiter[0], parent, {"minsize": size, "maxsize": size})
+
+
+def _append_postfix_element(node: Node, parent: Element) -> None:
+    size = "2.047em"
+    if parent.attrib.get("displaystyle") == "false" or node.token == commands.TBINOM:
+        size = "1.2em"
+    if node.token in (r"\pmatrix", commands.PMOD):
+        _convert_and_append_command(r"\rparen", parent)
+    elif node.token in (commands.BINOM, commands.DBINOM, commands.TBINOM):
+        _convert_and_append_command(r"\rparen", parent, {"minsize": size, "maxsize": size})
+    elif node.token == r"\bmatrix":
+        _convert_and_append_command(r"\rbrack", parent)
+    elif node.token == r"\Bmatrix":
+        _convert_and_append_command(r"\rbrace", parent)
+    elif node.token == r"\vmatrix":
+        _convert_and_append_command(r"\vert", parent)
+    elif node.token == r"\Vmatrix":
+        _convert_and_append_command(r"\Vert", parent)
+    elif node.token in (commands.FRAC, commands.GENFRAC) and node.delimiter is not None and node.delimiter[1] != ".":
+        # TODO: use 1.2em if inline
+        _convert_and_append_command(node.delimiter[1], parent, {"minsize": size, "maxsize": size})
+    elif node.token == commands.SKEW and node.attributes is not None:
+        SubElement(parent, "mspace", width="-" + node.attributes["width"])
+
+
+def _convert_symbol(node: Node, parent: Element, font: Optional[Dict[str, Optional[str]]] = None) -> None:
+    token = node.token
+    attributes = node.attributes or {}
+    symbol = convert_symbol(token)
+    if re.match(r"\d+(.\d+)?", token):
+        element = SubElement(parent, "mn", attrib=attributes)
+        element.text = token
+        _set_font(element, element.tag, font)
+    elif token in OPERATORS:
+        element = SubElement(parent, "mo", attrib=attributes)
+        element.text = token if symbol is None else "&#x{};".format(symbol)
+        if token == r"\|":
+            element.attrib["fence"] = "false"
+        if token == r"\smallint":
+            element.attrib["largeop"] = "false"
+        if token in ("(", ")", "[", "]", "|", r"\|", r"\{", r"\}", r"\surd"):
+            element.attrib["stretchy"] = "false"
+            _set_font(element, "fence", font)
+        else:
+            _set_font(element, element.tag, font)
+    elif (
+        symbol
+        and (
+            int(symbol, 16) in range(int("2200", 16), int("22FF", 16) + 1)
+            or int(symbol, 16) in range(int("2190", 16), int("21FF", 16) + 1)
+        )
+        or symbol == "."
+    ):
+        element = SubElement(parent, "mo", attrib=attributes)
+        element.text = "&#x{};".format(symbol)
+        _set_font(element, element.tag, font)
+    elif token in (r"\ ", "~", commands.NOBREAKSPACE, commands.SPACE):
+        element = SubElement(parent, "mtext", attrib=attributes)
+        element.text = "&#x000A0;"
+        _set_font(element, "mtext", font)
+    elif token == commands.NOT:
+        mpadded = SubElement(parent, "mpadded", width="0")
+        element = SubElement(mpadded, "mtext")
+        element.text = "&#x029F8;"
+    elif token in (
+        commands.DETERMINANT,
+        commands.GCD,
+        commands.INTOP,
+        commands.INJLIM,
+        commands.LIMINF,
+        commands.LIMSUP,
+        commands.PR,
+        commands.PROJLIM,
+    ):
+        element = SubElement(parent, "mo", attrib={"movablelimits": "true", **attributes})
+        texts = {
+            commands.INJLIM: "inj&#x02006;lim",
+            commands.INTOP: "&#x0222B;",
+            commands.LIMINF: "lim&#x02006;inf",
+            commands.LIMSUP: "lim&#x02006;sup",
+            commands.PROJLIM: "proj&#x02006;lim",
+        }
+        element.text = texts.get(token, token[1:])
+        _set_font(element, element.tag, font)
+    elif token == commands.IDOTSINT:
+        _parent = SubElement(parent, "mrow", attrib=attributes)
+        for s in ("&#x0222B;", "&#x022EF;", "&#x0222B;"):
+            element = SubElement(_parent, "mo")
+            element.text = s
+    elif token in (commands.LATEX, commands.TEX):
+        _parent = SubElement(parent, "mrow", attrib=attributes)
+        if token == commands.LATEX:
+            mi_l = SubElement(_parent, "mi")
+            mi_l.text = "L"
+            SubElement(_parent, "mspace", width="-.325em")
+            mpadded = SubElement(_parent, "mpadded", height="+.21ex", depth="-.21ex", voffset="+.21ex")
+            mstyle = SubElement(mpadded, "mstyle", displaystyle="false", scriptlevel="1")
+            mrow = SubElement(mstyle, "mrow")
+            mi_a = SubElement(mrow, "mi")
+            mi_a.text = "A"
+            SubElement(_parent, "mspace", width="-.17em")
+            _set_font(mi_l, mi_l.tag, font)
+            _set_font(mi_a, mi_a.tag, font)
+        mi_t = SubElement(_parent, "mi")
+        mi_t.text = "T"
+        SubElement(_parent, "mspace", width="-.14em")
+        mpadded = SubElement(_parent, "mpadded", height="-.5ex", depth="+.5ex", voffset="-.5ex")
+        mrow = SubElement(mpadded, "mrow")
+        mi_e = SubElement(mrow, "mi")
+        mi_e.text = "E"
+        SubElement(_parent, "mspace", width="-.115em")
+        mi_x = SubElement(_parent, "mi")
+        mi_x.text = "X"
+        _set_font(mi_t, mi_t.tag, font)
+        _set_font(mi_e, mi_e.tag, font)
+        _set_font(mi_x, mi_x.tag, font)
+    elif token.startswith(commands.OPERATORNAME):
+        element = SubElement(parent, "mo", attrib=attributes)
+        element.text = token[14:-1]
+    elif token.startswith(commands.BACKSLASH):
+        element = SubElement(parent, "mi", attrib=attributes)
+        if symbol:
+            element.text = "&#x{};".format(symbol)
+        elif token in commands.FUNCTIONS:
+            element.text = token[1:]
+        else:
+            element.text = token
+        _set_font(element, element.tag, font)
+    else:
+        element = SubElement(parent, "mi", attrib=attributes)
+        element.text = token
+        _set_font(element, element.tag, font)
+
+
+def _set_font(element: Element, key: str, font: Optional[Dict[str, Optional[str]]]) -> None:
+    if font is None:
+        return
+    _font = font[key]
+    if _font is not None:
+        element.attrib["mathvariant"] = _font
+
+
+def main() -> None:  # pragma: no cover
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Pure Python library for LaTeX to MathML conversion")
+    parser.add_argument("-V", "--version", dest="version", action="store_true", required=False, help="Show version")
+    parser.add_argument("-b", "--block", dest="block", action="store_true", required=False, help="Display block")
+
+    required = parser.add_argument_group("required arguments")
+
+    group = required.add_mutually_exclusive_group(required=False)
+    group.add_argument("-t", "--text", dest="text", type=str, required=False, help="Text")
+    group.add_argument("-f", "--file", dest="file", type=str, required=False, help="File")
+    group.add_argument("-s", "--stdin", dest="stdin", action="store_true", required=False, help="Stdin")
+
+    arguments = parser.parse_args()
+    display = "block" if arguments.block else "inline"
+
+    if arguments.version:
+        import latex2mathml
+
+        print("latex2mathml", latex2mathml.__version__)
+    elif arguments.text:
+        print(convert(arguments.text, display=display))
+    elif arguments.file:
+        with open(arguments.file) as f:
+            print(convert(f.read(), display=display))
+    elif arguments.stdin:
+        print(convert(sys.stdin.read(), display=display))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

videollama2/lib/python3.10/site-packages/latex2mathml/exceptions.py

@@ -0,0 +1,46 @@
+class NumeratorNotFoundError(Exception):
+    pass
+
+
+class DenominatorNotFoundError(Exception):
+    pass
+
+
+class ExtraLeftOrMissingRightError(Exception):
+    pass
+
+
+class MissingSuperScriptOrSubscriptError(Exception):
+    pass
+
+
+class DoubleSubscriptsError(Exception):
+    pass
+
+
+class DoubleSuperscriptsError(Exception):
+    pass
+
+
+class NoAvailableTokensError(Exception):
+    pass
+
+
+class InvalidStyleForGenfracError(Exception):
+    pass
+
+
+class MissingEndError(Exception):
+    pass
+
+
+class InvalidAlignmentError(Exception):
+    pass
+
+
+class InvalidWidthError(Exception):
+    pass
+
+
+class LimitsMustFollowMathOperatorError(Exception):
+    pass

videollama2/lib/python3.10/site-packages/latex2mathml/py.typed

@@ -0,0 +1 @@
+# PEP 581

videollama2/lib/python3.10/site-packages/latex2mathml/symbols_parser.py

@@ -0,0 +1,78 @@
+import codecs
+import os
+import re
+from typing import Dict, Optional, Union
+
+SYMBOLS_FILE: str = os.path.join(os.path.dirname(os.path.realpath(__file__)), "unimathsymbols.txt")
+SYMBOLS: Optional[Dict[str, str]] = None
+
+
+def convert_symbol(symbol: str) -> Union[str, None]:
+    global SYMBOLS
+    if not SYMBOLS:
+        SYMBOLS = parse_symbols()
+    return SYMBOLS.get(symbol, None)
+
+
+def parse_symbols() -> Dict[str, str]:
+    _symbols: Dict[str, str] = {}
+    with codecs.open(SYMBOLS_FILE, encoding="utf-8") as f:
+        for line in f:
+            if line.startswith("#"):
+                continue
+            columns = line.strip().split("^")
+            _unicode = columns[0]
+            latex = columns[2]
+            unicode_math = columns[3]
+            if latex and latex not in _symbols:
+                _symbols[latex] = _unicode
+            if unicode_math and unicode_math not in _symbols:
+                _symbols[unicode_math] = _unicode
+            for equivalent in re.findall(r"[=#]\s*(\\[^,^ ]+),?", columns[-1]):
+                if equivalent not in _symbols:
+                    _symbols[equivalent] = _unicode
+    _symbols.update(
+        {
+            r"\And": _symbols[r"\ampersand"],
+            r"\bigcirc": _symbols[r"\lgwhtcircle"],
+            r"\Box": _symbols[r"\square"],
+            r"\circledS": "024C8",
+            r"\diagdown": "02572",
+            r"\diagup": "02571",
+            r"\dots": "02026",
+            r"\dotsb": _symbols[r"\cdots"],
+            r"\dotsc": "02026",
+            r"\dotsi": _symbols[r"\cdots"],
+            r"\dotsm": _symbols[r"\cdots"],
+            r"\dotso": "02026",
+            r"\emptyset": "02205",
+            r"\gggtr": "022D9",
+            r"\gvertneqq": "02269",
+            r"\gt": _symbols[r"\greater"],
+            r"\ldotp": _symbols[r"\period"],
+            r"\llless": _symbols[r"\lll"],
+            r"\lt": _symbols[r"\less"],
+            r"\lvert": _symbols[r"\vert"],
+            r"\lVert": _symbols[r"\Vert"],
+            r"\lvertneqq": _symbols[r"\lneqq"],
+            r"\ngeqq": _symbols[r"\ngeq"],
+            r"\nshortmid": _symbols[r"\nmid"],
+            r"\nshortparallel": _symbols[r"\nparallel"],
+            r"\nsubseteqq": _symbols[r"\nsubseteq"],
+            r"\omicron": _symbols[r"\upomicron"],
+            r"\rvert": _symbols[r"\vert"],
+            r"\rVert": _symbols[r"\Vert"],
+            r"\shortmid": _symbols[r"\mid"],
+            r"\smallfrown": _symbols[r"\frown"],
+            r"\smallint": "0222B",
+            r"\smallsmile": _symbols[r"\smile"],
+            r"\surd": _symbols[r"\sqrt"],
+            r"\thicksim": "0223C",
+            r"\thickapprox": _symbols[r"\approx"],
+            r"\varsubsetneqq": _symbols[r"\subsetneqq"],
+            r"\varsupsetneq": "0228B",
+            r"\varsupsetneqq": _symbols[r"\supsetneqq"],
+        }
+    )
+    del _symbols[r"\mathring"]  # FIXME: improve tokenizer without removing this
+    return _symbols

videollama2/lib/python3.10/site-packages/latex2mathml/tokenizer.py

@@ -0,0 +1,55 @@
+import re
+from typing import Iterator
+
+from latex2mathml import commands
+from latex2mathml.symbols_parser import convert_symbol
+
+UNITS = ("in", "mm", "cm", "pt", "em", "ex", "pc", "bp", "dd", "cc", "sp", "mu")
+
+PATTERN = re.compile(
+    rf"""
+    (%[^\n]+) |                                 # comment
+    (a-zA-Z) |                                  # letter
+    ([_^])(\d) |                                # number succeeding an underscore or a caret
+    (-?\d+(?:\.\d+)?\s*(?:{'|'.join(UNITS)})) | # dimension
+    (\d+(?:\.\d+)?) |                           # integer/decimal
+    (\.\d*) |                                   # dot (.) or decimal can start with just a dot
+    (\\[\\\[\]{{}}\s!,:>;|_%#$&]) |             # escaped characters
+    (\\(?:begin|end)\s*{{[a-zA-Z]+\*?}}) |      # begin or end
+    (\\operatorname\s*{{[a-zA-Z\s*]+\*?\s*}}) | # operatorname
+    #  color, fbox, href, hbox, mbox, style, text, textbf, textit, textrm, textsf, texttt
+    (\\(?:color|fbox|hbox|href|mbox|style|text|textbf|textit|textrm|textsf|texttt))\s*{{([^}}]*)}} |
+    (\\[cdt]?frac)\s*([.\d])\s*([.\d])? |       # fractions
+    (\\math[a-z]+)({{)([a-zA-Z])(}}) |          # commands starting with math
+    (\\[a-zA-Z]+) |                             # other commands
+    (\S)                                        # non-space character
+    """,
+    re.VERBOSE,
+)
+
+
+def tokenize(latex_string: str, skip_comments: bool = True) -> Iterator[str]:
+    """
+    Converts Latex string into tokens.
+
+    :param latex_string: Latex string.
+    :param skip_comments: Flag to skip comments (default=True).
+    """
+    for match in PATTERN.finditer(latex_string):
+        tokens = tuple(filter(lambda x: x is not None, match.groups()))
+        if tokens[0].startswith(commands.MATH):
+            full_math = "".join(tokens)
+            symbol = convert_symbol(full_math)
+            if symbol:
+                yield f"&#x{symbol};"
+                continue
+        for captured in tokens:
+            if skip_comments and captured.startswith("%"):
+                break
+            if captured.endswith(UNITS):
+                yield captured.replace(" ", "")
+                continue
+            if captured.startswith((commands.BEGIN, commands.END, commands.OPERATORNAME)):
+                yield "".join(captured.split(" "))
+                continue
+            yield captured

videollama2/lib/python3.10/site-packages/latex2mathml/walker.py

@@ -0,0 +1,457 @@
+from typing import Any, Dict, Iterator, List, NamedTuple, Optional, Tuple
+
+from latex2mathml import commands
+from latex2mathml.exceptions import (
+    DenominatorNotFoundError,
+    DoubleSubscriptsError,
+    DoubleSuperscriptsError,
+    ExtraLeftOrMissingRightError,
+    InvalidAlignmentError,
+    InvalidStyleForGenfracError,
+    InvalidWidthError,
+    LimitsMustFollowMathOperatorError,
+    MissingEndError,
+    MissingSuperScriptOrSubscriptError,
+    NoAvailableTokensError,
+    NumeratorNotFoundError,
+)
+from latex2mathml.symbols_parser import convert_symbol
+from latex2mathml.tokenizer import tokenize
+
+
+class Node(NamedTuple):
+    token: str
+    children: Optional[Tuple[Any, ...]] = None
+    delimiter: Optional[str] = None
+    alignment: Optional[str] = None
+    text: Optional[str] = None
+    attributes: Optional[Dict[str, str]] = None
+    modifier: Optional[str] = None
+
+
+def walk(data: str) -> List[Node]:
+    tokens = tokenize(data)
+    return _walk(tokens)
+
+
+def _walk(tokens: Iterator[str], terminator: Optional[str] = None, limit: int = 0) -> List[Node]:
+    group: List[Node] = []
+    token: str
+    has_available_tokens = False
+    for token in tokens:
+        has_available_tokens = True
+        if token == terminator:
+            delimiter = None
+            if terminator == commands.RIGHT:
+                delimiter = next(tokens)
+            group.append(Node(token=token, delimiter=delimiter))
+            break
+        elif (token == commands.RIGHT != terminator) or (token == commands.MIDDLE and terminator != commands.RIGHT):
+            raise ExtraLeftOrMissingRightError
+        elif token == commands.LEFT:
+            delimiter = next(tokens)
+            children = tuple(_walk(tokens, terminator=commands.RIGHT))  # make \right as a child of \left
+            if len(children) == 0 or children[-1].token != commands.RIGHT:
+                raise ExtraLeftOrMissingRightError
+            node = Node(token=token, children=children if len(children) else None, delimiter=delimiter)
+        elif token == commands.OPENING_BRACE:
+            children = tuple(_walk(tokens, terminator=commands.CLOSING_BRACE))
+            if len(children) and children[-1].token == commands.CLOSING_BRACE:
+                children = children[:-1]
+            node = Node(token=commands.BRACES, children=children)
+        elif token in (commands.SUBSCRIPT, commands.SUPERSCRIPT):
+            try:
+                previous = group.pop()
+            except IndexError:
+                previous = Node(token="")  # left operand can be empty if not present
+
+            if token == previous.token == commands.SUBSCRIPT:
+                raise DoubleSubscriptsError
+            if (token == previous.token == commands.SUPERSCRIPT) and (
+                previous.children is not None
+                and len(previous.children) >= 2
+                and previous.children[1].token != commands.PRIME
+            ):
+                raise DoubleSuperscriptsError
+
+            modifier = None
+            if previous.token == commands.LIMITS:
+                modifier = commands.LIMITS
+                try:
+                    previous = group.pop()
+                    if not previous.token.startswith("\\"):  # TODO: Complete list of operators
+                        raise LimitsMustFollowMathOperatorError
+                except IndexError:
+                    raise LimitsMustFollowMathOperatorError
+
+            if token == commands.SUBSCRIPT and previous.token == commands.SUPERSCRIPT and previous.children is not None:
+                children = tuple(_walk(tokens, terminator=terminator, limit=1))
+                node = Node(
+                    token=commands.SUBSUP,
+                    children=(previous.children[0], *children, previous.children[1]),
+                    modifier=previous.modifier,
+                )
+            elif (
+                token == commands.SUPERSCRIPT and previous.token == commands.SUBSCRIPT and previous.children is not None
+            ):
+                children = tuple(_walk(tokens, terminator=terminator, limit=1))
+                node = Node(token=commands.SUBSUP, children=(*previous.children, *children), modifier=previous.modifier)
+            elif (
+                token == commands.SUPERSCRIPT
+                and previous.token == commands.SUPERSCRIPT
+                and previous.children is not None
+                and previous.children[1].token == commands.PRIME
+            ):
+                children = tuple(_walk(tokens, terminator=terminator, limit=1))
+
+                node = Node(
+                    token=commands.SUPERSCRIPT,
+                    children=(
+                        previous.children[0],
+                        Node(token=commands.BRACES, children=(previous.children[1], *children)),
+                    ),
+                    modifier=previous.modifier,
+                )
+            else:
+                try:
+                    children = tuple(_walk(tokens, terminator=terminator, limit=1))
+                except NoAvailableTokensError:
+                    raise MissingSuperScriptOrSubscriptError
+                if previous.token in (commands.OVERBRACE, commands.UNDERBRACE):
+                    modifier = previous.token
+                node = Node(token=token, children=(previous, *children), modifier=modifier)
+        elif token == commands.APOSTROPHE:
+            try:
+                previous = group.pop()
+            except IndexError:
+                previous = Node(token="")  # left operand can be empty if not present
+
+            if (
+                previous.token == commands.SUPERSCRIPT
+                and previous.children is not None
+                and len(previous.children) >= 2
+                and previous.children[1].token != commands.PRIME
+            ):
+                raise DoubleSuperscriptsError
+
+            if (
+                previous.token == commands.SUPERSCRIPT
+                and previous.children is not None
+                and len(previous.children) >= 2
+                and previous.children[1].token == commands.PRIME
+            ):
+                node = Node(token=commands.SUPERSCRIPT, children=(previous.children[0], Node(token=commands.DPRIME)))
+            elif previous.token == commands.SUBSCRIPT and previous.children is not None:
+                node = Node(
+                    token=commands.SUBSUP,
+                    children=(*previous.children, Node(token=commands.PRIME)),
+                    modifier=previous.modifier,
+                )
+            else:
+                node = Node(token=commands.SUPERSCRIPT, children=(previous, Node(token=commands.PRIME)))
+        elif token in commands.COMMANDS_WITH_TWO_PARAMETERS:
+            attributes = None
+            children = tuple(_walk(tokens, terminator=terminator, limit=2))
+            if token in (commands.OVERSET, commands.UNDERSET):
+                children = children[::-1]
+            node = Node(token=token, children=children, attributes=attributes)
+        elif token in commands.COMMANDS_WITH_ONE_PARAMETER or token.startswith(commands.MATH):
+            children = tuple(_walk(tokens, terminator=terminator, limit=1))
+            node = Node(token=token, children=children)
+        elif token == commands.NOT:
+            try:
+                next_node = tuple(_walk(tokens, terminator=terminator, limit=1))[0]
+                if next_node.token.startswith("\\"):
+                    negated_symbol = r"\n" + next_node.token[1:]
+                    symbol = convert_symbol(negated_symbol)
+                    if symbol:
+                        node = Node(token=negated_symbol)
+                        group.append(node)
+                        continue
+                node = Node(token=token)
+                group.extend((node, next_node))
+                continue
+            except NoAvailableTokensError:
+                node = Node(token=token)
+        elif token in (commands.XLEFTARROW, commands.XRIGHTARROW):
+            children = tuple(_walk(tokens, terminator=terminator, limit=1))
+            if children[0].token == commands.OPENING_BRACKET:
+                children = (
+                    Node(
+                        token=commands.BRACES, children=tuple(_walk(tokens, terminator=commands.CLOSING_BRACKET))[:-1]
+                    ),
+                    *tuple(_walk(tokens, terminator=terminator, limit=1)),
+                )
+            node = Node(token=token, children=children)
+        elif token in (commands.HSKIP, commands.HSPACE, commands.KERN, commands.MKERN, commands.MSKIP, commands.MSPACE):
+            children = tuple(_walk(tokens, terminator=terminator, limit=1))
+            if children[0].token == commands.BRACES and children[0].children is not None:
+                children = children[0].children
+            node = Node(token=token, attributes={"width": children[0].token})
+        elif token == commands.COLOR:
+            attributes = {"mathcolor": next(tokens)}
+            children = tuple(_walk(tokens, terminator=terminator))
+            sibling = None
+            if len(children) and children[-1].token == terminator:
+                children, sibling = children[:-1], children[-1]
+            group.append(Node(token=token, children=children, attributes=attributes))
+            if sibling:
+                group.append(sibling)
+            break
+        elif token == commands.STYLE:
+            attributes = {"style": next(tokens)}
+            next_node = tuple(_walk(tokens, terminator=terminator, limit=1))[0]
+            node = next_node._replace(attributes=attributes)
+        elif token in (
+            *commands.BIG.keys(),
+            *commands.BIG_OPEN_CLOSE.keys(),
+            commands.FBOX,
+            commands.HBOX,
+            commands.MBOX,
+            commands.MIDDLE,
+            commands.TEXT,
+            commands.TEXTBF,
+            commands.TEXTIT,
+            commands.TEXTRM,
+            commands.TEXTSF,
+            commands.TEXTTT,
+        ):
+            node = Node(token=token, text=next(tokens))
+        elif token == commands.HREF:
+            attributes = {"href": next(tokens)}
+            children = tuple(_walk(tokens, terminator=terminator, limit=1))
+            node = Node(token=token, children=children, attributes=attributes)
+        elif token in (
+            commands.ABOVE,
+            commands.ATOP,
+            commands.ABOVEWITHDELIMS,
+            commands.ATOPWITHDELIMS,
+            commands.BRACE,
+            commands.BRACK,
+            commands.CHOOSE,
+            commands.OVER,
+        ):
+            attributes = None
+            delimiter = None
+
+            if token == commands.ABOVEWITHDELIMS:
+                delimiter = next(tokens).lstrip("\\") + next(tokens).lstrip("\\")
+            elif token == commands.ATOPWITHDELIMS:
+                attributes = {"linethickness": "0"}
+                delimiter = next(tokens).lstrip("\\") + next(tokens).lstrip("\\")
+            elif token == commands.BRACE:
+                delimiter = "{}"
+            elif token == commands.BRACK:
+                delimiter = "[]"
+            elif token == commands.CHOOSE:
+                delimiter = "()"
+
+            if token in (commands.ABOVE, commands.ABOVEWITHDELIMS):
+                dimension_node = tuple(_walk(tokens, terminator=terminator, limit=1))[0]
+                dimension = _get_dimension(dimension_node)
+                attributes = {"linethickness": dimension}
+            elif token in (commands.ATOP, commands.BRACE, commands.BRACK, commands.CHOOSE):
+                attributes = {"linethickness": "0"}
+
+            denominator = tuple(_walk(tokens, terminator=terminator))
+
+            sibling = None
+            if len(denominator) and denominator[-1].token == terminator:
+                denominator, sibling = denominator[:-1], denominator[-1]
+
+            if len(denominator) == 0:
+                if token in (commands.BRACE, commands.BRACK):
+                    denominator = (Node(token=commands.BRACES, children=()),)
+                else:
+                    raise DenominatorNotFoundError
+            if len(group) == 0:
+                if token in (commands.BRACE, commands.BRACK):
+                    group = [Node(token=commands.BRACES, children=())]
+                else:
+                    raise NumeratorNotFoundError
+            if len(denominator) > 1:
+                denominator = (Node(token=commands.BRACES, children=denominator),)
+
+            if len(group) == 1:
+                children = (*group, *denominator)
+            else:
+                children = (Node(token=commands.BRACES, children=tuple(group)), *denominator)
+            group = [Node(token=commands.FRAC, children=children, attributes=attributes, delimiter=delimiter)]
+            if sibling is not None:
+                group.append(sibling)
+            break
+        elif token == commands.SQRT:
+            root_nodes = None
+            next_node = tuple(_walk(tokens, limit=1))[0]
+            if next_node.token == commands.OPENING_BRACKET:
+                root_nodes = tuple(_walk(tokens, terminator=commands.CLOSING_BRACKET))[:-1]
+                next_node = tuple(_walk(tokens, limit=1))[0]
+                if len(root_nodes) > 1:
+                    root_nodes = (Node(token=commands.BRACES, children=root_nodes),)
+
+            if root_nodes:
+                node = Node(token=commands.ROOT, children=(next_node, *root_nodes))
+            else:
+                node = Node(token=token, children=(next_node,))
+        elif token == commands.ROOT:
+            root_nodes = tuple(_walk(tokens, terminator=r"\of"))[:-1]
+            next_node = tuple(_walk(tokens, limit=1))[0]
+            if len(root_nodes) > 1:
+                root_nodes = (Node(token=commands.BRACES, children=root_nodes),)
+            if root_nodes:
+                node = Node(token=token, children=(next_node, *root_nodes))
+            else:
+                node = Node(token=token, children=(next_node, Node(token=commands.BRACES, children=())))
+        elif token in commands.MATRICES:
+            children = tuple(_walk(tokens, terminator=terminator))
+            sibling = None
+            if len(children) and children[-1].token == terminator:
+                children, sibling = children[:-1], children[-1]
+            if len(children) == 1 and children[0].token == commands.BRACES and children[0].children:
+                children = children[0].children
+            if sibling is not None:
+                group.extend([Node(token=token, children=children, alignment=""), sibling])
+                break
+            else:
+                node = Node(token=token, children=children, alignment="")
+        elif token == commands.GENFRAC:
+            delimiter = next(tokens).lstrip("\\") + next(tokens).lstrip("\\")
+            dimension_node, style_node = tuple(_walk(tokens, terminator=terminator, limit=2))
+            dimension = _get_dimension(dimension_node)
+            style = _get_style(style_node)
+            attributes = {"linethickness": dimension}
+            children = tuple(_walk(tokens, terminator=terminator, limit=2))
+            group.extend(
+                [Node(token=style), Node(token=token, children=children, delimiter=delimiter, attributes=attributes)]
+            )
+            break
+        elif token == commands.SIDESET:
+            left, right, operator = tuple(_walk(tokens, terminator=terminator, limit=3))
+            left_token, left_children = _make_subsup(left)
+            right_token, right_children = _make_subsup(right)
+            attributes = {"movablelimits": "false"}
+            node = Node(
+                token=token,
+                children=(
+                    Node(
+                        token=left_token,
+                        children=(
+                            Node(
+                                token=commands.VPHANTOM,
+                                children=(
+                                    Node(token=operator.token, children=operator.children, attributes=attributes),
+                                ),
+                            ),
+                            *left_children,
+                        ),
+                    ),
+                    Node(
+                        token=right_token,
+                        children=(
+                            Node(token=operator.token, children=operator.children, attributes=attributes),
+                            *right_children,
+                        ),
+                    ),
+                ),
+            )
+        elif token == commands.SKEW:
+            width_node, child = tuple(_walk(tokens, terminator=terminator, limit=2))
+            width = width_node.token
+            if width == commands.BRACES:
+                if width_node.children is None or len(width_node.children) == 0:
+                    raise InvalidWidthError
+                width = width_node.children[0].token
+            if not width.isdigit():
+                raise InvalidWidthError
+            node = Node(token=token, children=(child,), attributes={"width": f"{0.0555 * int(width):.3f}em"})
+        elif token.startswith(commands.BEGIN):
+            node = _get_environment_node(token, tokens)
+        else:
+            node = Node(token=token)
+
+        group.append(node)
+
+        if limit and len(group) >= limit:
+            break
+    if not has_available_tokens:
+        raise NoAvailableTokensError
+    return group
+
+
+def _make_subsup(node: Node) -> Tuple[str, Tuple[Node, ...]]:
+    # TODO: raise error instead of assertion
+    assert node.token == commands.BRACES
+    try:
+        assert (
+            node.children is not None
+            and 2 <= len(node.children[0].children) <= 3
+            and node.children[0].token
+            in (
+                commands.SUBSUP,
+                commands.SUBSCRIPT,
+                commands.SUPERSCRIPT,
+            )
+        )
+        token = node.children[0].token
+        children = node.children[0].children[1:]
+        return token, children
+    except IndexError:
+        return "", ()
+
+
+def _get_dimension(node: Node) -> str:
+    dimension = node.token
+    if node.token == commands.BRACES and node.children is not None:
+        dimension = node.children[0].token
+    return dimension
+
+
+def _get_style(node: Node) -> str:
+    style = node.token
+    if node.token == commands.BRACES and node.children is not None:
+        style = node.children[0].token
+    if style == "0":
+        return commands.DISPLAYSTYLE
+    if style == "1":
+        return commands.TEXTSTYLE
+    if style == "2":
+        return commands.SCRIPTSTYLE
+    if style == "3":
+        return commands.SCRIPTSCRIPTSTYLE
+    raise InvalidStyleForGenfracError
+
+
+def _get_environment_node(token: str, tokens: Iterator[str]) -> Node:
+    # TODO: support non-matrix environments
+    start_index = token.index("{") + 1
+    environment = token[start_index:-1]
+    terminator = rf"{commands.END}{{{environment}}}"
+    children = tuple(_walk(tokens, terminator=terminator))
+    if len(children) and children[-1].token != terminator:
+        raise MissingEndError
+    children = children[:-1]
+    alignment = ""
+
+    if len(children) and children[0].token == commands.OPENING_BRACKET:
+        children_iter = iter(children)
+        next(children_iter)  # remove BRACKET
+        for c in children_iter:
+            if c.token == commands.CLOSING_BRACKET:
+                break
+            elif c.token not in "lcr|":
+                raise InvalidAlignmentError
+            alignment += c.token
+        children = tuple(children_iter)
+    elif (
+        len(children)
+        and children[0].children is not None
+        and (
+            children[0].token == commands.BRACES
+            or (environment.endswith("*") and children[0].token == commands.BRACKETS)
+        )
+        and all(c.token in "lcr|" for c in children[0].children)
+    ):
+        alignment = "".join(c.token for c in children[0].children)
+        children = children[1:]
+
+    return Node(token=rf"\{environment}", children=children, alignment=alignment)

videollama2/lib/python3.10/site-packages/shortuuid/__init__.py

@@ -0,0 +1,18 @@
+from shortuuid.main import decode
+from shortuuid.main import encode
+from shortuuid.main import get_alphabet
+from shortuuid.main import random
+from shortuuid.main import set_alphabet
+from shortuuid.main import ShortUUID
+from shortuuid.main import uuid
+
+__version__ = "1.0.11"
+__all__ = [
+    "decode",
+    "encode",
+    "get_alphabet",
+    "random",
+    "set_alphabet",
+    "ShortUUID",
+    "uuid",
+]

videollama2/lib/python3.10/site-packages/shortuuid/cli.py

@@ -0,0 +1,50 @@
+import argparse
+import sys
+from typing import Any
+from uuid import UUID
+
+from .main import decode
+from .main import encode
+from .main import uuid
+
+
+def encode_cli(args: argparse.Namespace):
+    print(encode(args.uuid))
+
+
+def decode_cli(args: argparse.Namespace):
+    print(str(decode(args.shortuuid, legacy=args.legacy)))
+
+
+def cli(*args: Any) -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate, encode and decode shortuuids",
+        epilog="top-level command generates a random shortuuid",
+    )
+
+    subparsers = parser.add_subparsers(help="sub-command help")
+
+    encode_parser = subparsers.add_parser(
+        "encode", help="Encode a UUID into a short UUID", description=encode.__doc__
+    )
+    encode_parser.add_argument("uuid", type=UUID, help="UUID to be encoded")
+    encode_parser.set_defaults(func=encode_cli)
+
+    decode_parser = subparsers.add_parser(
+        "decode", help="Decode a short UUID into a UUID", description=decode.__doc__
+    )
+    decode_parser.add_argument("shortuuid", type=str, help="Short UUID to be decoded")
+    decode_parser.add_argument("--legacy", action="store_true")
+    decode_parser.set_defaults(func=decode_cli)
+
+    passed_args = parser.parse_args(*args)
+
+    if hasattr(passed_args, "func"):
+        passed_args.func(passed_args)
+    else:
+        # Maintain legacy behaviour
+        print(uuid())
+
+
+if __name__ == "__main__":
+    cli(sys.argv[1:])

videollama2/lib/python3.10/site-packages/shortuuid/django_fields.py

@@ -0,0 +1,39 @@
+from typing import Any
+from typing import Dict
+from typing import Tuple
+
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+from . import ShortUUID
+
+
+class ShortUUIDField(models.CharField):
+    description = _("A short UUID field.")
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.length: int = kwargs.pop("length", 22)  # type: ignore
+        self.prefix: str = kwargs.pop("prefix", "")  # type: ignore
+
+        if "max_length" not in kwargs:
+            # If `max_length` was not specified, set it here.
+            kwargs["max_length"] = self.length + len(self.prefix)  # type: ignore
+
+        self.alphabet: str = kwargs.pop("alphabet", None)  # type: ignore
+        kwargs["default"] = self._generate_uuid  # type: ignore
+
+        super().__init__(*args, **kwargs)
+
+    def _generate_uuid(self) -> str:
+        """Generate a short random string."""
+        return self.prefix + ShortUUID(alphabet=self.alphabet).random(
+            length=self.length
+        )
+
+    def deconstruct(self) -> Tuple[str, str, Tuple, Dict[str, Any]]:
+        name, path, args, kwargs = super().deconstruct()
+        kwargs["alphabet"] = self.alphabet
+        kwargs["length"] = self.length
+        kwargs["prefix"] = self.prefix
+        kwargs.pop("default", None)
+        return name, path, args, kwargs

videollama2/lib/python3.10/site-packages/shortuuid/main.py

@@ -0,0 +1,137 @@
+"""Concise UUID generation."""
+
+import math
+import secrets
+import uuid as _uu
+from typing import List
+from typing import Optional
+
+
+def int_to_string(
+    number: int, alphabet: List[str], padding: Optional[int] = None
+) -> str:
+    """
+    Convert a number to a string, using the given alphabet.
+
+    The output has the most significant digit first.
+    """
+    output = ""
+    alpha_len = len(alphabet)
+    while number:
+        number, digit = divmod(number, alpha_len)
+        output += alphabet[digit]
+    if padding:
+        remainder = max(padding - len(output), 0)
+        output = output + alphabet[0] * remainder
+    return output[::-1]
+
+
+def string_to_int(string: str, alphabet: List[str]) -> int:
+    """
+    Convert a string to a number, using the given alphabet.
+
+    The input is assumed to have the most significant digit first.
+    """
+    number = 0
+    alpha_len = len(alphabet)
+    for char in string:
+        number = number * alpha_len + alphabet.index(char)
+    return number
+
+
+class ShortUUID(object):
+    def __init__(self, alphabet: Optional[str] = None) -> None:
+        if alphabet is None:
+            alphabet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ" "abcdefghijkmnopqrstuvwxyz"
+
+        self.set_alphabet(alphabet)
+
+    @property
+    def _length(self) -> int:
+        """Return the necessary length to fit the entire UUID given the current alphabet."""
+        return int(math.ceil(math.log(2**128, self._alpha_len)))
+
+    def encode(self, uuid: _uu.UUID, pad_length: Optional[int] = None) -> str:
+        """
+        Encode a UUID into a string (LSB first) according to the alphabet.
+
+        If leftmost (MSB) bits are 0, the string might be shorter.
+        """
+        if not isinstance(uuid, _uu.UUID):
+            raise ValueError("Input `uuid` must be a UUID object.")
+        if pad_length is None:
+            pad_length = self._length
+        return int_to_string(uuid.int, self._alphabet, padding=pad_length)
+
+    def decode(self, string: str, legacy: bool = False) -> _uu.UUID:
+        """
+        Decode a string according to the current alphabet into a UUID.
+
+        Raises ValueError when encountering illegal characters or a too-long string.
+
+        If string too short, fills leftmost (MSB) bits with 0.
+
+        Pass `legacy=True` if your UUID was encoded with a ShortUUID version prior to
+        1.0.0.
+        """
+        if not isinstance(string, str):
+            raise ValueError("Input `string` must be a str.")
+        if legacy:
+            string = string[::-1]
+        return _uu.UUID(int=string_to_int(string, self._alphabet))
+
+    def uuid(self, name: Optional[str] = None, pad_length: Optional[int] = None) -> str:
+        """
+        Generate and return a UUID.
+
+        If the name parameter is provided, set the namespace to the provided
+        name and generate a UUID.
+        """
+        if pad_length is None:
+            pad_length = self._length
+
+        # If no name is given, generate a random UUID.
+        if name is None:
+            u = _uu.uuid4()
+        elif name.lower().startswith(("http://", "https://")):
+            u = _uu.uuid5(_uu.NAMESPACE_URL, name)
+        else:
+            u = _uu.uuid5(_uu.NAMESPACE_DNS, name)
+        return self.encode(u, pad_length)
+
+    def random(self, length: Optional[int] = None) -> str:
+        """Generate and return a cryptographically secure short random string of `length`."""
+        if length is None:
+            length = self._length
+
+        return "".join(secrets.choice(self._alphabet) for _ in range(length))
+
+    def get_alphabet(self) -> str:
+        """Return the current alphabet used for new UUIDs."""
+        return "".join(self._alphabet)
+
+    def set_alphabet(self, alphabet: str) -> None:
+        """Set the alphabet to be used for new UUIDs."""
+        # Turn the alphabet into a set and sort it to prevent duplicates
+        # and ensure reproducibility.
+        new_alphabet = list(sorted(set(alphabet)))
+        if len(new_alphabet) > 1:
+            self._alphabet = new_alphabet
+            self._alpha_len = len(self._alphabet)
+        else:
+            raise ValueError("Alphabet with more than " "one unique symbols required.")
+
+    def encoded_length(self, num_bytes: int = 16) -> int:
+        """Return the string length of the shortened UUID."""
+        factor = math.log(256) / math.log(self._alpha_len)
+        return int(math.ceil(factor * num_bytes))
+
+
+# For backwards compatibility
+_global_instance = ShortUUID()
+encode = _global_instance.encode
+decode = _global_instance.decode
+uuid = _global_instance.uuid
+random = _global_instance.random
+get_alphabet = _global_instance.get_alphabet
+set_alphabet = _global_instance.set_alphabet

videollama2/lib/python3.10/site-packages/shortuuid/test_shortuuid.py

@@ -0,0 +1,224 @@
+import os
+import string
+import sys
+import unittest
+from collections import defaultdict
+from unittest.mock import patch
+from uuid import UUID
+from uuid import uuid4
+
+from shortuuid.cli import cli
+from shortuuid.main import decode
+from shortuuid.main import encode
+from shortuuid.main import get_alphabet
+from shortuuid.main import random
+from shortuuid.main import set_alphabet
+from shortuuid.main import ShortUUID
+from shortuuid.main import uuid
+
+sys.path.insert(0, os.path.abspath(__file__ + "/../.."))
+
+
+class LegacyShortUUIDTest(unittest.TestCase):
+    def test_generation(self):
+        self.assertTrue(20 < len(uuid()) < 24)
+        self.assertTrue(20 < len(uuid("http://www.example.com/")) < 24)
+        self.assertTrue(20 < len(uuid("HTTP://www.example.com/")) < 24)
+        self.assertTrue(20 < len(uuid("example.com/")) < 24)
+
+    def test_encoding(self):
+        u = UUID("{3b1f8b40-222c-4a6e-b77e-779d5a94e21c}")
+        self.assertEqual(encode(u), "CXc85b4rqinB7s5J52TRYb")
+
+    def test_decoding(self):
+        u = UUID("{3b1f8b40-222c-4a6e-b77e-779d5a94e21c}")
+        self.assertEqual(decode("CXc85b4rqinB7s5J52TRYb"), u)
+
+    def test_alphabet(self):
+        backup_alphabet = get_alphabet()
+
+        alphabet = "01"
+        set_alphabet(alphabet)
+        self.assertEqual(alphabet, get_alphabet())
+
+        set_alphabet("01010101010101")
+        self.assertEqual(alphabet, get_alphabet())
+
+        self.assertEqual(set(uuid()), set("01"))
+        self.assertTrue(116 < len(uuid()) < 140)
+
+        u = uuid4()
+        self.assertEqual(u, decode(encode(u)))
+
+        u = uuid()
+        self.assertEqual(u, encode(decode(u)))
+
+        self.assertRaises(ValueError, set_alphabet, "1")
+        self.assertRaises(ValueError, set_alphabet, "1111111")
+
+        set_alphabet(backup_alphabet)
+
+        self.assertRaises(ValueError, lambda x: ShortUUID(x), "0")
+
+    def test_random(self):
+        self.assertEqual(len(random()), 22)
+        for i in range(1, 100):
+            self.assertEqual(len(random(i)), i)
+
+
+class ClassShortUUIDTest(unittest.TestCase):
+    def test_generation(self):
+        su = ShortUUID()
+        self.assertTrue(20 < len(su.uuid()) < 24)
+        self.assertTrue(20 < len(su.uuid("http://www.example.com/")) < 24)
+        self.assertTrue(20 < len(su.uuid("HTTP://www.example.com/")) < 24)
+        self.assertTrue(20 < len(su.uuid("example.com/")) < 24)
+
+    def test_encoding(self):
+        su = ShortUUID()
+        u = UUID("{3b1f8b40-222c-4a6e-b77e-779d5a94e21c}")
+        self.assertEqual(su.encode(u), "CXc85b4rqinB7s5J52TRYb")
+
+    def test_decoding(self):
+        su = ShortUUID()
+        u = UUID("{3b1f8b40-222c-4a6e-b77e-779d5a94e21c}")
+        self.assertEqual(su.decode("CXc85b4rqinB7s5J52TRYb"), u)
+
+    def test_random(self):
+        su = ShortUUID()
+        for i in range(1000):
+            self.assertEqual(len(su.random()), 22)
+
+        for i in range(1, 100):
+            self.assertEqual(len(su.random(i)), i)
+
+    def test_alphabet(self):
+        alphabet = "01"
+        su1 = ShortUUID(alphabet)
+        su2 = ShortUUID()
+
+        self.assertEqual(alphabet, su1.get_alphabet())
+
+        su1.set_alphabet("01010101010101")
+        self.assertEqual(alphabet, su1.get_alphabet())
+
+        self.assertEqual(set(su1.uuid()), set("01"))
+        self.assertTrue(116 < len(su1.uuid()) < 140)
+        self.assertTrue(20 < len(su2.uuid()) < 24)
+
+        u = uuid4()
+        self.assertEqual(u, su1.decode(su1.encode(u)))
+
+        u = su1.uuid()
+        self.assertEqual(u, su1.encode(su1.decode(u)))
+
+        self.assertRaises(ValueError, su1.set_alphabet, "1")
+        self.assertRaises(ValueError, su1.set_alphabet, "1111111")
+
+    def test_encoded_length(self):
+        su1 = ShortUUID()
+        self.assertEqual(su1.encoded_length(), 22)
+
+        base64_alphabet = (
+            string.ascii_uppercase + string.ascii_lowercase + string.digits + "+/"
+        )
+
+        su2 = ShortUUID(base64_alphabet)
+        self.assertEqual(su2.encoded_length(), 22)
+
+        binary_alphabet = "01"
+        su3 = ShortUUID(binary_alphabet)
+        self.assertEqual(su3.encoded_length(), 128)
+
+        su4 = ShortUUID()
+        self.assertEqual(su4.encoded_length(num_bytes=8), 11)
+
+
+class ShortUUIDPaddingTest(unittest.TestCase):
+    def test_padding(self):
+        su = ShortUUID()
+        random_uid = uuid4()
+        smallest_uid = UUID(int=0)
+
+        encoded_random = su.encode(random_uid)
+        encoded_small = su.encode(smallest_uid)
+
+        self.assertEqual(len(encoded_random), len(encoded_small))
+
+    def test_decoding(self):
+        su = ShortUUID()
+        random_uid = uuid4()
+        smallest_uid = UUID(int=0)
+
+        encoded_random = su.encode(random_uid)
+        encoded_small = su.encode(smallest_uid)
+
+        self.assertEqual(su.decode(encoded_small), smallest_uid)
+        self.assertEqual(su.decode(encoded_random), random_uid)
+
+    def test_consistency(self):
+        su = ShortUUID()
+        num_iterations = 1000
+        uid_lengths = defaultdict(int)
+
+        for count in range(num_iterations):
+            random_uid = uuid4()
+            encoded_random = su.encode(random_uid)
+            uid_lengths[len(encoded_random)] += 1
+            decoded_random = su.decode(encoded_random)
+
+            self.assertEqual(random_uid, decoded_random)
+
+        self.assertEqual(len(uid_lengths), 1)
+        uid_length = next(iter(uid_lengths.keys()))  # Get the 1 value
+
+        self.assertEqual(uid_lengths[uid_length], num_iterations)
+
+
+class EncodingEdgeCasesTest(unittest.TestCase):
+    def test_decode_dict(self):
+        su = ShortUUID()
+        self.assertRaises(ValueError, su.encode, [])
+        self.assertRaises(ValueError, su.encode, {})
+        self.assertRaises(ValueError, su.decode, (2,))
+        self.assertRaises(ValueError, su.encode, 42)
+        self.assertRaises(ValueError, su.encode, 42.0)
+
+
+class DecodingEdgeCasesTest(unittest.TestCase):
+    def test_decode_dict(self):
+        su = ShortUUID()
+        self.assertRaises(ValueError, su.decode, [])
+        self.assertRaises(ValueError, su.decode, {})
+        self.assertRaises(ValueError, su.decode, (2,))
+        self.assertRaises(ValueError, su.decode, 42)
+        self.assertRaises(ValueError, su.decode, 42.0)
+
+
+class CliTest(unittest.TestCase):
+    @patch("shortuuid.cli.print")
+    def test_shortuuid_command_produces_uuid(self, mock_print):
+        # When we call the main cli function
+        cli([])
+        # Then a shortuuid is printed out
+        mock_print.assert_called()
+        terminal_output = mock_print.call_args[0][0]
+        self.assertEqual(len(terminal_output), 22)
+
+    @patch("shortuuid.cli.print")
+    def test_encode_command(self, mock_print):
+        cli(["encode", "3b1f8b40-222c-4a6e-b77e-779d5a94e21c"])
+
+        terminal_output = mock_print.call_args[0][0]
+        self.assertEqual(terminal_output, "CXc85b4rqinB7s5J52TRYb")
+
+    @patch("shortuuid.cli.print")
+    def test_decode_command(self, mock_print):
+        cli(["decode", "CXc85b4rqinB7s5J52TRYb"])
+
+        terminal_output = mock_print.call_args[0][0]
+        self.assertEqual(terminal_output, "3b1f8b40-222c-4a6e-b77e-779d5a94e21c")
+
+
+if __name__ == "__main__":
+    unittest.main()