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

{pyopengl_accelerate-4.0.0a1 → pyopengl_accelerate-4.0.0a4}/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.0a1"
+__version__ = "4.0.0a4"
 __version_tuple__ = (4, 0, 0)

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

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

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

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

{pyopengl_accelerate-4.0.0a1 → pyopengl_accelerate-4.0.0a4}/PyOpenGL_accelerate.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ OpenGL_accelerate/wrapper.pxd
 PyOpenGL_accelerate.egg-info/PKG-INFO
 PyOpenGL_accelerate.egg-info/SOURCES.txt
 PyOpenGL_accelerate.egg-info/dependency_links.txt
+PyOpenGL_accelerate.egg-info/requires.txt
 PyOpenGL_accelerate.egg-info/top_level.txt
 src/arraydatatype.pyx
 src/buffers_formathandler.pyx
@@ -20,5 +21,17 @@ src/nones_formathandler.pyx
 src/numpy_formathandler.pyx
 src/vbo.pyx
 src/wrapper.pyx
+src/c/pygl_handwritten.c
+src/c/pygl_runtime.c
+src/c/generated/pygl_EGL.c
+src/c/generated/pygl_GL.c
+src/c/generated/pygl_GLES1.c
+src/c/generated/pygl_GLES2.c
+src/c/generated/pygl_GLES3.c
+src/c/generated/pygl_GLSC2.c
+src/c/generated/pygl_GLX.c
+src/c/generated/pygl_WGL.c
+src/c/generated/pygl_generated.c
+src/c/generated/pygl_modules.c
 tests/test_arraydatatypeaccel.py
 tests/test_numpyaccel.py

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

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

