PyOpenGL-accelerate 4.0.0a4__tar.gz → 4.0.0a7__tar.gz

pyopengl_accelerate-4.0.0a7/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.0a7/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.0a7"
+#: 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.0a4 → pyopengl_accelerate-4.0.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a4
+Version: 4.0.0a7
 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.0a4
+Requires-Dist: PyOpenGL==4.0.0a7
 Dynamic: download-url
 Dynamic: license-file
 Dynamic: requires-dist
@@ -35,6 +35,22 @@ This set of C (Cython) extensions provides acceleration of common operations
 for slow points in PyOpenGL 3.x. It is not a requirement for using PyOpenGL
 but performance without it will be poor.
 
+## The PyOpenGL it pairs with
+
+`PyOpenGL_accelerate` and `PyOpenGL` are released together, carry the same
+version number, and have to be equal. They share the dispatch extension's
+generated tables, where the slot numbering of one release is meaningless to
+another, so this package requires the exact `PyOpenGL` it was built against:
+
+    pip install PyOpenGL PyOpenGL_accelerate
+
+Installing or upgrading `PyOpenGL_accelerate` brings the matching `PyOpenGL`
+with it. Upgrading `PyOpenGL` on its own does not go the other way — it leaves
+the older accelerate installed — so name both packages when you upgrade either.
+A pair that has come apart is refused when the first entry point is built, in a
+message naming both versions; `PYOPENGL_USE_ACCELERATE=0` in the environment
+runs on ctypes until it is put right.
+
 ## Build Process
 
 Cython is updated frequently to support newer versions of Python. As of

{pyopengl_accelerate-4.0.0a4 → pyopengl_accelerate-4.0.0a7}/PyOpenGL_accelerate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a4
+Version: 4.0.0a7
 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.0a4
+Requires-Dist: PyOpenGL==4.0.0a7
 Dynamic: download-url
 Dynamic: license-file
 Dynamic: requires-dist
@@ -35,6 +35,22 @@ This set of C (Cython) extensions provides acceleration of common operations
 for slow points in PyOpenGL 3.x. It is not a requirement for using PyOpenGL
 but performance without it will be poor.
 
+## The PyOpenGL it pairs with
+
+`PyOpenGL_accelerate` and `PyOpenGL` are released together, carry the same
+version number, and have to be equal. They share the dispatch extension's
+generated tables, where the slot numbering of one release is meaningless to
+another, so this package requires the exact `PyOpenGL` it was built against:
+
+    pip install PyOpenGL PyOpenGL_accelerate
+
+Installing or upgrading `PyOpenGL_accelerate` brings the matching `PyOpenGL`
+with it. Upgrading `PyOpenGL` on its own does not go the other way — it leaves
+the older accelerate installed — so name both packages when you upgrade either.
+A pair that has come apart is refused when the first entry point is built, in a
+message naming both versions; `PYOPENGL_USE_ACCELERATE=0` in the environment
+runs on ctypes until it is put right.
+
 ## Build Process
 
 Cython is updated frequently to support newer versions of Python. As of

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

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

pyopengl_accelerate-4.0.0a7/README.md

@@ -0,0 +1,31 @@
+# Acceleration code for PyOpenGL
+
+This set of C (Cython) extensions provides acceleration of common operations
+for slow points in PyOpenGL 3.x. It is not a requirement for using PyOpenGL
+but performance without it will be poor.
+
+## The PyOpenGL it pairs with
+
+`PyOpenGL_accelerate` and `PyOpenGL` are released together, carry the same
+version number, and have to be equal. They share the dispatch extension's
+generated tables, where the slot numbering of one release is meaningless to
+another, so this package requires the exact `PyOpenGL` it was built against:
+
+    pip install PyOpenGL PyOpenGL_accelerate
+
+Installing or upgrading `PyOpenGL_accelerate` brings the matching `PyOpenGL`
+with it. Upgrading `PyOpenGL` on its own does not go the other way — it leaves
+the older accelerate installed — so name both packages when you upgrade either.
+A pair that has come apart is refused when the first entry point is built, in a
+message naming both versions; `PYOPENGL_USE_ACCELERATE=0` in the environment
+runs on ctypes until it is put right.
+
+## Build Process
+
+Cython is updated frequently to support newer versions of Python. As of
+release 3.1.9 we no longer check in the Cython generated code for the
+wrapper modules, relying on the build machines to generate the wrappers.
+
+The Github CI Pipeline should generate and release binary builds for most
+major platforms (Windows, Linux, Mac), but if you need to build from source,
+a `pip install .` **should** work from the PyOpenGL repository.

{pyopengl_accelerate-4.0.0a4 → pyopengl_accelerate-4.0.0a7}/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.0a4 → pyopengl_accelerate-4.0.0a7}/setup.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 """Builds accelleration functions for PyOpenGL
 """
-import sys
 from setuptools import setup, Extension
 
 try:
@@ -53,6 +52,43 @@ def pyopengl_requirement():
     return 'PyOpenGL==%s' % (_our_version(),)
 
 
