Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/OpenGL/EGL/ANDROID/__init__.py

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

vllm/lib/python3.10/site-packages/OpenGL/EGL/ANDROID/framebuffer_target.py

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+'''OpenGL extension EXT.create_context_robustness
+
+This module customises the behaviour of the 
+OpenGL.raw.EGL.EXT.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/EXT/create_context_robustness.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.EGL import _types, _glgets
+from OpenGL.raw.EGL.EXT.create_context_robustness import *
+from OpenGL.raw.EGL.EXT.create_context_robustness import _EXTENSION_NAME
+
+def glInitCreateContextRobustnessEXT():
+    '''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/EGL/EXT/image_dma_buf_import.py

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+"""OpenGL.EGL the portable interface to GL environments"""
+from OpenGL.raw.EGL._types import *
+from OpenGL.EGL.VERSION.EGL_1_0 import *
+from OpenGL.EGL.VERSION.EGL_1_1 import *
+from OpenGL.EGL.VERSION.EGL_1_2 import *
+from OpenGL.EGL.VERSION.EGL_1_3 import *
+from OpenGL.EGL.VERSION.EGL_1_4 import *
+from OpenGL.EGL.VERSION.EGL_1_5 import *

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

@@ -0,0 +1,277 @@
+"""ctypes-based OpenGL wrapper for Python
+
+This is the PyOpenGL 3.x tree, it attempts to provide
+a largely compatible API for code written with the
+PyOpenGL 2.x series using the ctypes foreign function
+interface system.
+
+Configuration Variables:
+
+There are a few configuration variables in this top-level
+module.  Applications should be the only code that tweaks
+these variables, mid-level libraries should not take it
+upon themselves to disable/enable features at this level.
+The implication there is that your library code should be
+able to work with any of the valid configurations available
+with these sets of flags.
+
+Further, once any entry point has been loaded, the variables 
+can no longer be updated.  The OpenGL._confligflags module 
+imports the variables from this location, and once that 
+import occurs the flags should no longer be changed.
+
+    ERROR_CHECKING -- if set to a False value before
+        importing any OpenGL.* libraries will completely
+        disable error-checking.  This can dramatically
+        improve performance, but makes debugging far
+        harder.
+
+        This is intended to be turned off *only* in a
+        production environment where you *know* that
+        your code is entirely free of situations where you
+        use exception-handling to handle error conditions,
+        i.e. where you are explicitly checking for errors
+        everywhere they can occur in your code.
+
+        Default: True
+
+    ERROR_LOGGING -- If True, then wrap array-handler
+        functions with  error-logging operations so that all exceptions
+        will be reported to log objects in OpenGL.logs, note that
+        this means you will get lots of error logging whenever you
+        have code that tests by trying something and catching an
+        error, this is intended to be turned on only during
+        development so that you can see why something is failing.
+
+        Errors are normally logged to the OpenGL.errors logger.
+
+        Only triggers if ERROR_CHECKING is True
+
+        Default: False
+
+    ERROR_ON_COPY -- if set to a True value before
+        importing the numpy/lists support modules, will
+        cause array operations to raise
+        OpenGL.error.CopyError if the operation
+        would cause a data-copy in order to make the
+        passed data-type match the target data-type.
+
+        This effectively disables all list/tuple array
+        support, as they are inherently copy-based.
+
+        This feature allows for optimisation of your
+        application.  It should only be enabled during
+        testing stages to prevent raising errors on
+        recoverable conditions at run-time.
+
+        Default: False
+
+    CONTEXT_CHECKING -- if set to True, PyOpenGL will wrap
+        *every* GL and GLU call with a check to see if there
+        is a valid context.  If there is no valid context
+        then will throw OpenGL.errors.NoContext.  This is an
+        *extremely* slow check and is not enabled by default,
+        intended to be enabled in order to track down (wrong)
+        code that uses GL/GLU entry points before the context
+        has been initialized (something later Linux GLs are
+        very picky about).
+
+        Default: False
+
+    STORE_POINTERS -- if set to True, PyOpenGL array operations
+        will attempt to store references to pointers which are
+        being passed in order to prevent memory-access failures
+        if the pointed-to-object goes out of scope.  This
+        behaviour is primarily intended to allow temporary arrays
+        to be created without causing memory errors, thus it is
+        trading off performance for safety.
+
+        To use this flag effectively, you will want to first set
+        ERROR_ON_COPY to True and eliminate all cases where you
+        are copying arrays.  Copied arrays *will* segfault your
+        application deep within the GL if you disable this feature!
+
+        Once you have eliminated all copying of arrays in your
+        application, you will further need to be sure that all
+        arrays which are passed to the GL are stored for at least
+        the time period for which they are active in the GL.  That
+        is, you must be sure that your array objects live at least
+        until they are no longer bound in the GL.  This is something
+        you need to confirm by thinking about your application's
+        structure.
+
+        When you are sure your arrays won't cause seg-faults, you
+        can set STORE_POINTERS=False in your application and enjoy
+        a (slight) speed up.
+
+        Note: this flag is *only* observed when ERROR_ON_COPY == True,
+            as a safety measure to prevent pointless segfaults
+
+        Default: True
+
+    WARN_ON_FORMAT_UNAVAILABLE -- If True, generates
+        logging-module warn-level events when a FormatHandler
+        plugin is not loadable (with traceback).
+
+        Default: False
+
+    FULL_LOGGING -- If True, then wrap functions with
+        logging operations which reports each call along with its
+        arguments to  the OpenGL.calltrace logger at the INFO
+        level.  This is *extremely* slow.  You should *not* enable
+        this in production code!
+
+        You will need to have a  logging configuration (e.g.
+            logging.basicConfig()
+        ) call  in your top-level script to see the results of the
+        logging.
+
+        Default: False
+
+    ALLOW_NUMPY_SCALARS -- if True, we will wrap
+        all GLint/GLfloat calls conversions with wrappers
+        that allow for passing numpy scalar values.
+
+        Note that this is experimental, *not* reliable,
+        and very slow!
+
+        Note that byte/char types are not wrapped.
+
+        Default: False
+
+    UNSIGNED_BYTE_IMAGES_AS_STRING -- if True, we will return
+        GL_UNSIGNED_BYTE image-data as strings, instead of arrays
+        for glReadPixels and glGetTexImage
+
+        Default: True
+
+    FORWARD_COMPATIBLE_ONLY -- only include OpenGL 3.1 compatible
+        entry points.  Note that this will generally break most
+        PyOpenGL code that hasn't been explicitly made "legacy free"
+        via a significant rewrite.
+
+        Default: False
+
+    SIZE_1_ARRAY_UNPACK -- if True, unpack size-1 arrays to be
+        scalar values, as done in PyOpenGL 1.5 -> 3.0.0, that is,
+        if a glGenList( 1 ) is done, return a uint rather than
+        an array of uints.
+
+        Default: True
+
+    USE_ACCELERATE -- if True, attempt to use the OpenGL_accelerate
+        package to provide Cython-coded accelerators for core wrapping
+        operations.
+
+        Default: True
+    
+    MODULE_ANNOTATIONS -- if True, attempt to annotate alternates() and 
+        constants to track in which module they are defined (only useful 
+        for the documentation-generation passes, really).
+        
+        Default: False
+"""
+from OpenGL.version import __version__
+import os
+def environ_key( name, default ):
+    composed = 'PYOPENGL_%s'%name.upper()
+    if composed in os.environ:
+        value = os.environ[composed]
+        if value.lower() in ('1','true'):
+            return True 
+        else:
+            return False
+    return os.environ.get( composed, default )
+
+ERROR_CHECKING = environ_key( 'ERROR_CHECKING', True)
+ERROR_LOGGING = environ_key( 'ERROR_LOGGING', False )
+ERROR_ON_COPY = environ_key( 'ERROR_ON_COPY', False )
+ARRAY_SIZE_CHECKING = environ_key( 'ARRAY_SIZE_CHECKING', True )
+STORE_POINTERS = environ_key( 'STORE_POINTERS', True )
+WARN_ON_FORMAT_UNAVAILABLE = False
+FORWARD_COMPATIBLE_ONLY = False
+SIZE_1_ARRAY_UNPACK = True
+USE_ACCELERATE = environ_key( 'USE_ACCELERATE', True )
+CONTEXT_CHECKING = environ_key( 'CONTEXT_CHECKING', False )
+
+FULL_LOGGING = environ_key( 'FULL_LOGGING', False )
+ALLOW_NUMPY_SCALARS = environ_key( 'ALLOW_NUMPY_SCALARS', False )
+UNSIGNED_BYTE_IMAGES_AS_STRING = environ_key( 'UNSIGNED_BYTE_IMAGES_AS_STRING', True )
+MODULE_ANNOTATIONS = False
+
+# Declarations of plugins provided by PyOpenGL itself
+from OpenGL.plugins import PlatformPlugin, FormatHandler
+PlatformPlugin( 'nt', 'OpenGL.platform.win32.Win32Platform' )
+PlatformPlugin( 'linux2', 'OpenGL.platform.glx.GLXPlatform' )
+PlatformPlugin( 'darwin', 'OpenGL.platform.darwin.DarwinPlatform' )
+PlatformPlugin( 'posix', 'OpenGL.platform.glx.GLXPlatform' )
+PlatformPlugin( 'osmesa', 'OpenGL.platform.osmesa.OSMesaPlatform')
+PlatformPlugin( 'egl', 'OpenGL.platform.egl.EGLPlatform')
+
+import sys
+if sys.version_info[0] < 3:
+    # Python 3.x renames the built-in module
+    _bi = '__builtin__'
+else:
+    _bi = 'builtins'
+
+FormatHandler( 'none', 'OpenGL.arrays.nones.NoneHandler', [ _bi+'.NoneType'],isOutput=False )
+
+if sys.version_info[0] < 3:
+    FormatHandler( 'str', 'OpenGL.arrays.strings.StringHandler',[_bi+'.str'], isOutput=False )
+    FormatHandler( 'unicode', 'OpenGL.arrays.strings.UnicodeHandler',[_bi+'.unicode'], isOutput=False )
+else:
+    FormatHandler( 'bytes', 'OpenGL.arrays.strings.StringHandler',[_bi+'.bytes'], isOutput=False )
+    FormatHandler( 'str', 'OpenGL.arrays.strings.UnicodeHandler',[_bi+'.str'], isOutput=False )
+    
+FormatHandler( 'list', 'OpenGL.arrays.lists.ListHandler', [
+    _bi+'.list',
+    _bi+'.tuple',
+], isOutput=False )
+FormatHandler( 'numbers', 'OpenGL.arrays.numbers.NumberHandler', [
+    _bi+'.int',
+    _bi+'.float',
+    _bi+'.long',
+], isOutput=False )
+FormatHandler(
+    'ctypesarrays', 'OpenGL.arrays.ctypesarrays.CtypesArrayHandler',
+    [
+        '_ctypes.ArrayType',
+        '_ctypes.PyCArrayType',
+        '_ctypes.Array',
+        '_ctypes.array.Array',
+    ],
+    isOutput=True,
+)
+FormatHandler(
+    'ctypesparameter',
+    'OpenGL.arrays.ctypesparameters.CtypesParameterHandler',
+    [
+        _bi+'.CArgObject',
+        'ctypes.c_uint',
+        'ctypes.c_int',
+        'ctypes.c_float',
+        'ctypes.c_double',
+        'ctypes.c_ulong',
+        'ctypes.c_long',
+        'ctypes.c_longlong',
+    ],
+    isOutput=True,
+)
+FormatHandler( 'ctypespointer', 'OpenGL.arrays.ctypespointers.CtypesPointerHandler',[
+    'ctypes.c_void_p',
+    '_ctypes._Pointer',
+    'ctypes.c_char_p',
+    '_ctypes.pointer._Pointer',
+],isOutput=False )
+FormatHandler( 'numpy', 'OpenGL.arrays.numpymodule.NumpyHandler', [
+    'numpy.ndarray',
+    'numpy.core.memmap.memmap',
+],isOutput=True )
+FormatHandler( 'buffer', 'OpenGL.arrays.buffers.BufferHandler', [
+    'OpenGL.arrays._buffers.Py_buffer',
+    _bi+'.memoryview',
+    _bi+'.bytearray',
+],isOutput=True )
+FormatHandler( 'vbo', 'OpenGL.arrays.vbo.VBOHandler', ['OpenGL.arrays.vbo.VBO','OpenGL_accelerate.vbo.VBO'],isOutput=False )
+FormatHandler( 'vbooffset', 'OpenGL.arrays.vbo.VBOOffsetHandler', ['OpenGL.arrays.vbo.VBOOffset','OpenGL_accelerate.vbo.VBOOffset'],isOutput=False )

