Add files using upload-large-folder tool

.gitattributes

@@ -974,3 +974,4 @@ videollama2/lib/python3.10/site-packages/pydantic_core/_pydantic_core.cpython-31
 videollama2/lib/python3.10/site-packages/altair/vegalite/v5/__pycache__/api.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Bold.ttf filter=lfs diff=lfs merge=lfs -text
 parrot/lib/ossl-modules/legacy.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/cupy_backends/cuda/libs/cusparse.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/gpu_association.py

@@ -0,0 +1,23 @@
+'''OpenGL extension AMD.gpu_association
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.AMD.gpu_association to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/gpu_association.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.AMD.gpu_association import *
+from OpenGL.raw.GLX.AMD.gpu_association import _EXTENSION_NAME
+
+def glInitGpuAssociationAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.create_context
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.create_context to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/create_context.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.create_context import *
+from OpenGL.raw.GLX.ARB.create_context import _EXTENSION_NAME
+
+def glInitCreateContextARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_profile.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.create_context_profile
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.create_context_profile to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/create_context_profile.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.create_context_profile import *
+from OpenGL.raw.GLX.ARB.create_context_profile import _EXTENSION_NAME
+
+def glInitCreateContextProfileARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_robustness.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.create_context_robustness
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.create_context_robustness to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/create_context_robustness.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.create_context_robustness import *
+from OpenGL.raw.GLX.ARB.create_context_robustness import _EXTENSION_NAME
+
+def glInitCreateContextRobustnessARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/fbconfig_float.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.fbconfig_float
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.fbconfig_float to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/fbconfig_float.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.fbconfig_float import *
+from OpenGL.raw.GLX.ARB.fbconfig_float import _EXTENSION_NAME
+
+def glInitFbconfigFloatARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py

@@ -0,0 +1,55 @@
+'''OpenGL extension ARB.framebuffer_sRGB
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.framebuffer_sRGB to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Conventionally, OpenGL assumes framebuffer color components are stored
+	in a linear color space.  In particular, framebuffer blending is a
+	linear operation.
+	
+	The sRGB color space is based on typical (non-linear) monitor
+	characteristics expected in a dimly lit office.  It has been
+	standardized by the International Electrotechnical Commission (IEC)
+	as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2
+	gamma correction.
+	
+	This extension adds a framebuffer capability for sRGB framebuffer
+	update and blending.  When blending is disabled but the new sRGB
+	updated mode is enabled (assume the framebuffer supports the
+	capability), high-precision linear color component values for red,
+	green, and blue generated by fragment coloring are encoded for sRGB
+	prior to being written into the framebuffer.  When blending is enabled
+	along with the new sRGB update mode, red, green, and blue framebuffer
+	color components are treated as sRGB values that are converted to
+	linear color values, blended with the high-precision color values
+	generated by fragment coloring, and then the blend result is encoded
+	for sRGB just prior to being written into the framebuffer.
+	
+	The primary motivation for this extension is that it allows OpenGL
+	applications to render into a framebuffer that is scanned to a monitor
+	configured to assume framebuffer color values are sRGB encoded.
+	This assumption is roughly true of most PC monitors with default
+	gamma correction.  This allows applications to achieve faithful
+	color reproduction for OpenGL rendering without adjusting the
+	monitor's gamma correction.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/framebuffer_sRGB.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.framebuffer_sRGB import *
+from OpenGL.raw.GLX.ARB.framebuffer_sRGB import _EXTENSION_NAME
+
+def glInitFramebufferSrgbARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.robustness_application_isolation
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.robustness_application_isolation to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/robustness_application_isolation.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.robustness_application_isolation import *
+from OpenGL.raw.GLX.ARB.robustness_application_isolation import _EXTENSION_NAME
+
+def glInitRobustnessApplicationIsolationARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.robustness_share_group_isolation
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.robustness_share_group_isolation to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/robustness_share_group_isolation.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.robustness_share_group_isolation import *
+from OpenGL.raw.GLX.ARB.robustness_share_group_isolation import _EXTENSION_NAME
+
+def glInitRobustnessShareGroupIsolationARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py