+VERSION_HEADER = 'src/c/generated/pygl_version.h'
+
+
+def write_version_header():
+    """State the version in a header, and answer where it was written.
+
+    The extension reports at import which PyOpenGL its tables came from, so
+    that number has to reach the C.  A ``-D`` on the command line would too,
+    but a compiler driver's flags are not something the build compares against
+    an object file it already has: bump the version, and the existing
+    ``pygl_runtime.o`` is still newer than every source and header, so it is
+    linked as it stands and the new build announces the old version.  A header
+    is compared, being in ``depends``, so a bump recompiles what includes it.
+
+    Rewritten only when the contents change, so an unchanged version does not
+    invalidate the objects on every build.
+    """
+    path = os.path.join(HERE, VERSION_HEADER)
+    contents = (
+        '/* Written by accelerate\'s setup.py from OpenGL_accelerate.__version__.\n'
+        ' * The pair is released together and carries one number, so this is\n'
+        ' * the PyOpenGL whose generated tables this extension holds. */\n'
+        '#define PYOPENGL_VERSION "%s"\n' % (_our_version(),)
+    )
+    try:
+        with open(path, encoding='utf-8') as handle:
+            if handle.read() == contents:
+                return VERSION_HEADER
+    except OSError:
+        pass
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path + '.partial', 'w', encoding='utf-8') as handle:
+        handle.write(contents)
+    os.replace(path + '.partial', path)
+    return VERSION_HEADER
+
+
 def dispatch_extension():
     """The registry-generated C implementation of the OpenGL entry points.
 
@@ -94,18 +130,16 @@ def dispatch_extension():
         'src/c/pygl.h',
         'src/c/generated/pygl_elements.h',
         'src/c/generated/pygl_glgets.h',
+        # Says which PyOpenGL these tables were generated from, so that a
+        # mismatched pair is refused with a sentence rather than dispatching
+        # through the wrong slot indices.
+        write_version_header(),
     ]
     return [
         Extension(
             'OpenGL_accelerate.dispatch',
             sources=sources,
             include_dirs=['src/c', 'src/c/generated'],
-            # The extension states which PyOpenGL its tables were generated
-            # from, so that a mismatched pair is refused with a sentence rather
-            # than dispatching through the wrong slot indices.  The two are
-            # released together and carry the same number, so this is the
-            # accelerate version.
-            define_macros=[('PYOPENGL_VERSION', '"%s"' % (_our_version(),))],
             depends=[
                 path for path in headers if os.path.exists(os.path.join(HERE, path))
             ],
@@ -121,6 +155,59 @@ def dispatch_extension():
 extensions.extend(dispatch_extension())
 
 
+#: Where the toolchain the generated C was written against is recorded.
+TOOLCHAIN_STAMP = os.path.join(HERE, 'src', '.cython-toolchain')
+
+
+def _toolchain():
+    """Cython and numpy as the generated C sees them: version strings.
+
+    numpy is in here because these modules ``cimport numpy``, and what that
+    expands to is numpy's own declarations rather than anything in this
+    package.
+    """
+    from Cython import __version__ as cython_version
+
+    try:
+        from numpy import __version__ as numpy_version
+    except ImportError:                     # the numpy extension is skipped
+        numpy_version = 'none'
+    return 'cython %s\nnumpy %s\n' % (cython_version, numpy_version)
+
+
+def drop_c_from_another_toolchain():
+    """Delete generated C that a different Cython or numpy wrote.
+
+    ``cythonize`` decides whether to rewrite a ``.c`` by comparing it against
+    the ``.pyx`` and the ``.pxd`` files that ``.pyx`` cimports.  A
+    wheel-installed numpy carries the timestamps recorded in the wheel, so its
+    declarations can be years older than a ``.c`` generated from a *previous*
+    numpy last week -- and the stale C is then compiled against headers that no
+    longer match it.  What that reports is a compile error inside a numpy
+    internal, naming nothing in this package.
+
+    The generated C is not tracked by git and every ``.pyx`` beside it is
+    shipped, so it can always be written again.  Only with Cython installed:
+    an install from an sdist without one has the C and no way to make more.
+    """
+    import glob
+
+    if not have_cython:
+        return
+    wanted = _toolchain()
+    try:
+        with open(TOOLCHAIN_STAMP, encoding='utf-8') as handle:
+            if handle.read() == wanted:
+                return
+    except OSError:
+        pass
+    for path in glob.glob(os.path.join(HERE, 'src', '*.c')):
+        os.unlink(path)
+    with open(TOOLCHAIN_STAMP + '.partial', 'w', encoding='utf-8') as handle:
+        handle.write(wanted)
+    os.replace(TOOLCHAIN_STAMP + '.partial', TOOLCHAIN_STAMP)
+
+
 def cython_extension(
     name,
     include_dirs=(),
@@ -190,6 +277,10 @@ else:
 if (  # Prevents running of setup during code introspection imports
     __name__ == "__main__"
 ):
+    # Here rather than at module level: importing this file is how the suite
+    # and the packaging tools read what it declares, and an import that
+    # deleted generated C would make reading the declarations a build step.
+    drop_c_from_another_toolchain()
     # Workaround for Broken apple Python build params echoed in distutils
     # Approach taken from the PyMongo driver. OS-X Python builds were created with
     # non-existent flag, and distutils passes those flags to the extension

{pyopengl_accelerate-4.0.0a4 → pyopengl_accelerate-4.0.0a7}/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.0a4 → pyopengl_accelerate-4.0.0a7}/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 )