vllm/lib/python3.10/site-packages/OpenGL/_bytes.py

@@ -0,0 +1,63 @@
+"""8-bit string definitions for Python 2/3 compatibility
+
+Defines the following which allow for dealing with Python 3 breakages:
+
+    STR_IS_BYTES
+    STR_IS_UNICODE
+    
+        Easily checked booleans for type identities
+    
+    _NULL_8_BYTE
+    
+        An 8-bit byte with NULL (0) value 
+    
+    as_8_bit( x, encoding='utf-8')
+    
+        Returns the value as the 8-bit version
+    
+    unicode -- always pointing to the unicode type 
+    bytes -- always pointing to the 8-bit bytes type
+"""
+import sys
+
+STR_IS_BYTES = True
+
+if sys.version_info[:2] < (2,6):
+    # no bytes, traditional setup...
+    bytes = str 
+else:
+    bytes = bytes
+try:
+    long = long
+except NameError as err:
+    long = int
+if sys.version_info[:2] < (3,0):
+    # traditional setup, with bytes defined...
+    unicode = unicode
+    _NULL_8_BYTE = '\000'
+    def as_8_bit( x, encoding='utf-8' ):
+        if isinstance( x, unicode ):
+            return x.encode( encoding )
+        return bytes( x )
+    integer_types = int,long
+else:
+    # new setup, str is now unicode...
+    STR_IS_BYTES = False
+    _NULL_8_BYTE = bytes( '\000','latin1' )
+    def as_8_bit( x, encoding='utf-8' ):
+        if isinstance( x,unicode ):
+            return x.encode(encoding)
+        elif isinstance( x, bytes ):
+            # Note: this can create an 8-bit string that is *not* in encoding,
+            # but that is potentially exactly what we wanted, as these can 
+            # be arbitrary byte-streams being passed to C functions
+            return x
+        return str(x).encode( encoding )
+    unicode = str
+    integer_types = int,
+
+STR_IS_UNICODE = not STR_IS_BYTES
+if hasattr( sys, 'maxsize' ):
+    maxsize = sys.maxsize 
+else:
+    maxsize = sys.maxint

vllm/lib/python3.10/site-packages/OpenGL/_configflags.py

@@ -0,0 +1,18 @@
+"""Holds the import-time constants for various configuration flags"""
+from OpenGL import (
+    ERROR_CHECKING,
+    ERROR_LOGGING,
+    ERROR_ON_COPY,
+    ARRAY_SIZE_CHECKING,
+    STORE_POINTERS,
+    WARN_ON_FORMAT_UNAVAILABLE,
+    FORWARD_COMPATIBLE_ONLY,
+    SIZE_1_ARRAY_UNPACK,
+    USE_ACCELERATE,
+    CONTEXT_CHECKING,
+
+    FULL_LOGGING,
+    ALLOW_NUMPY_SCALARS,
+    UNSIGNED_BYTE_IMAGES_AS_STRING,
+    MODULE_ANNOTATIONS,
+)

vllm/lib/python3.10/site-packages/OpenGL/_null.py

@@ -0,0 +1,2 @@
+"""Just a NULL object for reference by other modules"""
+NULL = object()

vllm/lib/python3.10/site-packages/OpenGL/_opaque.py

@@ -0,0 +1,22 @@
+"""Data-type definitions for EGL/GLES"""
+import ctypes
+pointer = ctypes.pointer
+
+class _Opaque( ctypes.Structure ):
+    """An Opaque Structure reference (base class)"""
+class _opaque_pointer( ctypes.POINTER( _Opaque ) ):
+    _type_ = _Opaque
+    @classmethod
+    def from_param( cls, value ):
+        return ctypes.cast( value, cls )
+    @property
+    def address( self ):
+        return ctypes.addressof( self.contents )
+    @property 
+    def as_voidp( self ):
+        return ctypes.c_voidp( self.address )
+def opaque_pointer_cls( name ):
+    """Create an Opaque pointer class for the given name"""
+    typ = type( name, (_Opaque,), {} )
+    p_typ = type( name+'_pointer', (_opaque_pointer,), {'_type_':typ})
+    return p_typ

vllm/lib/python3.10/site-packages/OpenGL/acceleratesupport.py

@@ -0,0 +1,18 @@
+"""Common code for accelerated modules"""
+import logging
+from OpenGL import _configflags
+needed_version = (3,1,0)
+_log = logging.getLogger( 'OpenGL.acceleratesupport' )
+try:
+    import OpenGL_accelerate
+    if _configflags.USE_ACCELERATE:
+        if OpenGL_accelerate.__version_tuple__ <  needed_version:
+            _log.warn( """Incompatible version of OpenGL_accelerate found, need at least %s found %s""", needed_version, OpenGL_accelerate.__version_tuple__)
+            raise ImportError( """Old version of OpenGL_accelerate""" )
+        ACCELERATE_AVAILABLE = True
+        _log.info( """OpenGL_accelerate module loaded""" )
+    else:
+        raise ImportError( """Acceleration disabled""" )
+except ImportError as err:
+    _log.info( """No OpenGL_accelerate module loaded: %s""", err )
+    ACCELERATE_AVAILABLE = False

vllm/lib/python3.10/site-packages/OpenGL/constant.py

@@ -0,0 +1,78 @@
+"""Implementation of OpenGL constant objects"""
+import sys
+from OpenGL._bytes import bytes,unicode,as_8_bit, long, integer_types, maxsize
+from OpenGL import _configflags
+
+class Constant( object ):
+    """OpenGL constant that displays itself as a name rather than a value
+
+    The purpose of this class is to make debugging OpenGL code easier,
+    as you recieve messages that say what value you passed in in a
+    human-readable form, rather than as a bald number that requires
+    lookup and disambiguation in the header file.
+    """
+    def __new__( cls, name, value=None ):
+        """Initialise the constant with the given name and value"""
+        if not isinstance( value, Constant ):
+            if isinstance( value, float ) and cls is not FloatConstant:
+                return FloatConstant( name, value )
+            elif isinstance( value, int ) and cls is not IntConstant:
+                return IntConstant( name, value )
+            elif isinstance( value, long ) and cls is not LongConstant:
+                return LongConstant( name, value )
+            elif isinstance( value, (bytes,unicode) ) and cls is not StringConstant:
+                return StringConstant( name, as_8_bit(value) )
+        if isinstance( value, integer_types ):
+            if value > maxsize: # TODO: I'm guessing this should really by sizeof GLint, not 
+                value = - (value & maxsize)
+        base = super(Constant,cls).__new__( cls, value )
+        base.name = name
+        if _configflags.MODULE_ANNOTATIONS:
+            frame = sys._getframe().f_back
+            if frame and frame.f_back and '__name__' in frame.f_back.f_globals:
+                base.__module__ = frame.f_back.f_globals['__name__']
+        return base
+    def __repr__( self ):
+        """Return the name, rather than the bald value"""
+        return self.name
+    def __getnewargs__( self ):
+        """Produce the new arguments for recreating the instance"""
+        return (self.name,) + super( Constant, self ).__getnewargs__()
+
+class NumericConstant( Constant ):
+    """Base class for numeric-value constants"""
+    def __str__( self ):
+        """Return the value as a human-friendly string"""
+        return '%s (%s)'%(self.name,super(Constant,self).__str__())
+    def __getstate__(self):
+        """Retrieve state for pickle and the like"""
+        return self.name
+    def __setstate__( self, state ):
+        self.name = state
+
+class IntConstant( NumericConstant, int ):
+    """Integer constant"""
+if int is not long:
+    class LongConstant( NumericConstant, long ):
+        """Long integer constant"""
+else:
+    LongConstant = IntConstant
+class FloatConstant( NumericConstant, float ):
+    """Float constant"""
+
+class StringConstant( Constant, bytes ):
+    """String constants"""
+    def __repr__( self ):
+        """Return the value as a human-friendly string"""
+        return '%s (%s)'%(self.name,super(Constant,self).__str__())
+
+if __name__ == "__main__":
+    x = IntConstant( 'testint', 3 )
+    y = FloatConstant( 'testfloat', 3.0 )
+    z = StringConstant( 'teststr', 'some testing string' )
+
+    import pickle
+    for val in x,y,z:
+        restored = pickle.loads( pickle.dumps( val ))
+        assert restored == val, (str(restored),str(val))
+        assert restored.name == val.name, (restored.name,val.name)

vllm/lib/python3.10/site-packages/OpenGL/constants.py

@@ -0,0 +1,3 @@
+"""Backward-compatibility module to provide core-GL constant names"""
+from OpenGL.raw.GL._types import *
+from OpenGL.arrays._arrayconstants import *

vllm/lib/python3.10/site-packages/OpenGL/contextdata.py

@@ -0,0 +1,132 @@
+"""Storage of per-context values of various types
+
+Because OpenGL needs persistent references to the
+objects we're constructing to shadow Python objects,
+we have to store references to the objects somewhere
+
+For any given Python GUI library, we can use a weakref
+to the library's representation of the GL context to 
+call the cleanup function.  That means some per-GUI 
+library code in OpenGL (or the library), but it gives 
+us very natural operations within OpenGL.
+
+Note: you can entirely disable use of this module by 
+setting:
+
+    OpenGL.ERROR_ON_COPY = True 
+    OpenGL.STORE_POINTERS = False 
+        
+before importing OpenGL functionality.
+"""
+from OpenGL import platform
+import weakref
+storedPointers = {
+    # map from contextID: { constant: value }
+}
+storedWeakPointers = {
+    # map from contextID: WeakValueDictionary({ constant: value })
+}
+STORAGES = [ storedPointers, storedWeakPointers ]
+
+def getContext( context = None ):
+    """Get the context (if passed, just return)
+    
+    context -- the context ID, if None, the current context
+    """
+    if context is None:
+        context = platform.GetCurrentContext()
+        if context == 0:
+            from OpenGL import error
+            raise error.Error(
+                """Attempt to retrieve context when no valid context"""
+            )
+    return context
+def setValue( constant, value, context=None, weak=False ):
+    """Set a stored value for the given context
+    
+    constant -- Normally a GL constant value, but can be any hashable value 
+    value -- the value to be stored.  If weak is true must be 
+        weak-reference-able.  If None, then the value will be deleted from 
+        the storage 
+    context -- the context identifier for which we're storing the value
+    weak -- if true, value will be stored with a weakref
+        Note: you should always pass the same value for "weak" for a given 
+        constant, otherwise you will create two storages for the constant.
+    """
+    if getattr( value, '_no_cache_', False ):
+        return 
+    context = getContext( context )
+    if weak:
+        storage = storedWeakPointers
+        cls = weakref.WeakValueDictionary
+    else:
+        storage = storedPointers
+        cls = dict
+    current = storage.get( context )
+    if current is None:
+        storage[context] = current = cls()
+    previous = current.get( constant )
+    if value is None:
+        try:
+            del current[ constant ]
+        except (KeyError,TypeError,ValueError) as err:
+            pass 
+    else:
+        # XXX potential for failure here if a non-weakref-able objects
+        # is being stored with weak == True
+        current[ constant ] = value 
+##	print 'previous', previous, value, constant
+    return previous
+def delValue( constant, context=None ):
+    """Delete the specified value for the given context
+    
+    constant -- Normally a GL constant value, but can be any hashable value 
+    context -- the context identifier for which we're storing the value
+    """
+    context = getContext( context )
+    found = False
+    for storage in STORAGES:
+        contextStorage = storage.get( context  )
+        if contextStorage:
+            try:
+                del contextStorage[ constant ]
+                found = True
+            except KeyError as err:
+                pass
+    return found
+
+def getValue( constant, context = None ):
+    """Get a stored value for the given constant
+    
+    constant -- unique ID for the type of data being retrieved
+    context -- the context ID, if None, the current context
+    """
+    context = getContext( context )
+    for storage in STORAGES:
+        contextStorage = storage.get( context  )
+        if contextStorage:
+            value =  contextStorage.get( constant )
+            if value is not None:
+                return value
+    return None
+
+def cleanupContext( context=None ):
+    """Cleanup all held pointer objects for the given context
+    
+    Warning: this is dangerous, as if you call it before a context 
+    is destroyed you may release memory held by the context and cause
+    a protection fault when the GL goes to render the scene!
+    
+    Normally you will want to get the context ID explicitly and then 
+    register cleanupContext as a weakref callback to your GUI library 
+    Context object with the (now invalid) context ID as parameter.
+    """
+    if context is None:
+        context = platform.GetCurrentContext()
+    for storage in STORAGES:
+        try:
+            del storedPointers[ context ]
+        except KeyError as err:
+            return False
+        else:
+            return True

vllm/lib/python3.10/site-packages/OpenGL/converters.py

@@ -0,0 +1,316 @@
+"""Implementations for common converter types"""
+import ctypes,logging
+from OpenGL._bytes import bytes, unicode, as_8_bit
+from OpenGL._null import NULL
+_log = logging.getLogger( 'OpenGL.converters' )
+
+class Converter( object ):
+    """Base class for Converter types
+
+    Converter objects are callable objects used with the
+    OpenGL.wrapper.Wrapper class to simplify the wrapping
+    of functions by collecting commonly used functionality
+    into a reusable function.
+
+    Each Converter has two (class) attributes:
+
+        argNames -- list of argument names for initialisation
+        indexLookups -- set of (indexname, argName,methodName) values
+            to lookup on wrapper.  These allow us to use argument-name
+            references to refer to which arguments to use when
+            processing (prevents the need to revise pointers when
+            we change the API for a function).
+
+    Converters can be any of the Wrapper API helper functions,
+    so the callable interface can vary among Converter classes.
+    """
+    argNames = ( )
+    indexLookups = ( )
+    def __init__( self, *args, **named ):
+        """Store arguments in attributes
+
+        *args -- mapped to self.argNames in order to set attributes
+        **named -- mapped to self.argNames by name to set attributes
+        """
+        argNames = list(self.argNames)
+        for a in self.argNames:
+            if a in named:
+                setattr( self, a, named[a] )
+                argNames.remove( a )
+        for a,value in zip( argNames, args ):
+            setattr( self, a, value )
+    def finalise( self, wrapper ):
+        """Look up our indices (where appropriate)"""
+        for indexname,argName,methodName in self.indexLookups:
+            setattr(
+                self, indexname,
+                getattr(wrapper,methodName)(getattr( self, argName ))
+            )
+
+# Definitions of the abstract interfaces...
+class PyConverter( Converter ):
+    """Converter sub-class for use in Wrapper.pyConverters
+
+    This class just defines the interface for a pyConverter-style
+    Converter object
+    """
+    def __call__( self, incoming, function, arguments ):
+        """Convert incoming argument into compatable data-types
+
+        incoming -- the Python argument for this parameter
+        function -- the wrapper.Wrapper class we are supporting
+        arguments -- the complete set of arguments passed to the
+            function
+
+
+        """
+        raise NotImplemented( """%s class doesn't implement __call__"""%(
+            self.__class__.__name__,
+        ))
+
+class CConverter( Converter ):
+    """Converter sub-class for use in Wrapper.cConverters
+
+    This class just defines the interface for a cConverter-style
+    Converter object
+    """
+    def __call__( self, pyArgs, index, baseOperation ):
+        """Calculate C-compatible Python object from Python arguments
+
+        pyArgs -- set of Python argument objects converted by
+            pyConverters from the incoming arguments
+        index -- our index in baseOperation.cConverters
+        baseOperation -- the Wrapper object which we are supporting
+        """
+        raise NotImplemented( """%s class doesn't implement __call__"""%(
+            self.__class__.__name__,
+        ))
+class ReturnValues( Converter ):
+    """Converter sub-class for use as Wrapper.returnValues
+
+    This class just defines the interface for a returnValues-style
+    Converter object
+    """
+    def __call__( self, result, baseOperation, pyArgs, cArgs ):
+        """Return a final value to the caller
+
+        result -- the raw ctypes result value
+        baseOperation -- the Wrapper object which we are supporting
+        pyArgs -- the set of Python arguments produced by pyConverters
+        cArgs -- the set of C-compatible arguments produced by CConverter
+
+        return the Python object for the final result
+        """
+        raise NotImplemented( """%s class doesn't implement __call__"""%(
+            self.__class__.__name__,
+        ))
+
+# Now the concrete classes...
+from OpenGL import acceleratesupport
+CallFuncPyConverter = None
+if acceleratesupport.ACCELERATE_AVAILABLE:
+    try:
+        from OpenGL_accelerate.wrapper import (
+            CallFuncPyConverter, DefaultCConverter, getPyArgsName,
+        )
+        from OpenGL_accelerate.arraydatatype import (
+            Output,SizedOutput,OutputOrInput,SizedOutputOrInput
+        )
+        from OpenGL_accelerate.wrapper import (
+            returnCArgument, returnPyArgument,
+        )
+    except ImportError as err:
+        _log.warn(
+            "Unable to load converters accelerators (wrapper, arraydatatype) from OpenGL_accelerate"
+        )
+        CallFuncPyConverter = None
+if CallFuncPyConverter is None:
+    class CallFuncPyConverter( PyConverter ):
+        """PyConverter that takes a callable and calls it on incoming"""
+        def __init__( self, function ):
+            """Store the function"""
+            self.function = function
+        def __call__( self, incoming, function, argument ):
+            """Call our function on incoming"""
+            return self.function( incoming )
+    class DefaultCConverter( CConverter ):
+        """NULL or Default CConverter, returns same-named Python argument
+
+        Used primarily to allow for specifying a converter that explicitly
+        says "use the default behaviour".  This is *not* a finalise-ing
+        converter, it is passed in the index explicitly and just retrieves
+        that index from pyArgs when called.
+
+        Raises informative errors if the index cannot be resolved in pyArgs
+        """
+        def __init__( self, index ):
+            """Just store index for future access"""
+            self.index = index
+        def __call__( self, pyArgs, index, wrapper ):
+            """Return pyArgs[self.index] or raise a ValueError"""
+            try:
+                return pyArgs[ self.index ]
+            except IndexError as err:
+                raise ValueError(
+                    """Expected parameter index %r, but pyArgs only length %s"""%(
+                    self.index,
+                    len(pyArgs )
+                ))
+    class getPyArgsName( CConverter ):
+        """CConverter returning named Python argument
+
+        Intended for use in cConverters, the function returned
+        retrieves the named pyArg and returns it when called.
+        """
+        argNames = ('name',)
+        indexLookups = [ ('index','name', 'pyArgIndex' ), ]
+        __slots__ = ( 'index', 'name')
+        def __call__( self, pyArgs, index, baseOperation ):
+            """Return pyArgs[ self.index ]"""
+            try:
+                return pyArgs[ self.index ]
+            except AttributeError as err:
+                raise RuntimeError( """"Did not resolve parameter index for %r"""%(self.name))
+
+    class Output( CConverter ):
+        """CConverter generating static-size typed output arrays
+
+        Produces an output array of given type (arrayType) and
+        size using self.lookup() to determine the size of the
+        array to be produced, where the lookup function is passed
+        as an initialisation argument.
+
+        Provides also:
+
+            oldStyleReturn( ... ) for use in the default case of
+                PyOpenGL compatability mode, where result arrays of
+                size (1,) are returned as scalar values.
+        """
+        argNames = ('name','size','arrayType' )
+        indexLookups = [
+            ('outIndex','name', 'cArgIndex' ),
+        ]
+        __slots__ = ('index','size','arrayType','outIndex','inIndex')
+        def __call__( self, pyArgs, index, baseOperation ):
+            """Return pyArgs[ self.index ]"""
+            return self.arrayType.zeros( self.getSize(pyArgs) )
+        def getSize( self, pyArgs ):
+            """Retrieve the array size for this argument"""
+            return self.size
+        def oldStyleReturn( self, result, baseOperation, pyArgs, cArgs ):
+            """Retrieve cArgs[ self.index ]"""
+            result = cArgs[ self.outIndex ]
+            try:
+                thisSize = self.getSize(pyArgs)
+            except KeyError as err:
+                return result 
+            if thisSize == (1,):
+                try:
+                    return result[0]
+                except TypeError as err:
+                    return result
+            else:
+                return result
+    class OutputOrInput( Output ):
+        DO_OUTPUT = (None,NULL)
+        def __call__( self, pyArgs, index, baseOperation ):
+            for do_output in self.DO_OUTPUT:
+                if pyArgs[index] is do_output:
+                    return super( OutputOrInput,self ).__call__( pyArgs, index, baseOperation )
+            return self.arrayType.asArray( pyArgs[index] )
+
+    class SizedOutput( Output ):
+        """Output generating dynamically-sized typed output arrays
+
+        Takes an extra parameter "specifier", which is the name of
+        a Python argument to be passed to the lookup function in order
+        to determine the appropriate size for the output array.
+        """
+        argNames = ('name','specifier','lookup','arrayType' )
+        indexLookups = [
+            ('outIndex','name', 'cArgIndex' ),
+            ('index','specifier', 'pyArgIndex' ),
+        ]
+        __slots__ = ('index','specifier','lookup','arrayType')
+        def getSize( self, pyArgs ):
+            """Retrieve the array size for this argument"""
+            try:
+                specifier = pyArgs[ self.index ]
+            except AttributeError as err:
+                raise RuntimeError( """"Did not resolve parameter index for %r"""%(self.name))
+            else:
+                try:
+                    return self.lookup( specifier )
+                except KeyError as err:
+                    raise KeyError( """Unknown specifier %s"""%( specifier ))
+    class SizedOutputOrInput( SizedOutput ):
+        DO_OUTPUT = (None,NULL)
+        def __call__( self, pyArgs, index, baseOperation ):
+            for do_output in self.DO_OUTPUT:
+                if pyArgs[index] is do_output:
+                    return super( SizedOutputOrInput,self ).__call__( pyArgs, index, baseOperation )
+            return self.arrayType.asArray( pyArgs[index] )
+    class returnCArgument( ReturnValues ):
+        """ReturnValues returning the named cArgs value"""
+        argNames = ('name',)
+        indexLookups = [ ('index','name', 'cArgIndex' ), ]
+        __slots__ = ( 'index', 'name' )
+        def __call__( self, result, baseOperation, pyArgs, cArgs ):
+            """Retrieve cArgs[ self.index ]"""
+            return cArgs[self.index]
+
+    class returnPyArgument( ReturnValues ):
+        """ReturnValues returning the named pyArgs value"""
+        argNames = ('name',)
+        indexLookups = [ ('index','name', 'pyArgIndex' ), ]
+        __slots__ = ( 'index', 'name' )
+        def __call__( self, result, baseOperation, pyArgs, cArgs ):
+            """Retrieve pyArgs[ self.index ]"""
+            return pyArgs[self.index]
+
+class StringLengths( CConverter ):
+    """CConverter for processing array-of-pointers-to-strings data-type
+
+    Converter is a CConverter for the array-of-lengths for a
+    array-of-pointers-to-strings data-type used to pass a set
+    of code fragments to the GLSL compiler.
+
+    Provides also:
+
+        stringArray -- PyConverter callable ensuring list-of-strings
+            format for the python argument
+
+        stringArrayForC -- CResolver converting the array to
+            POINTER(c_char_p) format for passing to C
+
+        totalCount -- CConverter callable giving count of string
+            pointers (that is, length of the pointer array)
+    """
+    argNames = ('name',)
+    indexLookups = [ ('index','name', 'pyArgIndex' ), ]
+    __slots__ = ()
+    def __call__( self, pyArgs, index, baseOperation ):
+        """Get array of length integers for string contents"""
+        from OpenGL.raw.GL import _types
+        tmp = [len(x) for x in pyArgs[self.index]]
+        a_type = _types.GLint * len(tmp)
+        return a_type( *tmp )
+    def totalCount( self, pyArgs, index, baseOperation ):
+        """Get array of length integers for string contents"""
+        return len(pyArgs[self.index])
+    def stringArray( self, arg, baseOperation, args ):
+        """Create basic array-of-strings object from pyArg"""
+        if isinstance( arg, (bytes,unicode) ):
+            arg = [arg]
+        value = [as_8_bit(x) for x in arg]
+        return value
+    def stringArrayForC( self, strings ):
+        """Create a ctypes pointer to char-pointer set"""
+        from OpenGL import arrays
+        result = (ctypes.c_char_p * len(strings))()
+        for i,s in enumerate(strings):
+            result[i] = ctypes.cast(
+                arrays.GLcharARBArray.dataPointer(s),
+                ctypes.c_char_p,
+            )
+        return result