@@ -0,0 +1,81 @@
+'''OpenGL extension ARB.vertex_buffer_object
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.ARB.vertex_buffer_object to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension defines an interface that allows various types of data
+	(especially vertex array data) to be cached in high-performance
+	graphics memory on the server, thereby increasing the rate of data
+	transfers.
+	
+	Chunks of data are encapsulated within "buffer objects", which
+	conceptually are nothing more than arrays of bytes, just like any
+	chunk of memory.  An API is provided whereby applications can read
+	from or write to buffers, either via the GL itself (glBufferData,
+	glBufferSubData, glGetBufferSubData) or via a pointer to the memory.
+	
+	The latter technique is known as "mapping" a buffer.  When an
+	application maps a buffer, it is given a pointer to the memory.  When
+	the application finishes reading from or writing to the memory, it is
+	required to "unmap" the buffer before it is once again permitted to
+	use that buffer as a GL data source or sink.  Mapping often allows
+	applications to eliminate an extra data copy otherwise required to
+	access the buffer, thereby enhancing performance.  In addition,
+	requiring that applications unmap the buffer to use it as a data
+	source or sink ensures that certain classes of latent synchronization
+	bugs cannot occur.
+	
+	Although this extension only defines hooks for buffer objects to be
+	used with OpenGL's vertex array APIs, the API defined in this
+	extension permits buffer objects to be used as either data sources or
+	sinks for any GL command that takes a pointer as an argument.
+	Normally, in the absence of this extension, a pointer passed into the
+	GL is simply a pointer to the user's data.  This extension defines
+	a mechanism whereby this pointer is used not as a pointer to the data
+	itself, but as an offset into a currently bound buffer object.  The
+	buffer object ID zero is reserved, and when buffer object zero is
+	bound to a given target, the commands affected by that buffer binding
+	behave normally.  When a nonzero buffer ID is bound, then the pointer
+	represents an offset.
+	
+	In the case of vertex arrays, this extension defines not merely one
+	binding for all attributes, but a separate binding for each
+	individual attribute.  As a result, applications can source their
+	attributes from multiple buffers.  An application might, for example,
+	have a model with constant texture coordinates and variable geometry.
+	The texture coordinates might be retrieved from a buffer object with
+	the usage mode "STATIC_DRAW", indicating to the GL that the
+	application does not expect to update the contents of the buffer
+	frequently or even at all, while the vertices might be retrieved from
+	a buffer object with the usage mode "STREAM_DRAW", indicating that
+	the vertices will be updated on a regular basis.
+	
+	In addition, a binding is defined by which applications can source
+	index data (as used by DrawElements, DrawRangeElements, and
+	MultiDrawElements) from a buffer object.  On some platforms, this
+	enables very large models to be rendered with no more than a few
+	small commands to the graphics device.
+	
+	It is expected that a future extension will allow sourcing pixel data
+	from and writing pixel data to a buffer object.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.ARB.vertex_buffer_object import *
+from OpenGL.raw.GLX.ARB.vertex_buffer_object import _EXTENSION_NAME
+
+def glInitVertexBufferObjectARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/multisample.py

@@ -0,0 +1,65 @@
+'''OpenGL extension DFX.multisample
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.DFX.multisample to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	    This extension provides a mechanism to antialias all GL primitives:
+	    points, lines, polygons, bitmaps, and images. The technique is to
+	    sample all primitives multiple times at each pixel. The color sample
+	    values are resolved to a single, displayable color each time a pixel
+	    is updated, so the antialiasing appears to be automatic at the
+	    application level. Because each sample includes depth and stencil
+	    information, the depth and stencil functions perform equivalently to
+	    the single-sample mode.
+	
+	    An additional buffer, called the multisample buffer, is added to the
+	    framebuffer. Pixel sample values, including color, depth, and
+	    stencil values, are stored in this buffer. When the framebuffer
+	    includes a multisample buffer, it does not also include separate
+	    depth or stencil buffers, even if the multisample buffer does not
+	    store depth or stencil values. Color buffers (left/right,
+	    front/back, and aux) do coexist with the multisample buffer,
+	    however.
+	
+	    Multisample antialiasing is most valuable for rendering polygons,
+	    because it requires no sorting for hidden surface elimination, and
+	    it correctly handles adjacent polygons, object silhouettes, and even
+	    intersecting polygons. If only points or lines are being rendered,
+	    the "smooth" antialiasing mechanism provided by the base GL may
+	    result in a higher quality image.
+	
+	    This extension is a subset of SGIS_multisample. It differs in these
+	    key ways:
+	
+	       * Fragment alpha values are not affected by the fragment sample mask
+	       * The sample locations may or may not be fixed. Thus, there is no
+		 support for rendering the scene multiple times with different
+		 sample points.
+	       * Fragment masks are not computed for images or for bitmasks.
+	
+	    Because of these differences a new extension was created. However,
+	    it is not expected that this extension will co-exist with
+	    SGIS_multisample. Because of this and the fact that there are only
+	    32 push/pop bits the MULTISAMPLE_BIT_SGIS state value is the same as
+	    MUTLISAMPLE_BIT_3DFX.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/DFX/multisample.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.DFX.multisample import *
+from OpenGL.raw.GLX.DFX.multisample import _EXTENSION_NAME
+
+def glInitMultisampleDFX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/agp_offset.py

