PyOpenGL-accelerate 4.0.0a5__tar.gz → 4.0.0a8__tar.gz

pyopengl_accelerate-4.0.0a8/MANIFEST.in

@@ -0,0 +1,25 @@
+# The sources an install builds from.
+include src/*.pyx
+include OpenGL_accelerate/*.pxd
+include license.txt
+
+# `exclude`, not merely "not included": setuptools puts every extension
+# `sources` entry into the archive by itself, and `cythonize` rewrites those
+# entries from the .pyx to the .c it generated. So the C arrives without
+# anything here asking for it, and has to be taken back out.
+exclude src/*.c
+
+# NOT `include src/*.c`: that is Cython's output from the .pyx beside it, and
+# Cython is a hard build requirement of this package (see [build-system]), so
+# every install from this archive writes that C itself. `setup.py`'s
+# `drop_c_from_another_toolchain` deletes any that arrived, because the
+# archive carries no toolchain stamp for it to match against -- so shipping it
+# is weight that is deleted on arrival, with a hazard attached: stale
+# generated C is what fails to compile against a numpy it was not written for,
+# reporting an error inside a numpy header that names nothing in this package.
+# See https://github.com/mcfletch/pyopengl/issues/121
+#
+# `src/c/**` is a different thing and is shipped: the dispatch layer generated
+# from the Khronos registry by a tool that does not run at install time and is
+# not distributed. setup.py names those as extension sources, which is what
+# puts them in the archive.

pyopengl_accelerate-4.0.0a8/OpenGL_accelerate/__init__.py

@@ -0,0 +1,21 @@
+"""Cython-coded accelerators for the PyOpenGL wrapper
+
+This package contains Cython accelerator modules which
+attempt to speed up certain aspects of the PyOpenGL 3.x
+wrapper mechanism.  The source code is part of the
+PyOpenGL package and is built via the setupaccel.py
+script in the top level of the PyOpenGL source package.
+"""
+
+import re as _re
+
+#: The version this was built as, which is also the PyOpenGL it pairs with:
+#: the two share generated tables, the dependency is pinned to this number,
+#: and the extension refuses a PyOpenGL stating another.  A release bumps
+#: both this and ``OpenGL/version.py``.
+__version__ = "4.0.0a8"
+#: The numeric release ``__version__`` names, without a pre-release marker,
+#: which ``OpenGL.acceleratesupport`` compares with its floor.
+__version_tuple__ = tuple(
+    int(part) for part in _re.match(r'(\d+)\.(\d+)\.(\d+)', __version__).groups()
+)

{pyopengl_accelerate-4.0.0a5 → pyopengl_accelerate-4.0.0a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a5
+Version: 4.0.0a8
 Summary: Cython-coded accelerators for PyOpenGL
 Home-page: http://pyopengl.sourceforge.net
 Download-URL: http://sourceforge.net/project/showfiles.php?group_id=5988
@@ -24,7 +24,7 @@ Classifier: Intended Audience :: Developers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: license.txt
-Requires-Dist: PyOpenGL==4.0.0a5
+Requires-Dist: PyOpenGL==4.0.0a8
 Dynamic: download-url
 Dynamic: license-file
 Dynamic: requires-dist

{pyopengl_accelerate-4.0.0a5 → pyopengl_accelerate-4.0.0a8}/PyOpenGL_accelerate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a5
+Version: 4.0.0a8
 Summary: Cython-coded accelerators for PyOpenGL
 Home-page: http://pyopengl.sourceforge.net
 Download-URL: http://sourceforge.net/project/showfiles.php?group_id=5988
@@ -24,7 +24,7 @@ Classifier: Intended Audience :: Developers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: license.txt
-Requires-Dist: PyOpenGL==4.0.0a5
+Requires-Dist: PyOpenGL==4.0.0a8
 Dynamic: download-url
 Dynamic: license-file
 Dynamic: requires-dist

pyopengl_accelerate-4.0.0a8/PyOpenGL_accelerate.egg-info/requires.txt

@@ -0,0 +1 @@
+PyOpenGL==4.0.0a8

{pyopengl_accelerate-4.0.0a5 → pyopengl_accelerate-4.0.0a8}/pyproject.toml

@@ -70,3 +70,9 @@ cache-keys = [
     { file = "setup.py" },
     { file = "OpenGL_accelerate/__init__.py" },
 ]
+
+[tool.openglcontext-checks]
+# The OGC rules (openglcontext-checks) this project is held to by the
+# workspace preflight: every rule there is, each named, so a rule added
+# later joins when the project is clean of it.
+select = ["OGC121", "OGC131", "OGC141", "OGC161", "OGC201", "OGC221", "OGC222", "OGC223"]

{pyopengl_accelerate-4.0.0a5 → pyopengl_accelerate-4.0.0a8}/setup.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 """Builds accelleration functions for PyOpenGL
 """
-import sys
 from setuptools import setup, Extension
 
 try:
@@ -84,8 +83,9 @@ def write_version_header():
     except OSError:
         pass
     os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, 'w', encoding='utf-8') as handle:
+    with open(path + '.partial', 'w', encoding='utf-8') as handle:
         handle.write(contents)
+    os.replace(path + '.partial', path)
     return VERSION_HEADER
 
 
@@ -203,8 +203,9 @@ def drop_c_from_another_toolchain():
         pass
     for path in glob.glob(os.path.join(HERE, 'src', '*.c')):
         os.unlink(path)
-    with open(TOOLCHAIN_STAMP, 'w', encoding='utf-8') as handle:
+    with open(TOOLCHAIN_STAMP + '.partial', 'w', encoding='utf-8') as handle:
         handle.write(wanted)
+    os.replace(TOOLCHAIN_STAMP + '.partial', TOOLCHAIN_STAMP)
 
 
 def cython_extension(

{pyopengl_accelerate-4.0.0a5 → pyopengl_accelerate-4.0.0a8}/src/arraydatatype.pyx

@@ -28,9 +28,35 @@ cdef class HandlerRegistry:
         self.all_output_handlers = []
     def __setitem__( self,key,value ):
         self.registry[key] = value
+    # The pure-Python HandlerRegistry is a dict subclass, so it answers a
+    # lookup by type as well as a lookup by value.  This one held its mapping
+    # privately and offered only __setitem__, so `FormatHandler.typeLookup`
+    # -- a public classmethod, and how a third party asks which handler its
+    # own array format resolved to -- raised
+    #     TypeError: 'HandlerRegistry' object is not subscriptable
+    # wherever the accelerators are installed, which is most installations.
+    # Its `except KeyError` could not catch that, so the caller got an error
+    # about the registry's type rather than the answer or the KeyError the
+    # method documents.
+    def __getitem__( self, key ):
+        return self.registry[key]
+    def __contains__( self, key ):
+        return key in self.registry
+    def __len__( self ):
+        return len( self.registry )
+    def __iter__( self ):
+        return iter( self.registry )
+    def get( self, key, default=None ):
+        return self.registry.get( key, default )
+    def keys( self ):
+        return self.registry.keys()
+    def values( self ):
+        return self.registry.values()
+    def items( self ):
+        return self.registry.items()
     def __call__( self, value ):
         return self.c_lookup( value )
-    
+
     cdef object c_lookup( self, object value ):
         """C-level lookup of handler for given value"""
         cdef object typ, handler,base
@@ -491,6 +517,14 @@ cdef class AsArrayOfType(pyArgConverter):
         self.typeIndex = wrapper.pyArgIndex( self.typeName )
     cdef object c_call( self, object incoming, object function, tuple arguments ):
         """Get the arg as an array of the appropriate type"""
+        # An integer is a byte offset into the bound buffer rather than one
+        # datum to upload: this converter serves glDrawElements and the pixel
+        # calls, whose data argument the GL reads as an offset whenever a
+        # buffer object is bound.  Kept in step with the ctypes converter of
+        # the same name in OpenGL/arrays/arrayhelpers.py, and with
+        # OpenGL.arrays.arraydatatype.buffer_offset, which decides.
+        if type(incoming) is int:
+            return ctypes.c_void_p( incoming )
         return self.arrayType.asArray( incoming, arguments[ self.typeIndex ] )
 
 cdef class AsArrayTyped(pyArgConverter):

{pyopengl_accelerate-4.0.0a5 → pyopengl_accelerate-4.0.0a8}/src/buffers_formathandler.pyx

@@ -91,7 +91,13 @@ cdef class MemoryviewHandler(FormatHandler):
     cdef c_arraySize( self, object instance, object typeCode ):
         """Retrieve array size reference"""
         cdef Py_buffer * buffer
-        buffer = PyMemoryView_GET_BUFFER( self.c_as_memoryview( instance ) )
+        # `view` holds the memoryview for as long as `buffer` points into it.
+        # `c_as_memoryview` builds one where the instance is not already a
+        # memoryview, and a temporary of it lives only to the end of the
+        # statement that made it -- so reading through `buffer` on the next
+        # line reads a Py_buffer inside a freed object.
+        view = self.c_as_memoryview( instance )
+        buffer = PyMemoryView_GET_BUFFER( view )
         return buffer.len//buffer.itemsize
     cdef c_arrayByteCount( self, object instance ):
         """Given a data-value, calculate number of bytes required to represent"""
@@ -100,7 +106,9 @@ cdef class MemoryviewHandler(FormatHandler):
     cdef c_arrayToGLType( self, object instance ):
         """Given a value, guess OpenGL type of the corresponding pointer"""
         cdef Py_buffer * buffer
-        buffer = PyMemoryView_GET_BUFFER( self.c_as_memoryview( instance ) )
+        # `view` keeps the memoryview alive; see `c_arraySize`.
+        view = self.c_as_memoryview( instance )
+        buffer = PyMemoryView_GET_BUFFER( view )
         cdef object constant = self.array_to_gl_constant.get( buffer.format )
         if constant is None:
             if isinstance(buffer.format,bytes):
@@ -133,10 +141,14 @@ cdef class MemoryviewHandler(FormatHandler):
     cdef c_dimensions( self, object instance ):
         """Retrieve full set of dimensions for the array as tuple"""
         cdef Py_buffer * buffer
-        buffer = PyMemoryView_GET_BUFFER( self.c_as_memoryview( instance ) )
+        # `view` keeps the memoryview alive; see `c_arraySize`.
+        view = self.c_as_memoryview( instance )
+        buffer = PyMemoryView_GET_BUFFER( view )
         cdef dim = 0
         cdef list result
         result = []
         for dim in range(buffer.ndim):
             result.append( buffer.shape[dim] )
-        return result
+        # A tuple, as the shape of an array is everywhere else here and as
+        # `OpenGL.arrays.buffers.BufferHandler.dimensions` answers.
+        return tuple( result )