vllm/lib/python3.10/site-packages/OpenGL/error.py

@@ -0,0 +1,246 @@
+"""Implementation of OpenGL errors/exceptions
+
+Note that OpenGL-ctypes will also throw standard errors,
+such as TypeError or ValueError when appropriate.
+
+ErrorChecker is an _ErrorChecker instance that allows you
+to register a new error-checking function for use 
+throughout the system.
+"""
+import logging
+_log = logging.getLogger( 'OpenGL.error' )
+from OpenGL import platform, _configflags
+from ctypes import ArgumentError
+__all__ = (
+    "Error",'GLError','GLUError','GLUTError',
+    'GLerror','GLUerror','GLUTerror','ArgumentError',
+)
+
+class Error( Exception ):
+    """Base class for all PyOpenGL-specific exception classes"""
+class NoContext( Error ):
+    """Raised to indicate that there is no currently active context
+    
+    Technically almost *any* OpenGL call can segfault if there is 
+    no active context.  The OpenGL.CHECK_CONTEXT flag, if enabled 
+    will cause this error to be raised whenever a GL or GLU call is 
+    issued (via PyOpenGL) if there is no currently valid context.
+    """
+class CopyError( Error ):
+    """Raised to indicate that operation requires data-copying
+    
+    if you set:
+        OpenGL.ERROR_ON_COPY = True 
+    
+    before importing OpenGL.GL, this error will be raised when 
+    a passed argument would require a copy to be made.
+    """
+
+class NullFunctionError( Error ):
+    """Error raised when an undefined function is called"""
+
+class GLError( Error ):
+    """OpenGL core error implementation class
+    
+    Primary purpose of this error class is to allow for 
+    annotating an error with more details about the calling 
+    environment so that it's easier to debug errors in the
+    wrapping process.
+    
+    Attributes:
+    
+        err -- the OpenGL error code for the error 
+        result -- the OpenGL result code for the operation
+        baseOperation -- the "function" being called
+        pyArgs -- the translated set of Python arguments
+        cArgs -- the Python objects matching 1:1 the C arguments
+        cArguments -- ctypes-level arguments to the operation,
+            often raw integers for pointers and the like
+        description -- OpenGL description of the error (textual)
+    """
+    def __init__( 
+        self, 
+        err=None, 
+        result=None, 
+        cArguments=None, 
+        baseOperation=None, 
+        pyArgs=None, 
+        cArgs=None,
+        description=None,
+    ):
+        """Initialise the GLError, storing metadata for later display"""
+        (
+            self.err, self.result, self.cArguments, 
+            self.baseOperation, self.pyArgs, self.cArgs,
+            self.description
+        ) = (
+            err, result, cArguments,
+            baseOperation, pyArgs, cArgs,
+            description
+        )
+    DISPLAY_ORDER = (
+        'err', 
+        'description',
+        'baseOperation',
+        'pyArgs', 
+        'cArgs',
+        'cArguments',
+        'result', 
+    )
+    def __str__( self ):
+        """Create a fully formatted representation of the error"""
+        args = []
+        for property in self.DISPLAY_ORDER:
+            value = getattr( self, property, None )
+            if value is not None or property=='description':
+                formatFunction = 'format_%s'%(property)
+                if hasattr( self, formatFunction ):
+                    args.append( getattr(self,formatFunction)( property, value ))
+                else:
+                    args.append( '%s = %s'%(
+                        property,
+                        self.shortRepr( value ),
+                    ))
+        return '%s(\n\t%s\n)'%(self.__class__.__name__, ',\n\t'.join(
+            [x for x in args if x]
+        ))
+    def __repr__( self ):
+        """Produce a much shorter version of the error as a string"""
+        return '%s( %s )'%(
+            self.__class__.__name__,
+            ", ".join([x for x in [
+                'err=%s'%(self.err),
+                self.format_description( 'description', self.description ) or '',
+                self.format_baseOperation( 'baseOperation', self.baseOperation ) or '',
+            ] if x])
+        )
+    def format_description( self, property, value ):
+        """Format description using GLU's gluErrorString"""
+        if value is None and self.err is not None:
+            try:
+                from OpenGL.GLU import gluErrorString
+                self.description = value = gluErrorString( self.err )
+            except Exception as err:
+                return None
+        if value is None:
+            return None
+        return '%s = %s'%(
+            property,
+            self.shortRepr( value ),
+        )
+    def shortRepr( self, value, firstLevel=True ):
+        """Retrieve short representation of the given value"""
+        if isinstance( value, (list,tuple) ) and value and len(repr(value))>=40:
+            if isinstance( value, list ):
+                template = '[\n\t\t%s\n\t]'
+            else:
+                template = '(\n\t\t%s,\n\t)'
+            return template%( ",\n\t\t".join(
+                [
+                    self.shortRepr(x,False) for x in value
+                ]
+            ))
+        r = repr( value )
+        if len(r) < 120:
+            return r
+        else:
+            return r[:117] + '...'
+    def format_baseOperation( self, property, value ):
+        """Format a baseOperation reference for display"""
+        if hasattr( value, '__name__' ):
+            return '%s = %s'%( property, value.__name__ )
+        else:
+            return '%s = %r'%( property, value )
+
+class GLUError( Error ):
+    """GLU error implementation class"""
+
+class GLUTError( Error ):
+    """GLUT error implementation class"""
+
+
+if _configflags.ERROR_CHECKING:
+    from OpenGL import acceleratesupport
+    _ErrorChecker = None
+    if acceleratesupport.ACCELERATE_AVAILABLE:
+        try:
+            from OpenGL_accelerate.errorchecker import _ErrorChecker
+        except ImportError as err:
+            _log.warn( """OpenGL_accelerate seems to be installed, but unable to import error checking entry point!""" )
+    if _ErrorChecker is None:
+        class _ErrorChecker( object ):
+            """Per-API error-checking object
+            
+            Attributes:
+                _registeredChecker -- the checking function enabled when 
+                    not doing onBegin/onEnd processing
+                _currentChecker -- currently active checking function
+            """
+            _getErrors = None
+            def __init__( self, platform, baseOperation=None, noErrorResult=0 ):
+                """Initialize from a platform module/reference"""
+                self._isValid = platform.CurrentContextIsValid
+                self._getErrors = baseOperation
+                self._noErrorResult = noErrorResult
+                if self._getErrors:
+                    if _configflags.CONTEXT_CHECKING:
+                        self._registeredChecker = self.safeGetError 
+                    else:
+                        self._registeredChecker = self._getErrors
+                else:
+                    self._registeredChecker = self.nullGetError
+                self._currentChecker = self._registeredChecker
+            def __bool__( self ):
+                """We are "true" if we actually do anything"""
+                if self._registeredChecker is self.nullGetError:
+                    return False 
+                return True
+            def safeGetError( self ):
+                """Check for error, testing for context before operation"""
+                if self._isValid():
+                    return self._getErrors()
+                return None 
+            def nullGetError( self ):
+                """Used as error-checker when no error checking should be done"""
+                return self._noErrorResult
+            def glCheckError( 
+                self,
+                result,
+                baseOperation=None,
+                cArguments=None,
+                *args
+            ):
+                """Base GL Error checker compatible with new ctypes errcheck protocol
+                
+                This function will raise a GLError with just the calling information
+                available at the C-calling level, i.e. the error code, cArguments,
+                baseOperation and result.  Higher-level code is responsible for any 
+                extra annotations.
+                
+                Note:
+                    glCheckError relies on glBegin/glEnd interactions to 
+                    prevent glGetError being called during a glBegin/glEnd 
+                    sequence.  If you are calling glBegin/glEnd in C you 
+                    should call onBegin and onEnd appropriately.
+                """
+                err = self._currentChecker()
+                if err != self._noErrorResult:
+                    raise GLError(
+                        err,
+                        result,
+                        cArguments = cArguments,
+                        baseOperation = baseOperation,
+                    )
+                return result
+            def onBegin( self ):
+                """Called by glBegin to record the fact that glGetError won't work"""
+                self._currentChecker = self.nullGetError
+            def onEnd( self ):
+                """Called by glEnd to record the fact that glGetError will work"""
+                self._currentChecker = self._registeredChecker
+else:
+    _ErrorChecker = None
+# Compatibility with PyOpenGL 2.x series
+GLUerror = GLUError
+GLerror = GLError 
+GLUTerror = GLUTError