@@ -0,0 +1,31 @@
+'''OpenGL extension MESA.agp_offset
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.MESA.agp_offset to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extensions provides a way to convert pointers in an AGP memory
+	region into byte offsets into the AGP aperture.
+	Note, this extension depends on GLX_NV_vertex_array_range, for which
+	no real specification exists.  See GL_NV_vertex_array_range for more
+	information.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/agp_offset.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.MESA.agp_offset import *
+from OpenGL.raw.GLX.MESA.agp_offset import _EXTENSION_NAME
+
+def glInitAgpOffsetMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py

@@ -0,0 +1,30 @@
+'''OpenGL extension MESA.copy_sub_buffer
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.MESA.copy_sub_buffer to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The glxCopySubBufferMESA() function copies a rectangular region
+	of the back color buffer to the front color buffer.  This can be
+	used to quickly repaint 3D windows in response to expose events
+	when the back color buffer cannot be damaged by other windows.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/copy_sub_buffer.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.MESA.copy_sub_buffer import *
+from OpenGL.raw.GLX.MESA.copy_sub_buffer import _EXTENSION_NAME
+
+def glInitCopySubBufferMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py

@@ -0,0 +1,35 @@
+'''OpenGL extension MESA.pixmap_colormap
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.MESA.pixmap_colormap to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Since Mesa allows RGB rendering into drawables with PseudoColor,
+	StaticColor, GrayScale and StaticGray visuals, Mesa needs a colormap
+	in order to compute pixel values during rendering.
+	
+	The colormap associated with a window can be queried with normal
+	Xlib functions but there is no colormap associated with pixmaps.
+	
+	The glXCreateGLXPixmapMESA function is an alternative to glXCreateGLXPixmap
+	which allows specification of a colormap.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/pixmap_colormap.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.MESA.pixmap_colormap import *
+from OpenGL.raw.GLX.MESA.pixmap_colormap import _EXTENSION_NAME
+
+def glInitPixmapColormapMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/query_renderer.py

@@ -0,0 +1,23 @@
+'''OpenGL extension MESA.query_renderer
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.MESA.query_renderer to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/query_renderer.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.MESA.query_renderer import *
+from OpenGL.raw.GLX.MESA.query_renderer import _EXTENSION_NAME
+
+def glInitQueryRendererMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py

@@ -0,0 +1,29 @@
+'''OpenGL extension MESA.set_3dfx_mode
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.MESA.set_3dfx_mode to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The Mesa Glide driver allows full-screen rendering or rendering into
+	an X window.  The glXSet3DfxModeMESA() function allows an application
+	to switch between full-screen and windowed rendering.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/set_3dfx_mode.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.MESA.set_3dfx_mode import *
+from OpenGL.raw.GLX.MESA.set_3dfx_mode import _EXTENSION_NAME
+
+def glInitSet3DfxModeMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/swap_method.py

@@ -0,0 +1,23 @@
+'''OpenGL extension OML.swap_method
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.OML.swap_method to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/OML/swap_method.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.OML.swap_method import *
+from OpenGL.raw.GLX.OML.swap_method import _EXTENSION_NAME
+
+def glInitSwapMethodOML():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/sync_control.py

