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

{pyopengl_accelerate-4.0.0a4 → pyopengl_accelerate-4.0.0a5}/OpenGL_accelerate/__init__.py

@@ -7,5 +7,5 @@ PyOpenGL package and is built via the setupaccel.py
 script in the top level of the PyOpenGL source package.
 """
 
-__version__ = "4.0.0a4"
+__version__ = "4.0.0a5"
 __version_tuple__ = (4, 0, 0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a4
+Version: 4.0.0a5
 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.0a5
 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.0a5}/PyOpenGL_accelerate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a4
+Version: 4.0.0a5
 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.0a5
 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.0a5/PyOpenGL_accelerate.egg-info/requires.txt

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

pyopengl_accelerate-4.0.0a5/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.0a5}/setup.py

@@ -53,6 +53,42 @@ 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, 'w', encoding='utf-8') as handle:
+        handle.write(contents)
+    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,58 @@ 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, 'w', encoding='utf-8') as handle:
+        handle.write(wanted)
+
+
 def cython_extension(
     name,
     include_dirs=(),
@@ -190,6 +276,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.0a5}/src/c/pygl_runtime.c

@@ -2864,10 +2864,15 @@ static int pygl_init_errors(void)
     return (pygl_null_function_error && pygl_no_context_error) ? 0 : -1;
 }
 
-/* The PyOpenGL version this extension's tables were generated from, supplied by
- * accelerate's setup.py.  Absent only in a build that has not been told, and a
- * build that cannot say which tables it holds is not one to dispatch through --
- * see OpenGL._dispatch._versions_match. */
+/* The PyOpenGL version this extension's tables were generated from, written by
+ * accelerate's setup.py into generated/pygl_version.h.  A build that cannot say
+ * which tables it holds is not one to dispatch through, so an absent header
+ * leaves a version nothing matches -- see OpenGL._dispatch._versions_match. */
+#if defined(__has_include)
+#  if __has_include("generated/pygl_version.h")
+#    include "generated/pygl_version.h"
+#  endif
+#endif
 #ifndef PYOPENGL_VERSION
 #define PYOPENGL_VERSION "unknown"
 #endif

{pyopengl_accelerate-4.0.0a4 → pyopengl_accelerate-4.0.0a5}/src/vbo.pyx

@@ -2,7 +2,7 @@
 #cython: language_level=3
 import ctypes, weakref
 from OpenGL_accelerate.formathandler cimport FormatHandler
-from OpenGL import error
+from OpenGL import dispatch, error
 from OpenGL._bytes import bytes,unicode
 try:
     long = long
@@ -201,7 +201,11 @@ cdef class VBO:
         self.get_implementation()._DELETERS_[ id(self) ] = weakref.ref(
             # Cython instances can't have weakrefs, sigh...
             self,
-            self.get_implementation().deleter( [self.buffer], id(self) )
+            # With the context the buffer was made in, which is the only one
+            # its name means this buffer in; see OpenGL.arrays.vbo.
+            self.get_implementation().deleter(
+                [self.buffer], id(self), dispatch.context_identity()
+            )
         )
         return self.buffer
     def copy_data( self ):

{pyopengl_accelerate-4.0.0a4 → pyopengl_accelerate-4.0.0a5}/tests/test_arraydatatypeaccel.py

@@ -95,20 +95,29 @@ class TestNumpy( _BaseTest, unittest.TestCase ):
         z = self.handler.zeros( (0,), GL.GL_BYTE )
         assert z.dtype == numpy.byte, z
 
+def two_rows_of_three():
+    """Six floats in memory a VBO can be made from without a copy.
+
+    Where there is no numpy the array is built and filled rather than
+    converted from a list: converting one *is* the copy ERROR_ON_COPY refuses,
+    and what these cases are about is the VBO handler rather than the way the
+    array beside it was made.
+    """
+    if numpy:
+        return numpy.array( [[1,2,3],[4,5,6]], 'f' )
+    array = adt.GLfloatArray.zeros( (2,3) )
+    array[0][:] = (1.0,2.0,3.0)
+    array[1][:] = (4.0,5.0,6.0)
+    return array
+
 class TestVBO( _BaseTest, unittest.TestCase ):
     def setUp( self ):
-        if numpy:
-            self.array = vbo.VBO(numpy.array( [[1,2,3],[4,5,6]],'f'))
-        else:
-            self.array = vbo.VBO(adt.GLfloatArray.asArray([[1,2,3],[4,5,6]]))
+        self.array = vbo.VBO(two_rows_of_three())
         super(TestVBO,self).setUp()
 
 class TestVBOOffset( _BaseTest, unittest.TestCase ):
     def setUp( self ):
-        if numpy:
-            self.array = vbo.VBO(numpy.array( [[1,2,3],[4,5,6]],'f')) + 12
-        else:
-            self.array = vbo.VBO(adt.GLfloatArray.asArray([[1,2,3],[4,5,6]])) + 12
+        self.array = vbo.VBO(two_rows_of_three()) + 12
         super(TestVBOOffset,self).setUp()
         
 class TestNones( unittest.TestCase ):

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

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

pyopengl_accelerate-4.0.0a4/README.md

@@ -1,15 +0,0 @@
-# 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.
-
-## 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.