vllm/lib/python3.10/site-packages/OpenGL/extensions.py

@@ -0,0 +1,256 @@
+"""Extension module support methods
+
+This module provides the tools required to check whether
+an extension is available
+"""
+from OpenGL.latebind import LateBind
+from OpenGL._bytes import bytes,unicode,as_8_bit
+import OpenGL as root
+import sys
+import logging
+_log = logging.getLogger( 'OpenGL.extensions' )
+VERSION_PREFIX = as_8_bit('GL_VERSION_GL_')
+CURRENT_GL_VERSION = None
+AVAILABLE_GL_EXTENSIONS = []
+AVAILABLE_GLU_EXTENSIONS = []
+
+# version tuple -> list of implicitly included extensions...
+VERSION_EXTENSIONS = [
+    ((3,0), [
+        as_8_bit('GL_ARB_vertex_array_object'),
+        as_8_bit('GL_ARB_texture_buffer_object'),
+        as_8_bit('GL_ARB_framebuffer_object'),
+        as_8_bit('GL_ARB_map_buffer_range'),
+    ]),
+    ((3,1), [
+        as_8_bit('GL_ARB_copy_buffer'),
+        as_8_bit('GL_ARB_uniform_buffer_object'),
+    ]),
+    ((3,2), [
+        as_8_bit('GL_ARB_draw_elements_base_vertex'),
+        as_8_bit('GL_ARB_provoking_vertex'),
+        as_8_bit('GL_ARB_sync'),
+        as_8_bit('GL_ARB_texture_multisample'),
+    ]),
+    ((3,3), [
+        as_8_bit('GL_ARB_texture_multisample'),
+        as_8_bit('GL_ARB_blend_func_extended'),
+        as_8_bit('GL_ARB_sampler_objects'),
+        as_8_bit('GL_ARB_explicit_attrib_location'),
+        as_8_bit('GL_ARB_occlusion_query2'),
+        as_8_bit('GL_ARB_shader_bit_encoding'),
+        as_8_bit('GL_ARB_texture_rgb10_a2ui'),
+        as_8_bit('GL_ARB_texture_swizzle'),
+        as_8_bit('GL_ARB_timer_query'),
+        as_8_bit('GL_ARB_vertex_type_2_10_10_10_rev'),
+    ]),
+    ((4,0), [
+        as_8_bit('GL_ARB_texture_query_lod'),
+        as_8_bit('GL_ARB_draw_indirect'),
+        as_8_bit('GL_ARB_gpu_shader5'),
+        as_8_bit('GL_ARB_gpu_shader_fp64'),
+        as_8_bit('GL_ARB_shader_subroutine'),
+        as_8_bit('GL_ARB_tessellation_shader'),
+        as_8_bit('GL_ARB_texture_buffer_object_rgb32'),
+        as_8_bit('GL_ARB_texture_cube_map_array'),
+        as_8_bit('GL_ARB_texture_gather'),
+        as_8_bit('GL_ARB_transform_feedback2'),
+        as_8_bit('GL_ARB_transform_feedback3'),
+    ]),
+    ((4,1), [
+        as_8_bit('GL_ARB_ES2_compatibility'),
+        as_8_bit('GL_ARB_get_program_binary'),
+        as_8_bit('GL_ARB_separate_shader_objects'),
+        as_8_bit('GL_ARB_shader_precision'),
+        as_8_bit('GL_ARB_vertex_attrib_64bit'),
+        as_8_bit('GL_ARB_viewport_array'),
+    ]),
+    ((4,2), [
+        as_8_bit('GL_ARB_base_instance'),
+        as_8_bit('GL_ARB_shading_language_420pack'),
+        as_8_bit('GL_ARB_transform_feedback_instanced'),
+        as_8_bit('GL_ARB_compressed_texture_pixel_storage'),
+        as_8_bit('GL_ARB_conservative_depth'),
+        as_8_bit('GL_ARB_internalformat_query'),
+        as_8_bit('GL_ARB_map_buffer_alignment'),
+        as_8_bit('GL_ARB_shader_atomic_counters'),
+        as_8_bit('GL_ARB_shader_image_load_store'),
+        as_8_bit('GL_ARB_shading_language_packing'),
+        as_8_bit('GL_ARB_texture_storage'),
+    ]),
+]
+
+class ExtensionQuerier( object ):
+    prefix = None
+    version_prefix = None
+    assumed_version = [1,0]
+    
+    version = extensions = None
+    version_string = extensions_string = None
+    
+    registered = []
+    def __init__( self ):
+        self.registered.append( self )
+    
+    @classmethod 
+    def hasExtension( self, specifier ):
+        for registered in self.registered:
+            result = registered( specifier )
+            if result:
+                return result 
+        return False
+    
+    def __call__( self, specifier ):
+        specifier = as_8_bit(specifier).replace(as_8_bit('.'),as_8_bit('_'))
+        if not specifier.startswith( self.prefix ):
+            return None 
+        
+        if specifier.startswith( self.version_prefix ):
+            specifier = [
+                int(x)
+                for x in specifier[ len(self.version_prefix):].split(as_8_bit('_'))
+            ]
+            if specifier[:2] <= self.assumed_version:
+                return True
+            version = self.getVersion()
+            if not version:
+                return version
+            return specifier <= version
+        else:
+            extensions = self.getExtensions()
+            return extensions and specifier in extensions
+    def getVersion( self ):
+        if not self.version:
+            self.version = self.pullVersion()
+        return self.version 
+    def getExtensions( self ):
+        if not self.extensions:
+            self.extensions = self.pullExtensions()
+        return self.extensions
+
+class _GLQuerier( ExtensionQuerier ):
+    prefix = as_8_bit('GL_')
+    version_prefix = as_8_bit('GL_VERSION_GL_')
+    assumed_version = [1,1]
+    def pullVersion( self ):
+        """Retrieve 2-int declaration of major/minor GL version
+
+        returns [int(major),int(minor)] or False if not loaded
+        """
+        from OpenGL import platform
+        if not platform.PLATFORM.CurrentContextIsValid():
+            return False
+        from OpenGL.raw.GL.VERSION.GL_1_1 import glGetString 
+        from OpenGL.raw.GL.VERSION.GL_1_1 import GL_VERSION
+        new = glGetString( GL_VERSION )
+        
+        self.version_string = new
+        if new:
+            return [
+                int(x) for x in new.split(as_8_bit(' '),1)[0].split( as_8_bit('.') )
+            ]
+        else:
+            return False # not yet loaded/supported
+    def pullExtensions( self ):
+        from OpenGL import platform
+        if not platform.PLATFORM.CurrentContextIsValid():
+            return False
+        from OpenGL.raw.GL._types import GLint
+        from OpenGL.raw.GL.VERSION.GL_1_1 import glGetString, glGetError
+        from OpenGL.raw.GL.VERSION.GL_1_1 import GL_EXTENSIONS
+        from OpenGL import error
+        try:
+            extensions = glGetString( GL_EXTENSIONS )
+            if glGetError():
+                raise error.GLError()
+            if extensions:
+                extensions = extensions.split()
+            else:
+                return False
+        except (AttributeError, error.GLError) as err:
+            # OpenGL 3.0 deprecates glGetString( GL_EXTENSIONS )
+            from OpenGL.raw.GL.VERSION.GL_3_0 import GL_NUM_EXTENSIONS, glGetStringi
+            from OpenGL.raw.GL.VERSION.GL_1_1 import glGetIntegerv
+            count = GLint()
+            glGetIntegerv( GL_NUM_EXTENSIONS, count )
+            extensions = []
+            for i in range( count.value ):
+                extension = glGetStringi( GL_EXTENSIONS, i )
+                extensions.append(
+                    extension
+                )
+        # Add included-by-reference extensions...
+        version = self.getVersion()
+        if not version:
+            # should not be possible?
+            return version 
+        check = tuple( version[:2] )
+        for (v,v_exts) in VERSION_EXTENSIONS:
+            if v <= check:
+                for v_ext in v_exts:
+                    if v_ext not in extensions:
+                        extensions.append( as_8_bit(v_ext) )
+            else:
+                break
+        return extensions
+GLQuerier = _GLQuerier()
+class _GLUQuerier( ExtensionQuerier ):
+    prefix = as_8_bit('GLU_')
+    version_prefix = as_8_bit('GLU_VERSION_GL_')
+    def pullVersion( self ):
+        from OpenGL.GLU import gluGetString,GLU_VERSION
+        return [
+            int(x) for x in gluGetString( GLU_VERSION ).split('_')
+            if x.isdigit()
+        ]
+    def pullExtensions( self ):
+        from OpenGL.GLU import gluGetString,GLU_EXTENSIONS
+        return gluGetString( GLU_EXTENSIONS ).split()
+GLUQuerier = _GLUQuerier()
+
+def hasExtension( specifier ):
+    return ExtensionQuerier.hasExtension( specifier )
+hasGLExtension = hasGLUExtension = hasExtension
+
+class _Alternate( LateBind ):
+    def __init__( self, name, *alternates ):
+        """Initialize set of alternative implementations of the same function"""
+        self.__name__ = name
+        self._alternatives = alternates
+        if root.MODULE_ANNOTATIONS:
+            frame = sys._getframe().f_back
+            if frame and frame.f_back and '__name__' in frame.f_back.f_globals:
+                self.__module__ = frame.f_back.f_globals['__name__']
+    def __bool__( self ):
+        from OpenGL import error
+        try:
+            return bool( self.getFinalCall())
+        except error.NullFunctionError as err:
+            return False
+    __nonzero__ = __bool__ # Python 2.6 compatibility
+    def finalise( self ):
+        """Call, doing a late lookup and bind to find an implementation"""
+        for alternate in self._alternatives:
+            if alternate:
+#                _log.info(
+#                    """Chose alternate: %s from %s""",
+#                    alternate.__name__,
+#                    ", ".join([x.__name__ for x in self._alternatives])
+#                )
+                return alternate
+        from OpenGL import error
+        raise error.NullFunctionError(
+            """Attempt to call an undefined alternate function (%s), check for bool(%s) before calling"""%(
+                ', '.join([x.__name__ for x in self._alternatives]),
+                self.__name__,
+            )
+        )
+def alternate( name, *functions ):
+    """Construct a callable that functions as the first implementation found of given set of alternatives
+
+    if name is a function then its name will be used....
+    """
+    if not isinstance( name, (bytes,unicode)):
+        functions = (name,)+functions
+        name = name.__name__
+    return type( name, (_Alternate,), {} )( name, *functions )

vllm/lib/python3.10/site-packages/OpenGL/images.py

@@ -0,0 +1,160 @@
+"""Image/texture implementation code
+
+This module provides the Pan-OpenGL operations required to support OpenGL
+image handling.  Most of this code is simply boilerplate code that sets 
+OpenGL parameters such that normal Pythonic assumptions about data-ordering
+are met to allow easier interaction with other projects (such as PIL or 
+Numpy).
+
+Generally speaking, there are 3 pieces of information which control how 
+an image is processed in the system:
+
+    format -- this is the pixel format, such as GL_RGB/GL_RED/GL_ABGR_EXT
+    dims -- tuple of dimensions for the image, (width,height,depth) order 
+    type -- the storage data-type for the image, normally GL_UNSIGNED_BYTE 
+        when working in Python, but all of the standard OpenGL types for 
+        images can be used if you happen to have your data in some exotic
+        format.
+    
+    OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING -- if this global value is set,
+        then read of unsigned byte images using glReadPixels and 
+        glGetTexImage produces a string instead of the default array format.
+
+Attributes of Note:
+
+    COMPONENT_COUNTS -- used to lookup how many units of a 
+        given storage type are required to store a unit in a given format
+    
+    TYPE_TO_ARRAYTYPE -- maps Image storage types to their array data-type
+        constants, i.e. maps GL_UNSIGNED_SHORT_4_4_4_4 to GL_UNSIGNED_SHORT
+        so that we can use the standard array types for manipulating 
+        image arrays.
+    
+    RANK_PACKINGS -- commands required to set up default array-transfer 
+        operations for an array of the specified rank.
+
+New image formats and types will need to be registered here to be supported,
+this means that extension modules which add image types/formats need to alter 
+the tables described above!
+
+    XXX Should be an API to handle that instead of direct modification.
+
+"""
+from OpenGL.raw.GL.VERSION import GL_1_1 as _simple
+from OpenGL import arrays
+from OpenGL import _configflags
+import ctypes
+
+def SetupPixelRead( format, dims, type):
+    """Setup transfer mode for a read into a numpy array return the array
+    
+    Calls setupDefaultTransferMode, sets rankPacking and then 
+    returns a createTargetArray for the parameters.
+    """
+    setupDefaultTransferMode()
+    # XXX this is wrong? dims may grow or it may not, depends on whether
+    # the format can fit in the type or not, but rank is a property of the 
+    # image itself?  Don't know, should test.
+    rankPacking( len(dims)+1 )
+    return createTargetArray( format, dims, type )
+
+def setupDefaultTransferMode( ):
+    """Set pixel transfer mode to assumed internal structure of arrays
+    
+    Basically OpenGL-ctypes (and PyOpenGL) assume that your image data is in 
+    non-byte-swapped order, with big-endian ordering of bytes (though that 
+    seldom matters in image data).  These assumptions are normally correct 
+    when dealing with Python libraries which expose byte-arrays.
+    """
+    _simple.glPixelStorei(_simple.GL_PACK_SWAP_BYTES, 0)
+    _simple.glPixelStorei(_simple.GL_PACK_LSB_FIRST, 0)
+def rankPacking( rank ):
+    """Set the pixel-transfer modes for a given image "rank" (# of dims)
+    
+    Uses RANK_PACKINGS table to issue calls to glPixelStorei
+    """
+    for func,which,arg in RANK_PACKINGS[rank]:
+        try:
+            func(which,arg)
+        except Exception as err:
+            # XXX should be logging a warning!
+            pass
+
+def createTargetArray( format, dims, type ):
+    """Create storage array for given parameters
+    
+    If storage type requires > 1 unit per format pixel, then dims will be
+    extended by 1, so in the common case of RGB and GL_UNSIGNED_BYTE you 
+    will wind up with an array of dims + (3,) dimensions.  See
+    COMPONENT_COUNTS for table which controls which formats produce
+    larger dimensions.  The secondary table TIGHT_PACK_FORMATS overrides 
+    this case, so that image formats registered as TIGHT_PACK_FORMATS
+    only ever return a dims-shaped value.  TIGHT_PACK_FORMATS will raise 
+    ValueErrors if they are used with a format that does not have the same 
+    number of components as they define.
+    
+    Note that the base storage type must provide a zeros method.  The zeros
+    method relies on their being a registered default array-implementation for 
+    the storage type.  The default installation of OpenGL-ctypes will use 
+    Numpy arrays for returning the result.
+    """
+    # calculate the number of storage elements required to store 
+    # a single pixel of format, that's the dimension of the resulting array
+    componentCount = formatToComponentCount( format )
+    if componentCount > 1:
+        if type not in TIGHT_PACK_FORMATS:
+            # requires multiple elements to store a single pixel (common)
+            # e.g. byte array (typeBits = 8) with RGB (24) or RGBA (32)
+            dims += (componentCount, )
+        elif TIGHT_PACK_FORMATS[ type ] < componentCount:
+            raise ValueError(
+                """Image type: %s supports %s components, but format %s requires %s components"""%(
+                    type,
+                    TIGHT_PACK_FORMATS[ type ],
+                    format,
+                    componentCount,
+                )
+            )
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ TYPE_TO_ARRAYTYPE.get(type,type) ]
+    return arrayType.zeros( dims )
+
+def formatToComponentCount( format ):
+    """Given an OpenGL image format specification, get components/pixel"""
+    size = COMPONENT_COUNTS.get( format )
+    if size is None:
+        raise ValueError( """Unrecognised image format: %r"""%(format,))
+    return size
+
+def returnFormat( data, type ):
+    """Perform compatibility conversion for PyOpenGL 2.x image-as string results
+    
+    Uses OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING to control whether to perform the 
+    conversions.
+    """
+    if _configflags.UNSIGNED_BYTE_IMAGES_AS_STRING:
+        if type == _simple.GL_UNSIGNED_BYTE:
+            if hasattr( data, 'tostring' ):
+                return data.tostring()
+            elif hasattr( data, 'raw' ):
+                return data.raw 
+            elif hasattr( data, '_type_' ):
+                s = ctypes.string_at( ctypes.cast( data, ctypes.c_voidp ), ctypes.sizeof( data ))
+                result = s[:] # copy into a new string
+                return s
+    return data
+
+
+COMPONENT_COUNTS = {
+    # Image-format-constant: number-of-components (integer)
+}
+TYPE_TO_BITS = { 
+    # GL-image-storage-type-constant: number-of-bits (integer)
+}
+TYPE_TO_ARRAYTYPE = { 
+    # GL-image-storage-type-constant: GL-datatype (constant)
+}
+TIGHT_PACK_FORMATS = {
+}
+RANK_PACKINGS = {
+    # rank (integer): list of (function,**arg) to setup for that rank
+}

vllm/lib/python3.10/site-packages/OpenGL/latebind.py

@@ -0,0 +1,61 @@
+"""Late-bound base-class (with acceleration)"""
+from OpenGL import acceleratesupport
+LateBind = Curry = None
+if acceleratesupport.ACCELERATE_AVAILABLE:
+    try:
+        from OpenGL_accelerate.latebind import LateBind, Curry
+    except ImportError as err:
+        pass
+if LateBind is None:
+    class LateBind(object):
+        """Provides a __call__ which dispatches to self._finalCall
+
+        When called without self._finalCall() makes a call to
+        self.finalise() and then calls self._finalCall()
+        """
+        _finalCall = None
+        def setFinalCall( self, finalCall ):
+            """Set our finalCall to the callable object given"""
+            self._finalCall = finalCall
+        def getFinalCall( self ):
+            """Retrieve and/or bind and retrieve final call"""
+            if not self._finalCall:
+                self._finalCall = self.finalise()
+            return self._finalCall
+
+
+        def finalise( self ):
+            """Finalise our target to our final callable object
+
+            return final callable
+            """
+
+        def __call__( self, *args, **named ):
+            """Call self._finalCall, calling finalise() first if not already called
+
+            There's actually *no* reason to unpack and repack the arguments,
+            but unfortunately I don't know of a Cython syntax to specify
+            that.
+            """
+            try:
+                return self._finalCall( *args, **named )
+            except (TypeError,AttributeError) as err:
+                if self._finalCall is None:
+                    self._finalCall = self.finalise()
+                return self._finalCall( *args, **named )
+if Curry is None:
+    class Curry(object):
+        """Provides a simple Curry which can bind (only) the first element
+
+        This is used by lazywrapper, which explains the weird naming
+        of the two attributes...
+        """
+        wrapperFunction = None
+        baseFunction = None
+        def __init__( self, wrapperFunction, baseFunction ):
+            """Stores self.wrapperFunction and self.baseFunction"""
+            self.baseFunction = baseFunction
+            self.wrapperFunction = wrapperFunction
+        def __call__( self, *args, **named ):
+            """returns self.wrapperFunction( self.baseFunction, *args, **named )"""
+            return self.wrapperFunction( self.baseFunction, *args, **named )

vllm/lib/python3.10/site-packages/OpenGL/lazywrapper.py

@@ -0,0 +1,58 @@
+"""Simplistic wrapper decorator for Python-coded wrappers"""
+from OpenGL.latebind import Curry
+from OpenGL import MODULE_ANNOTATIONS
+
+class _LazyWrapper( Curry ):
+    """Marker to tell us that an object is a lazy wrapper"""
+
+def lazy( baseFunction ):
+    """Produce a lazy-binding decorator that uses baseFunction
+
+    Allows simple implementation of wrappers where the
+    whole of the wrapper can be summed up as do 1 thing
+    then call base function with the cleaned up result.
+
+    Passes baseFunction in as the first argument of the
+    wrapped function, all other parameters are passed
+    unchanged.  The wrapper class created has __nonzero__
+    and similar common wrapper entry points defined.
+    """
+    def wrap( wrapper ):
+        """Wrap wrapper with baseFunction"""
+        def __nonzero__( self ):
+            return bool( baseFunction )
+        def __repr__( self ):
+            return '%s( %r )'%(
+                'OpenGL.lazywrapper.lazy',
+                baseFunction.__name__,
+            )
+        _with_wrapper = type( wrapper.__name__, (_LazyWrapper,), {
+            '__repr__': __repr__,
+            '__doc__': wrapper.__doc__,
+            '__nonzero__': __nonzero__,
+            'wrappedOperation': baseFunction,
+            'restype': getattr(wrapper, 'restype',getattr(baseFunction,'restype',None)),
+        } )
+        with_wrapper = _with_wrapper(wrapper,baseFunction)
+        with_wrapper.__name__ = wrapper.__name__
+        if hasattr( baseFunction, '__module__' ):
+            with_wrapper.__module__ = baseFunction.__module__
+        return with_wrapper
+    return wrap
+
+
+if __name__ == "__main__":
+    from OpenGL.raw import GLU
+    func = GLU.gluNurbsCallbackData
+    output = []
+    def testwrap( base ):
+        "Testing"
+        output.append( base )
+    testlazy = lazy( func )( testwrap )
+    testlazy( )
+    assert testlazy.__doc__ == "Testing"
+    assert testlazy.__class__.__name__ == 'testwrap'
+    assert testlazy.__name__ == 'testwrap'
+    assert testlazy.baseFunction is func
+    assert testlazy.wrapperFunction is testwrap
+    assert output

vllm/lib/python3.10/site-packages/OpenGL/logs.py

@@ -0,0 +1,91 @@
+"""Fix missing-API problems in logging module (circa Python 2.3)
+
+Adds constants to the log objects.
+Adds getException(err) to log objects to retrieve 
+formatted exception or err if traceback not available.
+"""
+import traceback, logging
+from OpenGL._configflags import ERROR_LOGGING, FULL_LOGGING
+getLog = logging.getLogger
+
+def getException(error):
+    """Get formatted traceback from exception"""
+    try:
+        return traceback.format_exc( limit=10 )
+    except Exception as err:
+        return str( error )
+
+logging.Logger.getException = staticmethod( getException )
+logging.Logger.err = logging.Logger.error
+logging.Logger.DEBUG = logging.DEBUG 
+logging.Logger.WARN = logging.WARN 
+logging.Logger.INFO = logging.INFO 
+logging.Logger.ERR = logging.Logger.ERROR = logging.ERROR
+
+if FULL_LOGGING:
+    getLog( 'OpenGL.calltrace' ).setLevel( logging.INFO )
+
+class _LoggedFunction( object ):
+    """Proxy that overrides __call__ to log arguments"""
+    def __init__( self, base, log ):
+        self.__dict__[''] = base 
+        self.__dict__['log'] = log
+    def __setattr__( self, key, value ):
+        if key != '':
+            setattr( self.__dict__[''], key, value )
+        else:
+            self.__dict__[''] = value 
+    def __getattr__( self, key ):
+        if key == '':
+            return self.__dict__['']
+        else:
+            return getattr( self.__dict__[''], key )
+class _FullLoggedFunction( _LoggedFunction ):
+    """Fully-logged function wrapper (logs all call params to OpenGL.calltrace)"""
+    _callTrace = getLog( 'OpenGL.calltrace' )
+    def __call__( self, *args, **named ):
+        argRepr = []
+        function = getattr( self, '' )
+        for arg in args:
+            argRepr.append( repr(arg) )
+        for key,value in named.items():
+            argRepr.append( '%s = %s'%( key,repr(value)) )
+        argRepr = ",".join( argRepr )
+        self._callTrace.info( '%s( %s )', function.__name__, argRepr )
+        try:
+            return function( *args, **named )
+        except Exception as err:
+            self.log.warn(
+                """Failure on %s: %s""", function.__name__, self.log.getException( err )
+            )
+            raise
+class _ErrorLoggedFunction ( _LoggedFunction ):
+    """On-error-logged function wrapper"""
+    def __call__( self, *args, **named ):
+        function = getattr( self, '' )
+        try:
+            return function( *args, **named )
+        except Exception as err:
+            self.log.warn(
+                """Failure on %s: %s""", function.__name__, self.log.getException( err )
+            )
+            raise
+    
+
+def logOnFail( function, log ):
+    """Produce possible log-wrapped version of function
+
+    function -- callable object to be wrapped
+    log -- the log to which to log information
+    
+    Uses ERROR_LOGGING and FULL_LOGGING
+    to determine whether/how to wrap the function.
+    """
+    if ERROR_LOGGING or FULL_LOGGING:
+        if FULL_LOGGING:
+            loggedFunction = _FullLoggedFunction( function, log )
+        else:
+            loggedFunction = _ErrorLoggedFunction( function, log )
+        return loggedFunction
+    else:
+        return function