{pyopengl_accelerate-4.0.0a1 → pyopengl_accelerate-4.0.0a4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name="PyOpenGL-accelerate"
-dynamic=["version"]
+dynamic=["version", "dependencies"]
 description = "Cython-coded accelerators for PyOpenGL"
 authors = [
     {name="Mike C. Fletcher",email="mcfletch@vrplumber.com"},
@@ -47,9 +47,26 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools.dynamic]
 version = {attr = "OpenGL_accelerate.__version__"}
+# The dependency on PyOpenGL is an exact pin on this package's own version, so
+# setup.py builds it from the one number rather than a second copy living here
+# to drift -- see pyopengl_requirement().
 
 [tool.setuptools.packages.find]
 namespaces=false
 include=["OpenGL_accelerate"]
 exclude=["tests","src"]
 
+# uv decides whether its cached metadata for a source tree is still current
+# from pyproject.toml, setup.py and setup.cfg alone. This project's version
+# lives in OpenGL_accelerate/__init__.py, so name that file too: without it a
+# version bump leaves uv answering with the previous number, and a dependent
+# requiring the new one resolves against PyPI rather than this checkout.
+[tool.uv]
+# setup.py too: the dependency on PyOpenGL is built there, from the version
+# in OpenGL_accelerate/__init__.py, so both files decide this package's
+# metadata and a change to either has to invalidate the cached answer.
+cache-keys = [
+    { file = "pyproject.toml" },
+    { file = "setup.py" },
+    { file = "OpenGL_accelerate/__init__.py" },
+]

pyopengl_accelerate-4.0.0a4/setup.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python
+"""Builds accelleration functions for PyOpenGL
+"""
+import sys
+from setuptools import setup, Extension
+
+try:
+    from Cython.Distutils import build_ext
+except ImportError:
+    have_cython = False
+    build_ext = False
+else:
+    have_cython = True
+
+import sys, os
+
+HERE = os.path.normpath(os.path.abspath(os.path.dirname(__file__)))
+
+extensions = []
+
+
+def _our_version():
+    """This package's version, read without importing it.
+
+    Importing ``OpenGL_accelerate`` during its own build would need the
+    extensions that are not built yet, so the assignment is read out of the
+    source the way the build backend reads it.
+    """
+    import re
+
+    with open(
+        os.path.join(HERE, 'OpenGL_accelerate', '__init__.py'), encoding='utf-8'
+    ) as handle:
+        source = handle.read()
+    found = re.search(r'^__version__\s*=\s*["\']([^"\']+)["\']', source, re.M)
+    if not found:
+        raise RuntimeError('OpenGL_accelerate/__init__.py states no __version__')
+    return found.group(1)
+
+
+def pyopengl_requirement():
+    """The PyOpenGL this accelerate pairs with, as a requirement string.
+
+    Exact, because the two are released together from one repository and the
+    dispatch extension's tables are generated from that PyOpenGL: a mismatched
+    pair does not degrade, it dispatches through the wrong slot indices.
+    ``OpenGL._dispatch`` refuses one at import; this stops pip assembling one
+    in the first place, which is a better place to learn it than the first
+    entry point a program calls.
+
+    Read from this package's own version so there is one number to bump.
+    """
+    return 'PyOpenGL==%s' % (_our_version(),)
+
+
+def dispatch_extension():
+    """The registry-generated C implementation of the OpenGL entry points.
+
+    It lives here rather than in ``pyopengl`` so that ``pyopengl`` stays a
+    single universal wheel: the C is what needs a compiler and a wheel per
+    platform, and this package is already the optional compiled companion.
+    "Is the fast path available?" is then the question it has always been --
+    is accelerate installed?
+
+    Both packages are released together from one repository, and the two
+    share generated tables, so the versions must match exactly; the module
+    checks that at import.
+    """
+    import glob
+
+    if os.environ.get('PYOPENGL_NO_C_DISPATCH'):
+        return []
+    if sys.implementation.name != 'cpython':
+        # The extension reaches CPython's vectorcall protocol directly.  On
+        # PyPy it would compile, import, and route every call through an
+        # emulated vectorcall across the cpyext boundary -- the slowest path
+        # available, chosen by default, on the interpreter the ctypes
+        # implementation exists to serve.
+        return []
+    generated = os.path.join(HERE, 'src', 'c', 'generated')
+    sources = sorted(
+        os.path.relpath(path, HERE).replace(os.sep, '/')
+        for path in glob.glob(os.path.join(generated, '*.c'))
+    )
+    if not sources:
+        return []
+    sources.insert(0, 'src/c/pygl_handwritten.c')
+    sources.insert(0, 'src/c/pygl_runtime.c')
+    # setuptools does not work out header dependencies, so a change to pygl.h
+    # would otherwise leave the generated objects stale and the build mixed:
+    # objects compiled against one version of a macro linked with a runtime
+    # compiled against another.
+    headers = [
+        'src/c/pygl.h',
+        'src/c/generated/pygl_elements.h',
+        'src/c/generated/pygl_glgets.h',
+    ]
+    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))
+            ],
+            # Optional so a source install without a compiler still yields a
+            # working accelerate; PyOpenGL falls back to ctypes on its own.
+            # Set PYOPENGL_REQUIRE_C_DISPATCH=1 while working on it, or a
+            # compile error is a warning and the stale object is kept.
+            optional=not os.environ.get('PYOPENGL_REQUIRE_C_DISPATCH'),
+        )
+    ]
+
+
+extensions.extend(dispatch_extension())
+
+
+def cython_extension(
+    name,
+    include_dirs=(),
+):
+    """Create a cython extension object"""
+    filenames = "%(name)s.c" % locals(), "%(name)s.pyx" % locals()
+    filename = filenames[bool(have_cython)]
+    return Extension(
+        "OpenGL_accelerate.%(name)s" % locals(),
+        [
+            os.path.join("src", filename),
+        ],
+        include_dirs=[
+            os.path.join(HERE, "src"),
+            HERE,
+        ]
+        + list(include_dirs),
+        define_macros=[
+            ('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION'),
+        ],
+        compiler_directives={'language_level': "3"} if have_cython else {},
+    )
+
+
+extensions.extend(
+    [
+        cython_extension("wrapper"),
+        cython_extension("formathandler"),
+        cython_extension("arraydatatype"),
+        cython_extension("errorchecker"),
+        cython_extension("vbo"),
+        cython_extension("nones_formathandler"),
+        cython_extension("latebind"),
+    ]
+)
+if sys.version_info[:2] >= (2, 7):
+    extensions.extend(
+        [
+            cython_extension("buffers_formathandler"),
+        ]
+    )
+
+try:
+    import numpy
+except ImportError:
+    sys.stderr.write("""Unable to import numpy, skipping numpy extension building\n""")
+else:
+    if hasattr(numpy, "get_include"):
+        includeDirectories = [
+            numpy.get_include(),
+        ]
+    else:
+        includeDirectories = [
+            os.path.join(
+                os.path.dirname(numpy.__file__),
+                "core",
+                "include",
+            ),
+        ]
+    extensions.append(
+        cython_extension(
+            "numpy_formathandler",
+            includeDirectories,
+        )
+    )
+
+if (  # Prevents running of setup during code introspection imports
+    __name__ == "__main__"
+):
+    # 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
+    # build, newer clangs now treat those flags as errors rather than warnings.
+    import platform, sys
+
+    if sys.platform == "darwin" and "clang" in platform.python_compiler().lower():
+        from distutils.sysconfig import get_config_vars
+
+        res = get_config_vars()
+        for key in ("CFLAGS", "PY_CFLAGS"):
+            if key in res:
+                res[key] = res[key].replace("-mno-fused-madd", "")
+
+    extraArguments = {}
+    ### Now the actual set up call
+    if have_cython:
+        extraArguments["cmdclass"] = {
+            "build_ext": build_ext,
+        }
+    setup(
+        build_requires=['cython'],
+        install_requires=[pyopengl_requirement()],
+        options={
+            "sdist": {
+                "formats": ["gztar"],
+                "force_manifest": True,
+            },
+        },
+        ext_modules=extensions,
+        **extraArguments
+    )

{pyopengl_accelerate-4.0.0a1 → pyopengl_accelerate-4.0.0a4}/src/arraydatatype.pyx