@@ -0,0 +1,23 @@
+'''OpenGL extension OML.sync_control
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.OML.sync_control to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/OML/sync_control.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.OML.sync_control import *
+from OpenGL.raw.GLX.OML.sync_control import _EXTENSION_NAME
+
+def glInitSyncControlOML():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/dmbuffer.py

@@ -0,0 +1,71 @@
+'''OpenGL extension SGIX.dmbuffer
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.SGIX.dmbuffer to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension introduces a new type of GLXPbuffer, a DM or Digital
+	Media pbuffer.  A DM pbuffer is a GLXPbuffer that adopts one or more 
+	of its buffers from an externally defined and allocated DMbuffer. 
+	In this way it resembles a GLXPixmap that attaches to an existing
+	X pixmap.  Like a standard pbuffer it can be used as a non-displayable
+	rendering area, or as a read source for pixel data.  The externally
+	defined buffers of the DM pbuffer can be sequentially associated 
+	with other DM buffers of the same size and configuration.  
+	
+	.  The DM pbuffer is described with a new attrib passed to 
+	   glXCreateGLXPbuffer.  
+	
+	.  A new GLX command allows associating a compatible DMbuffer with 
+	   the DM GLXPbuffer.  At associate time the DM buffers described 
+	   by the DMparams are used directly as the corresponding 
+	   buffers of the GLXPbuffer drawable, as described by the FBconfig.  
+	   All other buffers that are part of the config will be created by
+	   GL without externally referenceable names.  A DM pbuffer must be
+	   associated with a compatible DMbuffer before it can be made current
+	   to a GLX context. 
+	
+	.  The externally defined buffers of the DM pbuffer can be changed at 
+	   any time by successfully associating a new DMbuffer with the GLXPbuffer 
+	   through the associate command.  It will be the application's 
+	   responsibility to synchronize DMedia, GLX, and GL commands that 
+	   effect the contents of the DM pbuffer.
+	
+	.  Any direct GLX rendering context that satisfies config compatibility
+	   can be used to render to or read from a DM GLXPbuffer.
+	   A currently associated DMbuffer may simultaneously be in use by 
+	   other clients on the same Display, but will not be destroyed
+	   while associated with a GLXPbuffer.  When the GLXpbuffer is
+	   destroyed, all buffers that have no remaining clients, including
+	   the DMbuffer, will be freed.
+	
+	DM GLXPbuffers are proposed as a means for OpenGL to access buffers
+	generated by the VL, compression, and other digital media libraries in 
+	a uniform way.  The DMbuffer and DMparams descriptors are left 
+	intentionally abstract so that the GLX extension can adapt to future 
+	DM library changes.  
+	The initial implementation will require that the DMparams descriptor
+	supply at least pixel format and packing information, and that the  
+	DMbuffer provide the size and location of a colorbuffer.  GLX will do 
+	compatibility checking when possible based on the config, params, and 
+	buffer information at associate time. 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/dmbuffer.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.SGIX.dmbuffer import *
+from OpenGL.raw.GLX.SGIX.dmbuffer import _EXTENSION_NAME
+
+def glInitDmbufferSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/pbuffer.py

@@ -0,0 +1,60 @@
+'''OpenGL extension SGIX.pbuffer
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.SGIX.pbuffer to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	    This extension defines pixel buffers (GLXPbuffers, or pbuffer for
+	    short). GLXPbuffers are additional non-visible rendering buffers for an
+	    OpenGL renderer.  GLXPbuffers are equivalent to GLXPixmaps with the
+	    following exceptions:
+	
+	    1.	There is no associated X pixmap. Also, since a GLXPbuffer is a GLX
+	        resource, it may not be possible to render to it using X or an 
+	   	X extension other than GLX.
+	
+	    2.	The format of the color buffers and the type and size of any
+	     	associated ancillary buffers for a GLXPbuffer can only be
+	        described with a GLXFBConfig -- an X Visual cannot be used.
+	
+	    3.	It is possible to create a GLXPbuffer whose contents may be 
+		asynchronously lost at any time.
+	
+	    4.  GLXPbuffers can be rendered to using either direct or indirect
+	        rendering contexts.
+	
+	    5.  The allocation of a GLXPbuffer can fail if there are insufficient
+		resources (i.e., all the pbuffer memory has been allocated and 
+		the implementation does not virtualize pbuffer memory.)
+	
+	    The intent of the pbuffer semantics is to enable implementations to
+	    allocate pbuffers in non-visible frame buffer memory.  These
+	    pbuffers are intended to be "static" resources, in that a program
+	    will typically allocate them only once, rather than as a part of its
+	    rendering loop.  (But they should be deallocated when the program is
+	    no longer using them -- for example, if the program is iconified.)
+	    The frame buffer resources that are associated with a pbuffer are 
+	    also static, and are deallocated only when the pbuffer is destroyed, 
+	    or, in the case of a "unpreserved" pbuffer, as a result of X server 
+	    activity that changes its frame buffer requirements.
+	
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/pbuffer.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.SGIX.pbuffer import *
+from OpenGL.raw.GLX.SGIX.pbuffer import _EXTENSION_NAME
+
+def glInitPbufferSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_barrier.py

@@ -0,0 +1,37 @@
+'''OpenGL extension SGIX.swap_barrier
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.SGIX.swap_barrier to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides the capability to sychronize the buffer
+	swaps of different swap groups.
+	
+	A swap group is bound to a _swap_barrier_.  The buffer swaps of each 
+	swap group using that barrier will wait until every swap group using 
+	that barrier is ready to swap (where readiness is defined below), after
+	which time all buffer swaps of all groups using that barrier will
+	take place concurrently.
+	
+	This extension extends the set of conditions that must be met before
+	a buffer swap can take place. 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/swap_barrier.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.SGIX.swap_barrier import *
+from OpenGL.raw.GLX.SGIX.swap_barrier import _EXTENSION_NAME
+
+def glInitSwapBarrierSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_group.py

@@ -0,0 +1,33 @@
+'''OpenGL extension SGIX.swap_group
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.SGIX.swap_group to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides the capability to synchronize the buffer swaps
+	of a group of GLX drawables.  A swap group is created, and drawables are 
+	added as members to the swap group.  Buffer swaps to members of the swap 
+	group will then take place concurrently.
+	
+	This extension extends the set of conditions that must be met before
+	a buffer swap can take place. 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/swap_group.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.SGIX.swap_group import *
+from OpenGL.raw.GLX.SGIX.swap_group import _EXTENSION_NAME
+
+def glInitSwapGroupSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_resize.py

@@ -0,0 +1,37 @@
+'''OpenGL extension SGIX.video_resize
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.SGIX.video_resize to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a means for doing swap or frame synchronous 
+	resizing/panning of the area 
+	that is to be magnified (or passed through) to the output
+	video resolution.  The purpose of this functionality is to provide a
+	means of allowing an application to draw into a smaller viewport to
+	reduce the time spent doing pixel fill.  This reduced size viewport
+	is then magnified up to the video output resolution using the 
+	SGIX_video_resize extension.  This extension differs from SGIX_framezoom
+	(number 57) in that it is post framebuffer resizing.  Over rendering
+	at swap rates and panning at frame rates is possible using frame synchronous
+	update instead of swap synchronous update used for the fill reduction case. 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/video_resize.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.SGIX.video_resize import *
+from OpenGL.raw.GLX.SGIX.video_resize import _EXTENSION_NAME
+
+def glInitVideoResizeSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_source.py

@@ -0,0 +1,33 @@
+'''OpenGL extension SGIX.video_source
+
+This module customises the behaviour of the 
+OpenGL.raw.GLX.SGIX.video_source to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides the capability to source pixel data from a
+	video stream.  A new type of GLXDrawable (GLXVideoSourceSGIX) is
+	introduced which represents the drain node of a Video Library (VL)
+	path.  A GLXVideoSourceSGIX may be specified as the <read> parameter
+	to glXMakeCurrentReadSGI to indicate that pixel data should be read
+	from the specified video source instead of from the framebuffer.  A
+	GLXVideoSourceSGIX may only be specified as a <read> drawable.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/video_source.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GLX import _types, _glgets
+from OpenGL.raw.GLX.SGIX.video_source import *
+from OpenGL.raw.GLX.SGIX.video_source import _EXTENSION_NAME
+
+def glInitVideoSourceSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION