diff --git a/.gitattributes b/.gitattributes index 06747cb67b398b87ded2668158717e8a642b3ff1..37723350b5fa3ec6d81c26e7ab4ec75e33cedae8 100644 --- a/.gitattributes +++ b/.gitattributes @@ -974,3 +974,4 @@ videollama2/lib/python3.10/site-packages/pydantic_core/_pydantic_core.cpython-31 videollama2/lib/python3.10/site-packages/altair/vegalite/v5/__pycache__/api.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text parrot/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Bold.ttf filter=lfs diff=lfs merge=lfs -text parrot/lib/ossl-modules/legacy.so filter=lfs diff=lfs merge=lfs -text +vllm/lib/python3.10/site-packages/cupy_backends/cuda/libs/cusparse.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c45830534f6b930265b9347f6e23f119f59a0ca Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLES3/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLES3/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86fef3397a01504964a3b3c6f40e6ea164812f10 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLES3/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d9eb194d93902bd9eb88e14fdc1a36fd214a0471 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75d954918d3360244986945f2aa221c36484b61b Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/gpu_association.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/gpu_association.py new file mode 100644 index 0000000000000000000000000000000000000000..f515293b03bafa4b1a408f6509cbc76903968b02 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/AMD/gpu_association.py @@ -0,0 +1,23 @@ +'''OpenGL extension AMD.gpu_association + +This module customises the behaviour of the +OpenGL.raw.GLX.AMD.gpu_association to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gpu_association.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.AMD.gpu_association import * +from OpenGL.raw.GLX.AMD.gpu_association import _EXTENSION_NAME + +def glInitGpuAssociationAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context.py new file mode 100644 index 0000000000000000000000000000000000000000..793295cfd49ad0b6c9b366a0a6d4cd4deee9efe7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context import * +from OpenGL.raw.GLX.ARB.create_context import _EXTENSION_NAME + +def glInitCreateContextARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_profile.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_profile.py new file mode 100644 index 0000000000000000000000000000000000000000..a2cdbce11af09b7373567eb3b41d35ad98a6908c --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context_profile + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context_profile import * +from OpenGL.raw.GLX.ARB.create_context_profile import _EXTENSION_NAME + +def glInitCreateContextProfileARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_robustness.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_robustness.py new file mode 100644 index 0000000000000000000000000000000000000000..42aab048989baf8474bd40dc95128b4ceae48e35 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/create_context_robustness.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context_robustness + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context_robustness to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context_robustness import * +from OpenGL.raw.GLX.ARB.create_context_robustness import _EXTENSION_NAME + +def glInitCreateContextRobustnessARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/fbconfig_float.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/fbconfig_float.py new file mode 100644 index 0000000000000000000000000000000000000000..e1940fa0055a7bfe735fc339232987eec021d53b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/fbconfig_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.fbconfig_float + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.fbconfig_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fbconfig_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.fbconfig_float import * +from OpenGL.raw.GLX.ARB.fbconfig_float import _EXTENSION_NAME + +def glInitFbconfigFloatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py new file mode 100644 index 0000000000000000000000000000000000000000..0c4c785f2f46caadb7e3c025b2c70df319be1873 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.framebuffer_sRGB import * +from OpenGL.raw.GLX.ARB.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py new file mode 100644 index 0000000000000000000000000000000000000000..88aab8ab3adb40c2d393f2192284e499f734d4c9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.robustness_application_isolation + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.robustness_application_isolation to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_application_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.robustness_application_isolation import * +from OpenGL.raw.GLX.ARB.robustness_application_isolation import _EXTENSION_NAME + +def glInitRobustnessApplicationIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py new file mode 100644 index 0000000000000000000000000000000000000000..ec1601d5d7c1808dea433db843b1b0fdf5579d10 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.robustness_share_group_isolation + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.robustness_share_group_isolation to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_share_group_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.robustness_share_group_isolation import * +from OpenGL.raw.GLX.ARB.robustness_share_group_isolation import _EXTENSION_NAME + +def glInitRobustnessShareGroupIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py new file mode 100644 index 0000000000000000000000000000000000000000..bfbb200467b7fae20774c528a2098496ae370fc9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py @@ -0,0 +1,81 @@ +'''OpenGL extension ARB.vertex_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.vertex_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface that allows various types of data + (especially vertex array data) to be cached in high-performance + graphics memory on the server, thereby increasing the rate of data + transfers. + + Chunks of data are encapsulated within "buffer objects", which + conceptually are nothing more than arrays of bytes, just like any + chunk of memory. An API is provided whereby applications can read + from or write to buffers, either via the GL itself (glBufferData, + glBufferSubData, glGetBufferSubData) or via a pointer to the memory. + + The latter technique is known as "mapping" a buffer. When an + application maps a buffer, it is given a pointer to the memory. When + the application finishes reading from or writing to the memory, it is + required to "unmap" the buffer before it is once again permitted to + use that buffer as a GL data source or sink. Mapping often allows + applications to eliminate an extra data copy otherwise required to + access the buffer, thereby enhancing performance. In addition, + requiring that applications unmap the buffer to use it as a data + source or sink ensures that certain classes of latent synchronization + bugs cannot occur. + + Although this extension only defines hooks for buffer objects to be + used with OpenGL's vertex array APIs, the API defined in this + extension permits buffer objects to be used as either data sources or + sinks for any GL command that takes a pointer as an argument. + Normally, in the absence of this extension, a pointer passed into the + GL is simply a pointer to the user's data. This extension defines + a mechanism whereby this pointer is used not as a pointer to the data + itself, but as an offset into a currently bound buffer object. The + buffer object ID zero is reserved, and when buffer object zero is + bound to a given target, the commands affected by that buffer binding + behave normally. When a nonzero buffer ID is bound, then the pointer + represents an offset. + + In the case of vertex arrays, this extension defines not merely one + binding for all attributes, but a separate binding for each + individual attribute. As a result, applications can source their + attributes from multiple buffers. An application might, for example, + have a model with constant texture coordinates and variable geometry. + The texture coordinates might be retrieved from a buffer object with + the usage mode "STATIC_DRAW", indicating to the GL that the + application does not expect to update the contents of the buffer + frequently or even at all, while the vertices might be retrieved from + a buffer object with the usage mode "STREAM_DRAW", indicating that + the vertices will be updated on a regular basis. + + In addition, a binding is defined by which applications can source + index data (as used by DrawElements, DrawRangeElements, and + MultiDrawElements) from a buffer object. On some platforms, this + enables very large models to be rendered with no more than a few + small commands to the graphics device. + + It is expected that a future extension will allow sourcing pixel data + from and writing pixel data to a buffer object. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.vertex_buffer_object import * +from OpenGL.raw.GLX.ARB.vertex_buffer_object import _EXTENSION_NAME + +def glInitVertexBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ab56d5bb779ae6b44cceecbe8b9a689a7a3feaa Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/multisample.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/multisample.py new file mode 100644 index 0000000000000000000000000000000000000000..ff0676597964a2016281df2465a431c5269d9c45 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/DFX/multisample.py @@ -0,0 +1,65 @@ +'''OpenGL extension DFX.multisample + +This module customises the behaviour of the +OpenGL.raw.GLX.DFX.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color sample + values are resolved to a single, displayable color each time a pixel + is updated, so the antialiasing appears to be automatic at the + application level. Because each sample includes depth and stencil + information, the depth and stencil functions perform equivalently to + the single-sample mode. + + An additional buffer, called the multisample buffer, is added to the + framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, + front/back, and aux) do coexist with the multisample buffer, + however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and even + intersecting polygons. If only points or lines are being rendered, + the "smooth" antialiasing mechanism provided by the base GL may + result in a higher quality image. + + This extension is a subset of SGIS_multisample. It differs in these + key ways: + + * Fragment alpha values are not affected by the fragment sample mask + * The sample locations may or may not be fixed. Thus, there is no + support for rendering the scene multiple times with different + sample points. + * Fragment masks are not computed for images or for bitmasks. + + Because of these differences a new extension was created. However, + it is not expected that this extension will co-exist with + SGIS_multisample. Because of this and the fact that there are only + 32 push/pop bits the MULTISAMPLE_BIT_SGIS state value is the same as + MUTLISAMPLE_BIT_3DFX. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DFX/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.DFX.multisample import * +from OpenGL.raw.GLX.DFX.multisample import _EXTENSION_NAME + +def glInitMultisampleDFX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ab03c4652fd719b8f0ac2e9f38841aae1747ab9 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..966a87fea1fe5695a99fa57cb9778bc730e924cf Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b35e221a97df32d80d32fc7e6b3bc4b31255ef9 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9128fa0c62880915e9f3c889a39da6eb0f1c5e00 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/agp_offset.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/agp_offset.py new file mode 100644 index 0000000000000000000000000000000000000000..f9a31af3e57ba896e3dec8d7989540eab19efd22 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/agp_offset.py @@ -0,0 +1,31 @@ +'''OpenGL extension MESA.agp_offset + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.agp_offset to provide a more +Python-friendly API + +Overview (from the spec) + + This extensions provides a way to convert pointers in an AGP memory + region into byte offsets into the AGP aperture. + Note, this extension depends on GLX_NV_vertex_array_range, for which + no real specification exists. See GL_NV_vertex_array_range for more + information. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/agp_offset.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.agp_offset import * +from OpenGL.raw.GLX.MESA.agp_offset import _EXTENSION_NAME + +def glInitAgpOffsetMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py new file mode 100644 index 0000000000000000000000000000000000000000..62184a3279962e46a525cd4880cb03a6b70ce12b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py @@ -0,0 +1,30 @@ +'''OpenGL extension MESA.copy_sub_buffer + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.copy_sub_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + The glxCopySubBufferMESA() function copies a rectangular region + of the back color buffer to the front color buffer. This can be + used to quickly repaint 3D windows in response to expose events + when the back color buffer cannot be damaged by other windows. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/copy_sub_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.copy_sub_buffer import * +from OpenGL.raw.GLX.MESA.copy_sub_buffer import _EXTENSION_NAME + +def glInitCopySubBufferMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py new file mode 100644 index 0000000000000000000000000000000000000000..d2a5e618896dbcca9f346a76bffb01da8b5af022 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py @@ -0,0 +1,35 @@ +'''OpenGL extension MESA.pixmap_colormap + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.pixmap_colormap to provide a more +Python-friendly API + +Overview (from the spec) + + Since Mesa allows RGB rendering into drawables with PseudoColor, + StaticColor, GrayScale and StaticGray visuals, Mesa needs a colormap + in order to compute pixel values during rendering. + + The colormap associated with a window can be queried with normal + Xlib functions but there is no colormap associated with pixmaps. + + The glXCreateGLXPixmapMESA function is an alternative to glXCreateGLXPixmap + which allows specification of a colormap. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/pixmap_colormap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.pixmap_colormap import * +from OpenGL.raw.GLX.MESA.pixmap_colormap import _EXTENSION_NAME + +def glInitPixmapColormapMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/query_renderer.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/query_renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..a6a88e0b04ac44a490690e5499d27ad7455aa46c --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/query_renderer.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.query_renderer + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.query_renderer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/query_renderer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.query_renderer import * +from OpenGL.raw.GLX.MESA.query_renderer import _EXTENSION_NAME + +def glInitQueryRendererMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py new file mode 100644 index 0000000000000000000000000000000000000000..fe42d11bbf0d39f27960146728ba464531230330 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py @@ -0,0 +1,29 @@ +'''OpenGL extension MESA.set_3dfx_mode + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.set_3dfx_mode to provide a more +Python-friendly API + +Overview (from the spec) + + The Mesa Glide driver allows full-screen rendering or rendering into + an X window. The glXSet3DfxModeMESA() function allows an application + to switch between full-screen and windowed rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/set_3dfx_mode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.set_3dfx_mode import * +from OpenGL.raw.GLX.MESA.set_3dfx_mode import _EXTENSION_NAME + +def glInitSet3DfxModeMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03a0a226aa7ad12f58390c48ff016bfa0050d619 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/swap_method.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/swap_method.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..919b44f810502ef657ddd561a2adbd6e77526534 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/swap_method.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/sync_control.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/sync_control.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19f2300c4bb27e1fec7d873039607be3f901f8e7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/__pycache__/sync_control.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/swap_method.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/swap_method.py new file mode 100644 index 0000000000000000000000000000000000000000..0e7bc332801a46a3eb90be97dba09b02cbea001d --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/swap_method.py @@ -0,0 +1,23 @@ +'''OpenGL extension OML.swap_method + +This module customises the behaviour of the +OpenGL.raw.GLX.OML.swap_method to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/swap_method.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.OML.swap_method import * +from OpenGL.raw.GLX.OML.swap_method import _EXTENSION_NAME + +def glInitSwapMethodOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/sync_control.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/sync_control.py new file mode 100644 index 0000000000000000000000000000000000000000..904b62014908c17354efdbca4c660238438fba59 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/OML/sync_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension OML.sync_control + +This module customises the behaviour of the +OpenGL.raw.GLX.OML.sync_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/sync_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.OML.sync_control import * +from OpenGL.raw.GLX.OML.sync_control import _EXTENSION_NAME + +def glInitSyncControlOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af8424a7de6866c2bb5cf686c4d3fed861f28df3 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5a8f5a169d24266607fae814f96fe7923d63bb1 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3b3b36ba27bb59cc314a8ef6434f85460583cf8 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a6b9e2d9250ae7f518f1ee79f5bec8cc7f0c807 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6927eb0b013117321d7175e9dea77242992aa515 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfc4346dc4fbe1824d2a9159e7e7b7a8932911c7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9989be1c015c347127a5ad3fd555f09fbc3ad619 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7b44ad56c3734abc7f7eec8036efa90eed1671b Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/video_source.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/video_source.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3e2e49f127f9201a4d8fc6984d6333bdc1192ea Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/video_source.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bc48c3d5219ce4dafd28dbebe31bc4c34d70044 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/dmbuffer.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/dmbuffer.py new file mode 100644 index 0000000000000000000000000000000000000000..22bc3d73a40f72b6cfda6c07f6274644bd00c5c8 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/dmbuffer.py @@ -0,0 +1,71 @@ +'''OpenGL extension SGIX.dmbuffer + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.dmbuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new type of GLXPbuffer, a DM or Digital + Media pbuffer. A DM pbuffer is a GLXPbuffer that adopts one or more + of its buffers from an externally defined and allocated DMbuffer. + In this way it resembles a GLXPixmap that attaches to an existing + X pixmap. Like a standard pbuffer it can be used as a non-displayable + rendering area, or as a read source for pixel data. The externally + defined buffers of the DM pbuffer can be sequentially associated + with other DM buffers of the same size and configuration. + + . The DM pbuffer is described with a new attrib passed to + glXCreateGLXPbuffer. + + . A new GLX command allows associating a compatible DMbuffer with + the DM GLXPbuffer. At associate time the DM buffers described + by the DMparams are used directly as the corresponding + buffers of the GLXPbuffer drawable, as described by the FBconfig. + All other buffers that are part of the config will be created by + GL without externally referenceable names. A DM pbuffer must be + associated with a compatible DMbuffer before it can be made current + to a GLX context. + + . The externally defined buffers of the DM pbuffer can be changed at + any time by successfully associating a new DMbuffer with the GLXPbuffer + through the associate command. It will be the application's + responsibility to synchronize DMedia, GLX, and GL commands that + effect the contents of the DM pbuffer. + + . Any direct GLX rendering context that satisfies config compatibility + can be used to render to or read from a DM GLXPbuffer. + A currently associated DMbuffer may simultaneously be in use by + other clients on the same Display, but will not be destroyed + while associated with a GLXPbuffer. When the GLXpbuffer is + destroyed, all buffers that have no remaining clients, including + the DMbuffer, will be freed. + + DM GLXPbuffers are proposed as a means for OpenGL to access buffers + generated by the VL, compression, and other digital media libraries in + a uniform way. The DMbuffer and DMparams descriptors are left + intentionally abstract so that the GLX extension can adapt to future + DM library changes. + The initial implementation will require that the DMparams descriptor + supply at least pixel format and packing information, and that the + DMbuffer provide the size and location of a colorbuffer. GLX will do + compatibility checking when possible based on the config, params, and + buffer information at associate time. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/dmbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.dmbuffer import * +from OpenGL.raw.GLX.SGIX.dmbuffer import _EXTENSION_NAME + +def glInitDmbufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/pbuffer.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/pbuffer.py new file mode 100644 index 0000000000000000000000000000000000000000..53c0a02a07ef62a85e655b3c615a94acdd7453c8 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/pbuffer.py @@ -0,0 +1,60 @@ +'''OpenGL extension SGIX.pbuffer + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.pbuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines pixel buffers (GLXPbuffers, or pbuffer for + short). GLXPbuffers are additional non-visible rendering buffers for an + OpenGL renderer. GLXPbuffers are equivalent to GLXPixmaps with the + following exceptions: + + 1. There is no associated X pixmap. Also, since a GLXPbuffer is a GLX + resource, it may not be possible to render to it using X or an + X extension other than GLX. + + 2. The format of the color buffers and the type and size of any + associated ancillary buffers for a GLXPbuffer can only be + described with a GLXFBConfig -- an X Visual cannot be used. + + 3. It is possible to create a GLXPbuffer whose contents may be + asynchronously lost at any time. + + 4. GLXPbuffers can be rendered to using either direct or indirect + rendering contexts. + + 5. The allocation of a GLXPbuffer can fail if there are insufficient + resources (i.e., all the pbuffer memory has been allocated and + the implementation does not virtualize pbuffer memory.) + + The intent of the pbuffer semantics is to enable implementations to + allocate pbuffers in non-visible frame buffer memory. These + pbuffers are intended to be "static" resources, in that a program + will typically allocate them only once, rather than as a part of its + rendering loop. (But they should be deallocated when the program is + no longer using them -- for example, if the program is iconified.) + The frame buffer resources that are associated with a pbuffer are + also static, and are deallocated only when the pbuffer is destroyed, + or, in the case of a "unpreserved" pbuffer, as a result of X server + activity that changes its frame buffer requirements. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/pbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.pbuffer import * +from OpenGL.raw.GLX.SGIX.pbuffer import _EXTENSION_NAME + +def glInitPbufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_barrier.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_barrier.py new file mode 100644 index 0000000000000000000000000000000000000000..d599cdb45208e4a81578eb17c8372bf8c3b3d6c9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_barrier.py @@ -0,0 +1,37 @@ +'''OpenGL extension SGIX.swap_barrier + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.swap_barrier to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability to sychronize the buffer + swaps of different swap groups. + + A swap group is bound to a _swap_barrier_. The buffer swaps of each + swap group using that barrier will wait until every swap group using + that barrier is ready to swap (where readiness is defined below), after + which time all buffer swaps of all groups using that barrier will + take place concurrently. + + This extension extends the set of conditions that must be met before + a buffer swap can take place. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/swap_barrier.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.swap_barrier import * +from OpenGL.raw.GLX.SGIX.swap_barrier import _EXTENSION_NAME + +def glInitSwapBarrierSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_group.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_group.py new file mode 100644 index 0000000000000000000000000000000000000000..cfa0bb50b63c1e7155762192bc84e3dff66a6754 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/swap_group.py @@ -0,0 +1,33 @@ +'''OpenGL extension SGIX.swap_group + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.swap_group to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability to synchronize the buffer swaps + of a group of GLX drawables. A swap group is created, and drawables are + added as members to the swap group. Buffer swaps to members of the swap + group will then take place concurrently. + + This extension extends the set of conditions that must be met before + a buffer swap can take place. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/swap_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.swap_group import * +from OpenGL.raw.GLX.SGIX.swap_group import _EXTENSION_NAME + +def glInitSwapGroupSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_resize.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_resize.py new file mode 100644 index 0000000000000000000000000000000000000000..26e7cb342b184ad6c02eaaef1123e5781543486d --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_resize.py @@ -0,0 +1,37 @@ +'''OpenGL extension SGIX.video_resize + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.video_resize to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a means for doing swap or frame synchronous + resizing/panning of the area + that is to be magnified (or passed through) to the output + video resolution. The purpose of this functionality is to provide a + means of allowing an application to draw into a smaller viewport to + reduce the time spent doing pixel fill. This reduced size viewport + is then magnified up to the video output resolution using the + SGIX_video_resize extension. This extension differs from SGIX_framezoom + (number 57) in that it is post framebuffer resizing. Over rendering + at swap rates and panning at frame rates is possible using frame synchronous + update instead of swap synchronous update used for the fill reduction case. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/video_resize.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.video_resize import * +from OpenGL.raw.GLX.SGIX.video_resize import _EXTENSION_NAME + +def glInitVideoResizeSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_source.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_source.py new file mode 100644 index 0000000000000000000000000000000000000000..5cbcd86d7ea52caab4ef6a94649c19d0f040e943 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/video_source.py @@ -0,0 +1,33 @@ +'''OpenGL extension SGIX.video_source + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.video_source to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability to source pixel data from a + video stream. A new type of GLXDrawable (GLXVideoSourceSGIX) is + introduced which represents the drain node of a Video Library (VL) + path. A GLXVideoSourceSGIX may be specified as the parameter + to glXMakeCurrentReadSGI to indicate that pixel data should be read + from the specified video source instead of from the framebuffer. A + GLXVideoSourceSGIX may only be specified as a drawable. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/video_source.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.video_source import * +from OpenGL.raw.GLX.SGIX.video_source import _EXTENSION_NAME + +def glInitVideoSourceSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/visual_select_group.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/visual_select_group.py new file mode 100644 index 0000000000000000000000000000000000000000..9748bcf6d0d532e246017d7497d5d4fb1bcaa54e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SGIX/visual_select_group.py @@ -0,0 +1,36 @@ +'''OpenGL extension SGIX.visual_select_group + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.visual_select_group to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to lower visual selection + priorities that glXChooseVisual or glXChooseFBConfig defines. + A new visual attribute is introduced, providing a way for servers + to group visuals to different visual selection categories. + The visual selection priorities of all the visuals in one category + may be higher or lower than the ones in another category. + The visual selection priorities in one category follow the rules + of glXChooseVisual or glXChooseFBConfig. The new attribute is + invisible to users so can't be queried by glXGetConfig or + glXGetFBConfigAttrib. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/visual_select_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.visual_select_group import * +from OpenGL.raw.GLX.SGIX.visual_select_group import _EXTENSION_NAME + +def glInitVisualSelectGroupSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ad12ea1c3569951ce75aa56fcd753f8e3cc6425 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf69e2d4aea9fd6d8bb766d7952db4e518f10d0c Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/get_transparent_index.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/get_transparent_index.py new file mode 100644 index 0000000000000000000000000000000000000000..356218072df4df9c06981df13f21f678e5be9863 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/SUN/get_transparent_index.py @@ -0,0 +1,27 @@ +'''OpenGL extension SUN.get_transparent_index + +This module customises the behaviour of the +OpenGL.raw.GLX.SUN.get_transparent_index to provide a more +Python-friendly API + +Overview (from the spec) + + Gets the transparent pixel index for an overlay/underlay window pair. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/get_transparent_index.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SUN.get_transparent_index import * +from OpenGL.raw.GLX.SUN.get_transparent_index import _EXTENSION_NAME + +def glInitGetTransparentIndexSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_0.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_0.py new file mode 100644 index 0000000000000000000000000000000000000000..2ac67d4129201e743bb39a3d9b8d33c12178f1d9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_0.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_0 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_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/GLX_1_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_0 import * +from OpenGL.raw.GLX.VERSION.GLX_1_0 import _EXTENSION_NAME + +def glInitGlx10VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_1.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_1.py new file mode 100644 index 0000000000000000000000000000000000000000..cdf646e04ce20f307522e86635ce5cde22ee1734 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_1.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_1 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_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/GLX_1_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_1 import * +from OpenGL.raw.GLX.VERSION.GLX_1_1 import _EXTENSION_NAME + +def glInitGlx11VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_2.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_2.py new file mode 100644 index 0000000000000000000000000000000000000000..517542bec40ae05b78e8d79849288afbf02b0222 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_2.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_2 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_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/GLX_1_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_2 import * +from OpenGL.raw.GLX.VERSION.GLX_1_2 import _EXTENSION_NAME + +def glInitGlx12VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_3.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_3.py new file mode 100644 index 0000000000000000000000000000000000000000..53d63705b25f75c216dcafed6c4df48b031d0964 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_3.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_3 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_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/GLX_1_3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_3 import * +from OpenGL.raw.GLX.VERSION.GLX_1_3 import _EXTENSION_NAME + +def glInitGlx13VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_4.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_4.py new file mode 100644 index 0000000000000000000000000000000000000000..7bd18f7e1ce0c646418c66a83f90f3bb8bd76214 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/GLX_1_4.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_4 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_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/GLX_1_4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_4 import * +from OpenGL.raw.GLX.VERSION.GLX_1_4 import _EXTENSION_NAME + +def glInitGlx14VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfd1cf173e05705bce7e7ec2ced863c4a4e68379 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f34d6b3c28d78841e51fba5331b2b8751b20d0a2 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b078ea44135d4af2cd80b76158afa72e4461f4e7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff7e451936bc14a645fe6dc83261fa3c6993bf11 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f02517fba056194f3003a67778a3e9ef841b196 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee4d3c20fedf0a35fdc34d896daae12cf5654459 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/VERSION/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GLX/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GLX/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..761f8e9c27ce8553c8dde82c1f741208d914d051 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GLX/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2736d8e841bb587d44b54e8e44c2ab7664fd3df9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/__init__.py @@ -0,0 +1,70 @@ +"""Abstraction for the platform-specific code in PyOpenGL + +Each supported platform has a module which provides the +specific functionality required to support the base OpenGL +functionality on that platform. These modules are +registered using plugins in the: + + OpenGL.plugin.PlatformPlugin + +objects. To support a new platform you'll need to create +a new PlatformPlugin instance *before* you import +OpenGL.platform . Once you have a working platform +module, please consider contributing it back to the project. + +See baseplatform.BasePlatform for the core functionality +of a platform implementation. See the various platform +specific modules for examples to use when porting. +""" +import os, sys +from OpenGL.plugins import PlatformPlugin + +def _load( ): + """Load the os.name plugin for the platform functionality""" + key = (os.environ.get( 'PYOPENGL_PLATFORM'), sys.platform,os.name) + plugin = PlatformPlugin.match( key ) + plugin_class = plugin.load() + plugin.loaded = True + # create instance of this platform implementation + plugin = plugin_class() + + # install into the platform module's namespace now + plugin.install(globals()) + return plugin + +_load() + +def types(resultType,*argTypes): + """Decorator to add returnType, argTypes and argNames to a function""" + def add_types( function ): + """Adds the given metadata to the function, introspects var names from declaration""" + function.resultType = resultType + function.argTypes = argTypes + if hasattr( function, 'func_code' ): # python 2.x + function.argNames = function.func_code.co_varnames + else: + function.argNames = function.__code__.co_varnames + return function + return add_types + +def unpack_constants( constants, namespace ): + """Create constants and add to the namespace""" + from OpenGL.constant import Constant + for line in constants.splitlines(): + if line and line.split(): + name,value = line.split() + namespace[name] = Constant( name, int(value,16) ) + +def createFunction( function, dll,extension,deprecated=False, error_checker=None ): + """Allows the more compact declaration format to use the old-style constructor""" + return nullFunction( + function.__name__, + dll or PLATFORM.GL, + resultType = function.resultType, + argTypes = function.argTypes, + doc = None, argNames = function.argNames, + extension = extension, + deprecated = deprecated, + module = function.__module__, + error_checker = error_checker, + ) diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/__pycache__/egl.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/platform/__pycache__/egl.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9bc02333ae234e5a6c9fd271e987a6825a698463 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/platform/__pycache__/egl.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/baseplatform.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/baseplatform.py new file mode 100644 index 0000000000000000000000000000000000000000..ad88441b7c04981f1d1c00297dcef1f20f796617 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/baseplatform.py @@ -0,0 +1,419 @@ +"""Base class for platform implementations +""" +import ctypes +from OpenGL.platform import ctypesloader +from OpenGL._bytes import as_8_bit +import sys +from OpenGL import _configflags +from OpenGL import logs, MODULE_ANNOTATIONS + +class lazy_property( object ): + def __init__( self, function ): + self.fget = function + def __get__( self, obj, cls ): + value = self.fget( obj ) + setattr( obj, self.fget.__name__, value) + return value + +class _CheckContext( object ): + def __init__( self, func, ccisvalid ): + self.func = func + self.ccisvalid = ccisvalid + def __setattr__( self, key, value ): + if key not in ('func','ccisvalid'): + return setattr( self.func, key, value ) + else: + self.__dict__[key] = value + def __repr__( self ): + if getattr( self.func, '__doc__', None ): + return self.func.__doc__ + else: + return repr( self.func ) + def __getattr__( self, key ): + if key != 'func': + return getattr(self.func, key ) + raise AttributeError( key ) + def __call__( self, *args, **named ): + if not self.ccisvalid(): + from OpenGL import error + raise error.NoContext( self.func.__name__, args, named ) + return self.func( *args, **named ) + +def _find_module( exclude = (__name__,)): + frame = sys._getframe() + while frame and '__name__' in frame.f_globals: + if exclude: + if not frame.f_globals['__name__'] in exclude: + return frame.f_globals['__name__'] + + else: + return frame.f_globals['__name__'] + frame = frame.f_back + return None + +class BasePlatform( object ): + """Base class for per-platform implementations + + Attributes of note: + + EXPORTED_NAMES -- set of names exported via the platform + module's namespace... + + GL, GLU, GLUT, GLE, GLES1, GLES2, GLES3 -- ctypes libraries + + DEFAULT_FUNCTION_TYPE -- used as the default function + type for functions unless overridden on a per-DLL + basis with a "FunctionType" member + + GLUT_GUARD_CALLBACKS -- if True, the GLUT wrappers + will provide guarding wrappers to prevent GLUT + errors with uninitialised GLUT. + + EXTENSIONS_USE_BASE_FUNCTIONS -- if True, uses regular + dll attribute-based lookup to retrieve extension + function pointers. + """ + + EXPORTED_NAMES = [ + 'GetCurrentContext','CurrentContextIsValid', + 'createBaseFunction', 'createExtensionFunction', 'copyBaseFunction', + 'getGLUTFontPointer','nullFunction', + 'GLUT_GUARD_CALLBACKS', + ] + + + DEFAULT_FUNCTION_TYPE = None + GLUT_GUARD_CALLBACKS = False + EXTENSIONS_USE_BASE_FUNCTIONS = False + + def install( self, namespace ): + """Install this platform instance into the platform module""" + for name in self.EXPORTED_NAMES: + namespace[ name ] = getattr(self,name,None) + namespace['PLATFORM'] = self + return self + + def functionTypeFor( self, dll ): + """Given a DLL, determine appropriate function type...""" + if hasattr( dll, 'FunctionType' ): + return dll.FunctionType + else: + return self.DEFAULT_FUNCTION_TYPE + + def errorChecking( self, func, dll, error_checker=None ): + """Add error checking to the function if appropriate""" + from OpenGL import error + if error_checker and _configflags.ERROR_CHECKING: + #GLUT spec says error-checking is basically undefined... + # there *may* be GL errors on GLUT calls that e.g. render + # geometry, but that's all basically "maybe" stuff... + func.errcheck = error_checker.glCheckError + return func + def wrapContextCheck( self, func, dll ): + """Wrap function with context-checking if appropriate""" + if _configflags.CONTEXT_CHECKING and dll is self.GL and func.__name__ not in ( + 'glGetString', + 'glGetStringi', + 'glGetIntegerv', + ) and not func.__name__.startswith( 'glX' ): + return _CheckContext( func, self.CurrentContextIsValid ) + return func + def wrapLogging( self, func ): + """Wrap function with logging operations if appropriate""" + return logs.logOnFail( func, logs.getLog( 'OpenGL.errors' )) + + def finalArgType( self, typ ): + """Retrieve a final type for arg-type""" + if typ == ctypes.POINTER( None ) and not getattr( typ, 'final',False): + from OpenGL.arrays import ArrayDatatype + return ArrayDatatype + else: + return typ + def constructFunction( + self, + functionName, dll, + resultType=ctypes.c_int, argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + force_extension = False, + error_checker = None, + ): + """Core operation to create a new base ctypes function + + raises AttributeError if can't find the procedure... + """ + is_core = (not extension) or extension.split('_')[1] == 'VERSION' + if (not is_core) and not self.checkExtension( extension ): + raise AttributeError( """Extension not available""" ) + argTypes = [ self.finalArgType( t ) for t in argTypes ] + + if force_extension or ((not is_core) and (not self.EXTENSIONS_USE_BASE_FUNCTIONS)): + # what about the VERSION values??? + pointer = self.getExtensionProcedure( as_8_bit(functionName) ) + if pointer: + func = self.functionTypeFor( dll )( + resultType, + *argTypes + )( + pointer + ) + else: + raise AttributeError( """Extension %r available, but no pointer for function %r"""%(extension,functionName)) + else: + func = ctypesloader.buildFunction( + self.functionTypeFor( dll )( + resultType, + *argTypes + ), + functionName, + dll, + ) + func.__doc__ = doc + func.argNames = list(argNames or ()) + func.__name__ = functionName + func.DLL = dll + func.extension = extension + func.deprecated = deprecated + func = self.wrapLogging( + self.wrapContextCheck( + self.errorChecking( func, dll, error_checker=error_checker ), + dll, + ) + ) + if MODULE_ANNOTATIONS: + if not module: + module = _find_module( ) + if module: + func.__module__ = module + return func + + def createBaseFunction( + self, + functionName, dll, + resultType=ctypes.c_int, argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + error_checker = None, + ): + """Create a base function for given name + + Normally you can just use the dll.name hook to get the object, + but we want to be able to create different bindings for the + same function, so we do the work manually here to produce a + base function from a DLL. + """ + from OpenGL import wrapper + result = None + try: + if ( + _configflags.FORWARD_COMPATIBLE_ONLY and + dll is self.GL and + deprecated + ): + result = self.nullFunction( + functionName, dll=dll, + resultType=resultType, + argTypes=argTypes, + doc = doc, argNames = argNames, + extension = extension, + deprecated = deprecated, + error_checker = error_checker, + ) + else: + result = self.constructFunction( + functionName, dll, + resultType=resultType, argTypes=argTypes, + doc = doc, argNames = argNames, + extension = extension, + error_checker = error_checker, + ) + except AttributeError as err: + result = self.nullFunction( + functionName, dll=dll, + resultType=resultType, + argTypes=argTypes, + doc = doc, argNames = argNames, + extension = extension, + error_checker = error_checker, + ) + if MODULE_ANNOTATIONS: + if not module: + module = _find_module( ) + if module: + result.__module__ = module + return result + def checkExtension( self, name ): + """Check whether the given extension is supported by current context""" +# if not name or name in ('GL_VERSION_GL_1_0', 'GL_VERSION_GL_1_1'): +# return True +# if name.startswith( 'EGL_' ) or name.startswith( 'GLX_' ) or name.startswith( 'WGL_' ): +# # we can't check these extensions, have to rely on the function resolution +# return True + if not name: + return True + context = self.GetCurrentContext() + if context: + from OpenGL import contextdata + set = contextdata.getValue( 'extensions', context=context ) + if set is None: + set = {} + contextdata.setValue( + 'extensions', set, context=context, weak=False + ) + current = set.get( name ) + if current is None: + from OpenGL import extensions + result = extensions.ExtensionQuerier.hasExtension( name ) + set[name] = result + return result + return current + else: + from OpenGL import extensions + return extensions.ExtensionQuerier.hasExtension( name ) + createExtensionFunction = createBaseFunction + + def copyBaseFunction( self, original ): + """Create a new base function based on an already-created function + + This is normally used to provide type-specific convenience versions of + a definition created by the automated generator. + """ + from OpenGL import wrapper, error + if isinstance( original, _NullFunctionPointer ): + return self.nullFunction( + original.__name__, + original.DLL, + resultType = original.restype, + argTypes= original.argtypes, + doc = original.__doc__, + argNames = original.argNames, + extension = original.extension, + deprecated = original.deprecated, + error_checker = original.error_checker, + ) + elif hasattr( original, 'originalFunction' ): + original = original.originalFunction + return self.createBaseFunction( + original.__name__, original.DLL, + resultType=original.restype, argTypes=original.argtypes, + doc = original.__doc__, argNames = original.argNames, + extension = original.extension, + deprecated = original.deprecated, + error_checker = original.errcheck, + ) + def nullFunction( + self, + functionName, dll, + resultType=ctypes.c_int, + argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + error_checker = None, + ): + """Construct a "null" function pointer""" + if deprecated: + base = _DeprecatedFunctionPointer + else: + base = _NullFunctionPointer + cls = type( functionName, (base,), { + '__doc__': doc, + 'deprecated': deprecated, + } ) + if MODULE_ANNOTATIONS: + if not module: + module = _find_module( ) + if module: + cls.__module__ = module + return cls( + functionName, dll, resultType, argTypes, argNames, extension=extension, doc=doc, + error_checker = error_checker, + ) + def GetCurrentContext( self ): + """Retrieve opaque pointer for the current context""" + raise NotImplementedError( + """Platform does not define a GetCurrentContext function""" + ) + def getGLUTFontPointer(self, constant ): + """Retrieve a GLUT font pointer for this platform""" + raise NotImplementedError( + """Platform does not define a GLUT font retrieval function""" + ) + # names that are normally just references to other items... + @lazy_property + def CurrentContextIsValid( self ): + return self.GetCurrentContext + @lazy_property + def OpenGL(self): return self.GL + +class _NullFunctionPointer( object ): + """Function-pointer-like object for undefined functions""" + def __init__( + self, name, dll, resultType, argTypes, argNames, + extension=None, doc=None, deprecated=False, + error_checker = None, + ): + from OpenGL import error + self.__name__ = name + self.DLL = dll + self.argNames = argNames + self.argtypes = argTypes + self.errcheck = None + self.restype = resultType + self.extension = extension + self.doc = doc + self.deprecated = deprecated + self.error_checker = error_checker + resolved = False + def __nonzero__( self ): + """Make this object appear to be NULL""" + if self.extension and not self.resolved: + self.load() + return self.resolved + __bool__ = __nonzero__ + def load( self ): + """Attempt to load the function again, presumably with a context this time""" + from OpenGL import platform + try: + func = platform.PLATFORM.constructFunction( + self.__name__, self.DLL, + resultType=self.restype, + argTypes=self.argtypes, + doc = self.doc, + argNames = self.argNames, + extension = self.extension, + error_checker = self.error_checker, + ) + except AttributeError as err: + return None + else: + # now short-circuit so that we don't need to check again... + self.__class__.__call__ = staticmethod( func.__call__ ) + self.resolved = True + return func + return None + def __call__( self, *args, **named ): + if self.load(): + return self( *args, **named ) + else: + from OpenGL import error + raise error.NullFunctionError( + """Attempt to call an undefined function %s, check for bool(%s) before calling"""%( + self.__name__, self.__name__, + ) + ) + +class _DeprecatedFunctionPointer( _NullFunctionPointer ): + deprecated = True + def __call__( self, *args, **named ): + from OpenGL import error + raise error.NullFunctionError( + """Attempt to call a deprecated function %s while OpenGL in FORWARD_COMPATIBLE_ONLY mode. Set OpenGL.FORWARD_COMPATIBLE_ONLY to False to use legacy entry points"""%( + self.__name__, + ) + ) diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/darwin.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/darwin.py new file mode 100644 index 0000000000000000000000000000000000000000..d5c2840f2fe8c79a50aedb650967bf7a476061da --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/darwin.py @@ -0,0 +1,83 @@ +"""Darwin (MacOSX)-specific platform features + +This was implemented with the help of the following links: +[1] Apple's Mac OS X OpenGL interfaces: http://developer.apple.com/qa/qa2001/qa1269.html +[2] As above, but updated: http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_pg_concepts/chapter_2_section_3.html +[3] CGL reference: http://developer.apple.com/documentation/GraphicsImaging/Reference/CGL_OpenGL/index.html#//apple_ref/doc/uid/TP40001186 +[4] Intro to OpenGL on Mac OS X: http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_intro/chapter_1_section_1.html#//apple_ref/doc/uid/TP40001987-CH207-TP9 + +About the CGL API, (from [1]): +CGL or Core OpenGL is the lowest accessible interface API for OpenGL. +It knows nothing about windowing systems but can be used directly to +find both renderer information and as a full screen or off screen +interface. It is accessible from both Cocoa and Carbon and is what both +NSGL and AGL are built on. A complete Pbuffer interface is also provided. +Functionality is provided in via the OpenGL framework and applications +can include the OpenGL.h header to access CGL's functionality. Developers +can see an example of using CGL with Carbon in the Carbon CGL code sample. + +Documentation and header files are found in: +/System/Library/Frameworks/OpenGL.framework +/System/Library/Frameworks/GLUT.framework + +""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader + +class DarwinPlatform( baseplatform.BasePlatform ): + """Darwin (OSX) platform implementation""" + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + EXTENSIONS_USE_BASE_FUNCTIONS = True + + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'OpenGL', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): return self.GL + @baseplatform.lazy_property + def CGL(self): return self.GL + + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLUT', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLE(self): return self.GLUT + + @baseplatform.lazy_property + def GetCurrentContext( self ): + return self.CGL.CGLGetCurrentContext + + def getGLUTFontPointer( self, constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [ x.title() for x in constant.split( '_' )[1:] ] + internal = 'glut' + "".join( [x.title() for x in name] ) + pointer = ctypes.c_void_p.in_dll( self.GLUT, internal ) + return ctypes.c_void_p(ctypes.addressof(pointer)) + + @baseplatform.lazy_property + def glGetError( self ): + return self.GL.glGetError + diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/egl.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/egl.py new file mode 100644 index 0000000000000000000000000000000000000000..459de4085655c71165529d44b96370c99d3b4d54 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/egl.py @@ -0,0 +1,93 @@ +"""EGL (cross-platform) platform library""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader + +class EGLPlatform( baseplatform.BasePlatform ): + """EGL platform for opengl-es only platforms""" + @baseplatform.lazy_property + def GLES1(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLESv1_CM', # ick + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLES2(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLESv2', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLES3(self): + # implementers guide says to use the same name for the DLL + return self.GLES2 + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GL', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return self.GLES2 or self.GLES1 + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLU', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'glut', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def OpenGL(self): return self.GL + + @baseplatform.lazy_property + def EGL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'EGL', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load EGL library", *err.args) + @baseplatform.lazy_property + def getExtensionProcedure( self ): + eglGetProcAddress = self.EGL.eglGetProcAddress + eglGetProcAddress.restype = ctypes.c_void_p + return eglGetProcAddress + @baseplatform.lazy_property + def GLE( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'gle', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + @baseplatform.lazy_property + def GetCurrentContext( self ): + return self.EGL.eglGetCurrentContext diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/glx.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/glx.py new file mode 100644 index 0000000000000000000000000000000000000000..7da9369adc4fad1fd4d08bd3fbea87ae67d50b47 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/glx.py @@ -0,0 +1,117 @@ +"""GLX (x-windows)-specific platform features""" +import ctypes, ctypes.util +from functools import wraps +from OpenGL.platform import baseplatform, ctypesloader + +class GLXPlatform( baseplatform.BasePlatform ): + """Posix (Linux, FreeBSD, etceteras) implementation for PyOpenGL""" + # On Linux (and, I assume, most GLX platforms, we have to load + # GL and GLU with the "global" flag to allow GLUT to resolve its + # references to GL/GLU functions). + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GL', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLU', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'glut', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + # GLX doesn't seem to have its own loadable module? + @baseplatform.lazy_property + def GLX(self): return self.GL + + @baseplatform.lazy_property + def GLES1(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLESv1_CM', # ick + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLES2(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLESv2', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLES3(self): + # implementers guide says to use the same name for the DLL + return self.GLES2 + + @baseplatform.lazy_property + def glXGetProcAddressARB(self): + base = self.GLX.glXGetProcAddressARB + base.restype = ctypes.c_void_p + return base + @baseplatform.lazy_property + def getExtensionProcedure(self): + return self.glXGetProcAddressARB + + @baseplatform.lazy_property + def GLE( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'gle', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + + # This loads the GLX functions from the GL .so, not sure if that's + # really kosher... + @baseplatform.lazy_property + def GetCurrentContext( self ): + return self.GL.glXGetCurrentContext + + def getGLUTFontPointer( self, constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [ x.title() for x in constant.split( '_' )[1:] ] + internal = 'glut' + "".join( [x.title() for x in name] ) + pointer = ctypes.c_void_p.in_dll( self.GLUT, internal ) + return ctypes.c_void_p(ctypes.addressof(pointer)) + + @baseplatform.lazy_property + def glGetError( self ): + return self.GL.glGetError + diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/osmesa.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/osmesa.py new file mode 100644 index 0000000000000000000000000000000000000000..15cf23f83c87686d2bd8efb706f0fde6f88a1625 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/osmesa.py @@ -0,0 +1,92 @@ +"""OSMesa-specific features + +To request an OSMesa context, you need to run your script with: + + PYOPENGL_PLATFORM=osmesa + +defined in your shell/execution environment. +""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader +from OpenGL.constant import Constant +from OpenGL.raw.osmesa import _types + +class OSMesaPlatform( baseplatform.BasePlatform ): + """OSMesa implementation for PyOpenGL""" + EXPORTED_NAMES = baseplatform.BasePlatform.EXPORTED_NAMES[:] + [ + 'OSMesa', + ] + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'OSMesa', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLU', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'glut', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLE( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'gle', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def OSMesa( self ): return self.GL + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + + @baseplatform.lazy_property + def GetCurrentContext( self ): + function = self.OSMesa.OSMesaGetCurrentContext + function.restype = _types.OSMesaContext + return function + @baseplatform.lazy_property + def CurrentContextIsValid( self ): return self.GetCurrentContext + + @baseplatform.lazy_property + def getExtensionProcedure( self ): + function = self.OSMesa.OSMesaGetProcAddress + function.restype = ctypes.c_void_p + return function + + def getGLUTFontPointer( self, constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [ x.title() for x in constant.split( '_' )[1:] ] + internal = 'glut' + "".join( [x.title() for x in name] ) + pointer = ctypes.c_void_p.in_dll( self.GLUT, internal ) + return ctypes.c_void_p(ctypes.addressof(pointer)) diff --git a/vllm/lib/python3.10/site-packages/OpenGL/platform/win32.py b/vllm/lib/python3.10/site-packages/OpenGL/platform/win32.py new file mode 100644 index 0000000000000000000000000000000000000000..54f393dabd73d1562aeabf0037530e23a7138f1a --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/platform/win32.py @@ -0,0 +1,150 @@ +"""Windows-specific platform features""" +import ctypes +import platform +from OpenGL.platform import ctypesloader, baseplatform +import sys + +if sys.hexversion < 0x2070000: + vc = 'vc7' +# TODO: add Python 3.x compiler compatibility... +else: + vc = 'vc9' + +def _size(): + return platform.architecture()[0].strip( 'bits' ) +size = _size() + +class Win32Platform( baseplatform.BasePlatform ): + """Win32-specific platform implementation""" + + GLUT_GUARD_CALLBACKS = True + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.windll, 'opengl32', mode = ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.windll, 'glu32', mode = ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLUT( self ): + for possible in ('freeglut%s'%(size,),'freeglut', 'glut%s'%(size,)): + # Prefer FreeGLUT if the user has installed it, fallback to the included + # GLUT if it is installed + try: + return ctypesloader.loadLibrary( + ctypes.windll, possible, mode = ctypes.RTLD_GLOBAL + ) + except WindowsError as err: + pass + return None + @baseplatform.lazy_property + def GLE( self ): + for libName in ('opengle%s.%s'%(size,vc,),'gle%s'%(size,)): + try: + GLE = ctypesloader.loadLibrary( ctypes.cdll, libName ) + GLE.FunctionType = ctypes.CFUNCTYPE + return GLE + except WindowsError as err: + pass + else: + break + return None + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.WINFUNCTYPE ) + # Win32 GLUT uses different types for callbacks and functions... + GLUT_CALLBACK_TYPE = staticmethod( ctypes.CFUNCTYPE ) + GDI32 = ctypes.windll.gdi32 + @baseplatform.lazy_property + def WGL( self ): + return self.OpenGL + @baseplatform.lazy_property + def getExtensionProcedure( self ): + wglGetProcAddress = self.OpenGL.wglGetProcAddress + wglGetProcAddress.restype = ctypes.c_void_p + return wglGetProcAddress + + GLUT_FONT_CONSTANTS = { + 'GLUT_STROKE_ROMAN': ctypes.c_void_p( 0), + 'GLUT_STROKE_MONO_ROMAN': ctypes.c_void_p( 1), + 'GLUT_BITMAP_9_BY_15': ctypes.c_void_p( 2), + 'GLUT_BITMAP_8_BY_13': ctypes.c_void_p( 3), + 'GLUT_BITMAP_TIMES_ROMAN_10': ctypes.c_void_p( 4), + 'GLUT_BITMAP_TIMES_ROMAN_24': ctypes.c_void_p( 5), + 'GLUT_BITMAP_HELVETICA_10': ctypes.c_void_p( 6), + 'GLUT_BITMAP_HELVETICA_12': ctypes.c_void_p( 7), + 'GLUT_BITMAP_HELVETICA_18': ctypes.c_void_p( 8), + } + + + def getGLUTFontPointer( self,constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + return self.GLUT_FONT_CONSTANTS[ constant ] + + @baseplatform.lazy_property + def GetCurrentContext( self ): + wglGetCurrentContext = self.GL.wglGetCurrentContext + wglGetCurrentContext.restype = ctypes.c_void_p + return wglGetCurrentContext + + def constructFunction( + self, + functionName, dll, + resultType=ctypes.c_int, argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + error_checker=None, + ): + """Override construct function to do win32-specific hacks to find entry points""" + try: + return super( Win32Platform, self ).constructFunction( + functionName, dll, + resultType, argTypes, + doc, argNames, + extension, + deprecated, + module, + error_checker=error_checker, + ) + except AttributeError as err: + try: + return super( Win32Platform, self ).constructFunction( + functionName, self.GDI32, + resultType, argTypes, + doc, argNames, + extension, + deprecated, + module, + error_checker=error_checker, + ) + except AttributeError as err: + return super( Win32Platform, self ).constructFunction( + functionName, dll, + resultType, argTypes, + doc, argNames, + extension, + deprecated, + module, + force_extension = True, + error_checker=error_checker, + ) + diff --git a/vllm/lib/python3.10/site-packages/cupy_backends/cuda/libs/cusparse.cpython-310-x86_64-linux-gnu.so b/vllm/lib/python3.10/site-packages/cupy_backends/cuda/libs/cusparse.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..8446eccbf8f6aed52cb80aecb279968f76d498fe --- /dev/null +++ b/vllm/lib/python3.10/site-packages/cupy_backends/cuda/libs/cusparse.cpython-310-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fb9df9547c8a81f4b6a99f6719e8d0c5b2b3de1a7963e5532ae1f665a78a6a81 +size 7687640