@@ -303,6 +303,13 @@ cdef class Output(cArgConverter):
         never reaches the caller's array -- the silent "returns zeroes" bug.
         Detect the shrinking copy and raise. Correctly-typed arrays are not
         copied, so they never trip this.
+
+        Then the other question, which the count answers: an array shorter than
+        the call will write into is a heap overrun rather than an exception, so
+        it is refused. See ``Output.checkOutputSize`` in OpenGL/converters.py,
+        which is the same check for the pure-Python converter -- this one is
+        what runs where accelerate is installed, whichever dispatch layer the
+        entry points come from.
         """
         value = pyArgs[index]
         result = self.arrayType.asArray( value )
@@ -311,7 +318,10 @@ cdef class Output(cArgConverter):
                 rbytes = self.arrayType.arrayByteCount( result )
                 vbytes = self.arrayType.arrayByteCount( value )
             except Exception:
-                return result
+                # Not measurable -- a list has no byte count of its own -- so
+                # there is no shrinking coercion to detect. The size the call
+                # will write is still checked below.
+                rbytes = vbytes = 0
             if rbytes < vbytes:
                 raise TypeError(
                     '%s: pass-in output array was coerced to a smaller buffer '
@@ -319,8 +329,62 @@ cdef class Output(cArgConverter):
                     'into your array. Pass a correctly-typed array, or None to '
                     'have one allocated.' % ( self.name, rbytes, vbytes )
                 )
+        self.c_checkOutputSize( result, pyArgs )
         return result
 
+    cdef int c_checkOutputSize( self, object array, tuple pyArgs ) except -1:
+        """Nothing to check: a fixed declared size is a maximum.
+
+        Which of it a call fills depends on the pname -- glGetVertexAttribiv
+        declares four and writes one for most of them -- so a shorter array is
+        legitimate here.  :class:`SizedOutput` overrides this, because its size
+        is a count the caller passed and so says what will be written.
+        """
+        return 0
+
+    cdef int c_checkPromisedSize( self, object array, tuple pyArgs ) except -1:
+        """Refuse an output array smaller than the call will write into it.
+
+        Only a shortfall: a larger array is a caller deliberately reusing one
+        buffer for several calls, which is ordinary and safe.
+        """
+        cdef long wanted = 1
+        try:
+            shape = self.c_getSize( pyArgs )
+        except Exception:
+            return 0
+        if shape is None:
+            return 0
+        for dimension in shape:
+            try:
+                wanted = wanted * int(dimension)
+            except (TypeError, ValueError):
+                return 0
+        if wanted <= 0:
+            return 0
+        # Compared in bytes, not elements.  The count is in units of the type
+        # the *declaration* names -- glGetBufferSubData's `size` is a byte
+        # count, glGenTextures' `n` is a count of GLuint -- and the caller may
+        # pass an array of some other type holding the same bytes.
+        # Only what carries its own length.  A bare ctypes pointer does not --
+        # the hand-written wrappers in OpenGL/GL/exceptional.py pass
+        # `typedPointer` results straight down -- and arrayByteCount answers
+        # for one anyway, with the size of a single element.
+        if not hasattr( array, '__len__' ):
+            return 0
+        try:
+            wanted_bytes = wanted * ctypes.sizeof( self.arrayType.baseType )
+            held_bytes = self.arrayType.arrayByteCount( array )
+        except Exception:
+            return 0
+        if held_bytes < wanted_bytes:
+            raise ValueError(
+                '%s: output array holds %d byte(s), but the call will '
+                'write %d. Pass a larger array, or None to have one '
+                'allocated.' % ( self.name, held_bytes, wanted_bytes )
+            )
+        return 0
+
     def oldStyleReturn( self, object result, object baseOperation, tuple pyArgs, tuple cArgs ):
         """Retrieve cArgs[ self.index ]"""
         #TODO: make this a c_api-bearing value, not a Python function call
@@ -362,6 +426,24 @@ cdef class SizedOutput( Output ):
     def finalise( self, wrapper ):
         super( SizedOutput,self).finalise( wrapper )
         self.index = wrapper.pyArgIndex( self.specifier )
+    cdef int c_checkOutputSize( self, object array, tuple pyArgs ) except -1:
+        """Check the size only where it says what this call will write.
+
+        It does when it comes from a *count* the caller passed --
+        glGenTextures(n, names) writes n, glGetBufferSubData writes `size`
+        bytes -- which the declaration spells `size=lambda x: (x,)`.
+
+        It does not when it comes from a table keyed on a *pname*, which says
+        how large that piece of state is in total; how much of it a call fills
+        is the call's business, and glGetIntegeri_v writes one element of a
+        three-element pname at a time.  The declaration spells that
+        `size=<a dict>`, handed on as its `__getitem__` -- so the dict it is
+        bound to is what tells the two apart.
+        """
+        if isinstance( getattr( self.lookup, '__self__', None ), dict ):
+            return 0
+        return self.c_checkPromisedSize( array, pyArgs )
+
     cdef tuple c_getSize( self, tuple pyArgs ):
         """Retrieve the array size for this argument"""
         try: