Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/OpenGL/GL/ATI/element_array.py

@@ -0,0 +1,42 @@
+'''OpenGL extension ATI.element_array
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.ATI.element_array to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a mechanism for an application to create
+	an array of index data for use in specifying geometric primitives.
+	
+	This extension is most useful when used in conjunction with the
+	ATI_vertex_array_object extension. ATI_vertex_array_object
+	provides an interface for storing vertex array data in persistent,
+	hardware-addressable memory. In cases where large amounts of
+	vertex data are in use, the index data used to construct
+	primitives (typically as passed to the GL through DrawElements)
+	can impose a significant bandwidth burden. ATI_element_array
+	allows the application to specify independent arrays of elements,
+	which can then be cached using ATI_vertex_array_object.
+	
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ATI/element_array.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.ATI.element_array import *
+from OpenGL.raw.GL.ATI.element_array import _EXTENSION_NAME
+
+def glInitElementArrayATI():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glElementPointerATI.pointer size not checked against 'type'
+glElementPointerATI=wrapper.wrapper(glElementPointerATI).setInputArraySize(
+    'pointer', None
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/KHR/debug.py

@@ -0,0 +1,214 @@
+'''OpenGL extension KHR.debug
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.KHR.debug to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows the GL to notify applications when various events 
+	occur that may be useful during application development, debugging and 
+	profiling.
+	
+	These events are represented in the form of enumerable messages with a 
+	human-readable string representation. Examples of debug events include 
+	incorrect use of the GL, warnings of undefined behavior, and performance 
+	warnings.
+	
+	A message is uniquely identified by a source, a type and an 
+	implementation-dependent ID within the source and type pair.
+	
+	A message's source identifies the origin of the message and can either 
+	describe components of the GL, the window system, third-party external 
+	sources such as external debuggers, or even the application itself.
+	
+	The type of the message roughly identifies the nature of the event that 
+	caused the message. Examples include errors, performance warnings, 
+	warnings about undefined behavior or notifications identifying that the 
+	application is within a specific section of the application code.
+	
+	A message's ID for a given source and type further distinguishes messages 
+	within namespaces. For example, an error caused by a negative parameter 
+	value or an invalid internal texture format are both errors generated by 
+	the API, but would likely have different message IDs.
+	
+	Each message is also assigned to a severity level that denotes roughly how 
+	"important" that message is in comparison to other messages across all 
+	sources and types. For example, notification of a GL error would likely 
+	have a higher severity than a performance warning due to redundant state 
+	changes.
+	
+	Furthermore, every message contains an implementation-dependent string
+	representation that provides a useful description of the event.
+	
+	Messages are communicated to the application through an application-
+	defined callback function that is called by the GL implementation on each 
+	debug message. The motivation for the callback routine is to free 
+	application developers from actively having to query whether a GL error, 
+	or any other debuggable event has happened after each call to a GL 
+	function. With a callback, developers can keep their code free of debug 
+	checks, set breakpoints in the callback function, and only have to react 
+	to messages as they occur. In situations where using a callback is not 
+	possible, a message log is also provided that stores only copies of recent 
+	messages until they are actively queried. 
+	
+	To control the volume of debug output, messages can be disabled either 
+	individually by ID, or entire sets of messages can be turned off based on 
+	combination of source and type, through the entire application code or 
+	only section of the code encapsulated in debug groups. A debug group may 
+	also be used to annotate the command stream using descriptive texts. 
+	
+	This extension also defines debug markers, a mechanism for the OpenGL 
+	application to annotate the command stream with markers for discrete 
+	events.
+	
+	When profiling or debugging an OpenGL application with a built-in or an 
+	external debugger or profiler, it is difficult to relate the commands 
+	within the command stream to the elements of the scene or parts of the 
+	program code to which they correspond. Debug markers and debug groups help 
+	obviate this by allowing applications to specify this link. For example, a 
+	debug marker can be used to identify the beginning of a frame in the 
+	command stream and a debug group can encapsulate a specific command stream 
+	to identify a rendering pass. Debug groups also allow control of the debug 
+	outputs volume per section of an application code providing an effective 
+	way to handle the massive amount of debug outputs that drivers can 
+	generate.
+	
+	Some existing implementations of ARB_debug_output only expose the
+	ARB_debug_output extension string if the context was created with the
+	debug flag {GLX|WGL}_CONTEXT_DEBUG_BIT_ARB as specified in 
+	{GLX|WGL}_ARB_create_context. The behavior is not obvious when the
+	functionality is brought into the OpenGL core specification because the
+	extension string and function entry points must always exist.
+	
+	This extension modifies the existing ARB_debug_output extension to allow 
+	implementations to always have an empty message log. The specific messages 
+	written to the message log or callback routines are already implementation 
+	defined, so this specification simply makes it explicit that it's fine for 
+	there to be zero messages generated, even when a GL error occurs, which is 
+	useful if the context is non-debug.
+	
+	Debug output can be enabled and disabled by changing the DEBUG_OUTPUT 
+	state. It is implementation defined how much debug output is generated if 
+	the context was created without the CONTEXT_DEBUG_BIT set. This is a new 
+	query bit added to the existing GL_CONTEXT_FLAGS state to specify whether 
+	the context was created with debug enabled.
+	
+	Finally, this extension defines a mechanism for OpenGL applications to 
+	label their objects (textures, buffers, shaders, etc.) with a descriptive 
+	string. 
+	
+	When profiling or debugging an OpenGL application within an external or 
+	built-in (debut output API) debugger or profiler it is difficult to 
+	identify objects from their object names (integers). 
+	
+	Even when the object itself is viewed it can be problematic to 
+	differentiate between similar objects. Attaching a descriptive string, a 
+	label, to an object obviates this difficulty.
+	
+	The intended purpose of this extension is purely to improve the user 
+	experience within OpenGL development tools and application built-in 
+	profilers and debuggers. This extension typically improves OpenGL 
+	programmers efficiency by allowing them to instantly detect issues and the 
+	reason for these issues giving him more time to focus on adding new 
+	features to an OpenGL application.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/KHR/debug.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.KHR.debug import *
+from OpenGL.raw.GL.KHR.debug import _EXTENSION_NAME
+
+def glInitDebugKHR():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glDebugMessageControl.ids size not checked against count
+glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize(
+    'ids', None
+)
+# INPUT glDebugMessageInsert.buf size not checked against 'buf,length'
+glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize(
+    'buf', None
+)
+# INPUT glGetDebugMessageLog.lengths size not checked against count
+# INPUT glGetDebugMessageLog.ids size not checked against count
+# INPUT glGetDebugMessageLog.severities size not checked against count
+# INPUT glGetDebugMessageLog.sources size not checked against count
+# INPUT glGetDebugMessageLog.messageLog size not checked against bufSize
+# INPUT glGetDebugMessageLog.types size not checked against count
+glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setInputArraySize(
+    'lengths', None
+).setInputArraySize(
+    'ids', None
+).setInputArraySize(
+    'severities', None
+).setInputArraySize(
+    'sources', None
+).setInputArraySize(
+    'messageLog', None
+).setInputArraySize(
+    'types', None
+)
+# INPUT glPushDebugGroup.message size not checked against 'message,length'
+glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize(
+    'message', None
+)
+# INPUT glObjectLabel.label size not checked against 'label,length'
+glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize(
+    'label', None
+)
+# INPUT glGetObjectLabel.label size not checked against bufSize
+glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setInputArraySize(
+    'length', 1
+).setInputArraySize(
+    'label', None
+)
+# INPUT glObjectPtrLabel.label size not checked against 'label,length'
+glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize(
+    'label', None
+)
+# INPUT glGetObjectPtrLabel.label size not checked against bufSize
+glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setInputArraySize(
+    'length', 1
+).setInputArraySize(
+    'label', None
+)
+glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput(
+    'params',size=(1,),orPassIn=True
+)
+# INPUT glGetDebugMessageLogKHR.lengths size not checked against count
+# INPUT glGetDebugMessageLogKHR.ids size not checked against count
+# INPUT glGetDebugMessageLogKHR.severities size not checked against count
+# INPUT glGetDebugMessageLogKHR.sources size not checked against count
+# INPUT glGetDebugMessageLogKHR.messageLog size not checked against bufSize
+# INPUT glGetDebugMessageLogKHR.types size not checked against count
+glGetDebugMessageLogKHR=wrapper.wrapper(glGetDebugMessageLogKHR).setInputArraySize(
+    'lengths', None
+).setInputArraySize(
+    'ids', None
+).setInputArraySize(
+    'severities', None
+).setInputArraySize(
+    'sources', None
+).setInputArraySize(
+    'messageLog', None
+).setInputArraySize(
+    'types', None
+)
+# INPUT glGetObjectLabelKHR.label size not checked against bufSize
+glGetObjectLabelKHR=wrapper.wrapper(glGetObjectLabelKHR).setInputArraySize(
+    'label', None
+)
+# INPUT glGetObjectPtrLabelKHR.label size not checked against bufSize
+glGetObjectPtrLabelKHR=wrapper.wrapper(glGetObjectPtrLabelKHR).setInputArraySize(
+    'length', 1
+).setInputArraySize(
+    'label', None
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/KHR/texture_compression_astc_hdr.py

@@ -0,0 +1,40 @@
+'''OpenGL extension KHR.texture_compression_astc_hdr
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.KHR.texture_compression_astc_hdr to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Adaptive Scalable Texture Compression (ASTC) is a new texture
+	compression technology that offers unprecendented flexibility,
+	while producing better or comparable results than existing texture
+	compressions at all bit rates. It includes support for 2D and
+	slice-based 3D textures, with low and high dynamic range, at
+	bitrates from below 1 bit/pixel up to 8 bits/pixel in fine steps.
+	
+	The goal of this extension is to support the full 2D profile of the
+	ASTC texture compression specification, and allow construction of
+	3D textures from multiple 2D slices.
+	
+	ASTC-compressed textures are handled in OpenGL ES and OpenGL by
+	adding new supported formats to the existing mechanisms for handling
+	compressed textures.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.KHR.texture_compression_astc_hdr import *
+from OpenGL.raw.GL.KHR.texture_compression_astc_hdr import _EXTENSION_NAME
+
+def glInitTextureCompressionAstcHdrKHR():
+    '''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/GL/KHR/texture_compression_astc_ldr.py

@@ -0,0 +1,23 @@
+'''OpenGL extension KHR.texture_compression_astc_ldr
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.KHR.texture_compression_astc_ldr to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/KHR/texture_compression_astc_ldr.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.KHR.texture_compression_astc_ldr import *
+from OpenGL.raw.GL.KHR.texture_compression_astc_ldr import _EXTENSION_NAME
+
+def glInitTextureCompressionAstcLdrKHR():
+    '''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/WGL/ARB/__init__.py

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

vllm/lib/python3.10/site-packages/OpenGL/WGL/ARB/buffer_region.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.buffer_region
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.buffer_region to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/buffer_region.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.buffer_region import *
+from OpenGL.raw.WGL.ARB.buffer_region import _EXTENSION_NAME
+
+def glInitBufferRegionARB():
+    '''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/WGL/ARB/create_context.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.create_context
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.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.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.create_context import *
+from OpenGL.raw.WGL.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/WGL/ARB/create_context_profile.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.create_context_profile
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.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.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.create_context_profile import *
+from OpenGL.raw.WGL.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/WGL/ARB/create_context_robustness.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.create_context_robustness
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.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.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.create_context_robustness import *
+from OpenGL.raw.WGL.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/WGL/ARB/extensions_string.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.extensions_string
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.extensions_string to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/extensions_string.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.extensions_string import *
+from OpenGL.raw.WGL.ARB.extensions_string import _EXTENSION_NAME
+
+def glInitExtensionsStringARB():
+    '''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/WGL/ARB/framebuffer_sRGB.py

@@ -0,0 +1,55 @@
+'''OpenGL extension ARB.framebuffer_sRGB
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.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.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.framebuffer_sRGB import *
+from OpenGL.raw.WGL.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/WGL/ARB/make_current_read.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.make_current_read
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.make_current_read to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/make_current_read.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.make_current_read import *
+from OpenGL.raw.WGL.ARB.make_current_read import _EXTENSION_NAME
+
+def glInitMakeCurrentReadARB():
+    '''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/WGL/ARB/multisample.py

@@ -0,0 +1,51 @@
+'''OpenGL extension ARB.multisample
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.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
+	designed to allow multisample and smooth antialiasing techniques
+	to be alternated during the rendering of a single scene.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/multisample.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.multisample import *
+from OpenGL.raw.WGL.ARB.multisample import _EXTENSION_NAME
+
+def glInitMultisampleARB():
+    '''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/WGL/ARB/pbuffer.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.pbuffer
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.pbuffer to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/pbuffer.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.pbuffer import *
+from OpenGL.raw.WGL.ARB.pbuffer import _EXTENSION_NAME
+
+def glInitPbufferARB():
+    '''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/WGL/ARB/pixel_format.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.pixel_format
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.pixel_format to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/pixel_format.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.pixel_format import *
+from OpenGL.raw.WGL.ARB.pixel_format import _EXTENSION_NAME
+
+def glInitPixelFormatARB():
+    '''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/WGL/ARB/pixel_format_float.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.pixel_format_float
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.pixel_format_float to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/pixel_format_float.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.pixel_format_float import *
+from OpenGL.raw.WGL.ARB.pixel_format_float import _EXTENSION_NAME
+
+def glInitPixelFormatFloatARB():
+    '''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/WGL/ARB/render_texture.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.render_texture
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.ARB.render_texture to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/render_texture.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.render_texture import *
+from OpenGL.raw.WGL.ARB.render_texture import _EXTENSION_NAME
+
+def glInitRenderTextureARB():
+    '''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/WGL/ARB/robustness_application_isolation.py

@@ -0,0 +1,23 @@
+'''OpenGL extension ARB.robustness_application_isolation
+
+This module customises the behaviour of the 
+OpenGL.raw.WGL.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.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.robustness_application_isolation import *
+from OpenGL.raw.WGL.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/WGL/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.WGL.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.WGL import _types, _glgets
+from OpenGL.raw.WGL.ARB.robustness_share_group_isolation import *
+from OpenGL.raw.WGL.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