PyOpenGL-accelerate 3.1.6__tar.gz → 3.1.9__tar.gz

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/OpenGL_accelerate/__init__.py

@@ -6,5 +6,6 @@ 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.
 """
-__version__ = '3.1.6'
-__version_tuple__ = (3,1,6)
+
+__version__ = "3.1.9"
+__version_tuple__ = (3, 1, 9)

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/OpenGL_accelerate/formathandler.pxd

@@ -1,4 +1,5 @@
 """Cython import description for formathandler types"""
+#cython: language_level=3
 
 cdef class FormatHandler:
 	cdef public int ERROR_ON_COPY

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/OpenGL_accelerate/wrapper.pxd

@@ -1,4 +1,6 @@
 """Importable Cython declarations for wrapper module"""
+#cython: language_level=3
+
 cdef class cArgConverter:
 	cdef object c_call( self, tuple pyArgs, int index, object baseOperation )
 cdef class pyArgConverter:

pyopengl_accelerate-3.1.9/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.2
+Name: PyOpenGL-accelerate
+Version: 3.1.9
+Summary: Cython-coded accelerators for PyOpenGL
+Home-page: http://pyopengl.sourceforge.net
+Download-URL: http://sourceforge.net/project/showfiles.php?group_id=5988
+Author: Mike C. Fletcher
+Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
+License: NOTE:
+        
+        	THIS SOFTWARE IS NOT FAULT TOLERANT AND SHOULD NOT BE USED IN ANY
+        	SITUATION ENDANGERING HUMAN LIFE OR PROPERTY.
+        	
+        OpenGL-ctypes PyOpenGL-accelerate License
+        
+        	Copyright (c) 2005-2009, Michael C. Fletcher and Contributors
+        	All rights reserved.
+        	
+        	Redistribution and use in source and binary forms, with or without
+        	modification, are permitted provided that the following conditions
+        	are met:
+        	
+        		Redistributions of source code must retain the above copyright
+        		notice, this list of conditions and the following disclaimer.
+        	
+        		Redistributions in binary form must reproduce the above
+        		copyright notice, this list of conditions and the following
+        		disclaimer in the documentation and/or other materials
+        		provided with the distribution.
+        	
+        		The name of Michael C. Fletcher, or the name of any Contributor,
+        		may not be used to endorse or promote products derived from this 
+        		software without specific prior written permission.
+        	
+        	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        	``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+        	FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+        	COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+        	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+        	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+        	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+        	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+        	OF THE POSSIBILITY OF SUCH DAMAGE. 
+        
+        
+        
+Project-URL: Homepage, https://mcfletch.github.io/pyopengl/
+Project-URL: Download, https://pypi.org/project/PyOpenGL-accelerate/
+Project-URL: Source, https://github.com/mcfletch/pyopengl
+Project-URL: Documentation, https://mcfletch.github.io/pyopengl/documentation/index.html
+Keywords: Graphics,3D,OpenGL,GLU,GLUT,GLE,GLX,EXT,ARB,Mesa,PyOpenGL
+Platform: Win32
+Platform: Linux
+Platform: OS-X
+Platform: Posix
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Description-Content-Type: text/markdown
+Dynamic: download-url
+
+# 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.

pyopengl_accelerate-3.1.9/PyOpenGL_accelerate.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.2
+Name: PyOpenGL-accelerate
+Version: 3.1.9
+Summary: Cython-coded accelerators for PyOpenGL
+Home-page: http://pyopengl.sourceforge.net
+Download-URL: http://sourceforge.net/project/showfiles.php?group_id=5988
+Author: Mike C. Fletcher
+Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
+License: NOTE:
+        
+        	THIS SOFTWARE IS NOT FAULT TOLERANT AND SHOULD NOT BE USED IN ANY
+        	SITUATION ENDANGERING HUMAN LIFE OR PROPERTY.
+        	
+        OpenGL-ctypes PyOpenGL-accelerate License
+        
+        	Copyright (c) 2005-2009, Michael C. Fletcher and Contributors
+        	All rights reserved.
+        	
+        	Redistribution and use in source and binary forms, with or without
+        	modification, are permitted provided that the following conditions
+        	are met:
+        	
+        		Redistributions of source code must retain the above copyright
+        		notice, this list of conditions and the following disclaimer.
+        	
+        		Redistributions in binary form must reproduce the above
+        		copyright notice, this list of conditions and the following
+        		disclaimer in the documentation and/or other materials
+        		provided with the distribution.
+        	
+        		The name of Michael C. Fletcher, or the name of any Contributor,
+        		may not be used to endorse or promote products derived from this 
+        		software without specific prior written permission.
+        	
+        	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        	``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+        	FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+        	COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+        	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+        	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+        	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+        	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+        	OF THE POSSIBILITY OF SUCH DAMAGE. 
+        
+        
+        
+Project-URL: Homepage, https://mcfletch.github.io/pyopengl/
+Project-URL: Download, https://pypi.org/project/PyOpenGL-accelerate/
+Project-URL: Source, https://github.com/mcfletch/pyopengl
+Project-URL: Documentation, https://mcfletch.github.io/pyopengl/documentation/index.html
+Keywords: Graphics,3D,OpenGL,GLU,GLUT,GLE,GLX,EXT,ARB,Mesa,PyOpenGL
+Platform: Win32
+Platform: Linux
+Platform: OS-X
+Platform: Posix
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Description-Content-Type: text/markdown
+Dynamic: download-url
+
+# 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.

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/PyOpenGL_accelerate.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
 MANIFEST.in
-README.txt
+README.md
 license.txt
+pyproject.toml
+setup.cfg
 setup.py
 OpenGL_accelerate/__init__.py
 OpenGL_accelerate/formathandler.pxd
@@ -9,21 +11,14 @@ PyOpenGL_accelerate.egg-info/PKG-INFO
 PyOpenGL_accelerate.egg-info/SOURCES.txt
 PyOpenGL_accelerate.egg-info/dependency_links.txt
 PyOpenGL_accelerate.egg-info/top_level.txt
-src/arraydatatype.c
 src/arraydatatype.pyx
-src/buffers_formathandler.c
 src/buffers_formathandler.pyx
-src/errorchecker.c
 src/errorchecker.pyx
-src/formathandler.c
 src/formathandler.pyx
-src/latebind.c
 src/latebind.pyx
-src/nones_formathandler.c
 src/nones_formathandler.pyx
-src/numpy_formathandler.c
 src/numpy_formathandler.pyx
-src/vbo.c
 src/vbo.pyx
-src/wrapper.c
-src/wrapper.pyx
+src/wrapper.pyx
+tests/test_arraydatatypeaccel.py
+tests/test_numpyaccel.py

pyopengl_accelerate-3.1.9/README.md

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

pyopengl_accelerate-3.1.9/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name="PyOpenGL-accelerate"
+dynamic=["version"]
+description = "Cython-coded accelerators for PyOpenGL"
+authors = [
+    {name="Mike C. Fletcher",email="mcfletch@vrplumber.com"},
+]
+readme = {file="README.md", content-type = "text/markdown"}
+license={file="license.txt"}
+keywords = [
+    "Graphics",
+    "3D",
+    "OpenGL",
+    "GLU",
+    "GLUT",
+    "GLE",
+    "GLX",
+    "EXT",
+    "ARB",
+    "Mesa",
+    "PyOpenGL",
+]
+classifiers = [
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 2",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Graphics :: 3D Rendering",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Intended Audience :: Developers",
+]
+[project.urls]
+Homepage = "https://mcfletch.github.io/pyopengl/"
+Download = "https://pypi.org/project/PyOpenGL-accelerate/"
+Source = "https://github.com/mcfletch/pyopengl"
+Documentation = "https://mcfletch.github.io/pyopengl/documentation/index.html"
+
+[build-system]
+requires = [ "setuptools >= 42.0", "Cython >= 0.28", "numpy" ]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = {attr = "OpenGL_accelerate.__version__"}
+
+[tool.setuptools.packages.find]
+namespaces=false
+include=["OpenGL_accelerate"]
+exclude=["tests","src"]
+

pyopengl_accelerate-3.1.9/setup.cfg

@@ -0,0 +1,29 @@
+[metadata]
+name = PyOpenGL-accelerate
+version = attr: OpenGL_accelerate.__init__.__version__
+description = Acceleration code for PyOpenGL
+author = Mike C. Fletcher
+author_email = mcfletch@vrplumber.com
+url = http://pyopengl.sourceforge.net
+download_url = http://sourceforge.net/project/showfiles.php?group_id=5988
+license = BSD
+long_description = file: README.txt
+long_description_content_type = text/plain
+keywords = PyOpenGL, accelerate, Cython
+platforms = Win32, Linux, OS-X, Posix
+classifiers = 
+	License :: OSI Approved :: BSD License
+	Programming Language :: Python
+	Programming Language :: Python :: 3
+	Programming Language :: C
+	Topic :: Software Development :: Libraries :: Python Modules
+	Topic :: Multimedia :: Graphics :: 3D Rendering
+	Intended Audience :: Developers
+
+[options]
+packages = OpenGL_accelerate
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyopengl_accelerate-3.1.9/setup.py

@@ -0,0 +1,121 @@
+#!/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 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'],
+        options={
+            "sdist": {
+                "formats": ["gztar"],
+                "force_manifest": True,
+            },
+        },
+        ext_modules=extensions,
+        **extraArguments
+    )

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/arraydatatype.pyx

@@ -1,4 +1,6 @@
 """Cython-coded Array-handling accelerator module"""
+#cython: language_level=3
+
 import ctypes
 import OpenGL
 from OpenGL._null import NULL as _NULL

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/buffers_formathandler.pyx

@@ -1,4 +1,6 @@
 """Cython memoryview implementation of buffer-api format handler"""
+#cython: language_level=3
+
 from ctypes import c_void_p
 from OpenGL_accelerate.formathandler cimport FormatHandler
 import traceback, weakref

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/errorchecker.pyx

@@ -1,4 +1,5 @@
 """Cython-coded GL-error-check module"""
+#cython: language_level=3
 from OpenGL import _configflags
 
 cdef class _ErrorChecker:

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/formathandler.pyx

@@ -1,4 +1,5 @@
 """Cython-coded base FormatHandler implementation"""
+#cython: language_level=3
 
 cdef class FormatHandler:
 	"""PyOpenGL "Format" plugin implementation

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/latebind.pyx

@@ -1,4 +1,5 @@
 """General pattern which does late-bound calls"""
+#cython: language_level=3
 
 cdef class LateBind:
     """Provides a __call__ which dispatches to self._finalCall

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/nones_formathandler.pyx

@@ -1,4 +1,5 @@
 """Accelerator for None-as-an-array format handler operations"""
+#cython: language_level=3
 from OpenGL_accelerate.formathandler cimport FormatHandler
 
 cdef class NoneHandler(FormatHandler):

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/numpy_formathandler.pyx

@@ -1,4 +1,5 @@
 """Accelerator for numpy format handler operations"""
+#cython: language_level=3
 from ctypes import c_void_p
 import numpy as np
 cimport numpy as np
@@ -19,9 +20,9 @@ cdef extern from "numpy/arrayobject.h":
     int NPY_ARRAY_FORCECAST
     int PyArray_ISCARRAY( np.ndarray instance )
     int PyArray_ISCARRAY_RO( np.ndarray instance )
-    cdef np.ndarray PyArray_Zeros(int nd, np.Py_intptr_t* dims, np.dtype, int fortran)
+    cdef np.ndarray PyArray_Zeros(int nd, np.npy_intp* dims, np.dtype, int fortran)
     cdef np.ndarray PyArray_EnsureArray(object)
-    cdef int PyArray_FillWithScalar(object, object)
+    cdef int PyArray_FillWithScalar(np.ndarray, object)
     cdef void import_array()
     cdef void* PyArray_DATA( np.ndarray )
     cdef int PyArray_NDIM( np.ndarray )
@@ -121,7 +122,7 @@ cdef class NumpyHandler(FormatHandler):
             c_dims = PyArray_ContiguousFromAny( 
                 [int(x) for x in dims], np.NPY_INTP, 1,1 
             )
-        except (ValueError,TypeError), err:
+        except (ValueError,TypeError) as err:
             dims = (int(dims),)
             c_dims = PyArray_ContiguousFromAny( 
                 dims, np.NPY_INTP, 1,1 
@@ -157,7 +158,7 @@ cdef class NumpyHandler(FormatHandler):
         if PyArray_CheckScalar(instance):
             Py_INCREF(instance)
             working = self.c_zeros((1,), typeCode)
-            res = PyArray_FillWithScalar(<object>working, instance)
+            res = PyArray_FillWithScalar(working, instance)
             if res < -1:
                 raise ValueError("Unable to fill new array with value %r (%s)"%(instance,instance.__class__))
         else:
@@ -226,4 +227,4 @@ cdef class NumpyHandler(FormatHandler):
 
 # Cython numpy tutorial neglects to mention this AFAICS
 # get segfaults without it
-import_array()
+# import_array()

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/vbo.pyx

@@ -1,4 +1,5 @@
 """Cython-coded VBO implementation"""
+#cython: language_level=3
 import ctypes, weakref
 from OpenGL_accelerate.formathandler cimport FormatHandler
 from OpenGL import error
@@ -137,7 +138,7 @@ cdef class VBO:
         is concerned).
         """
         if slice.step and not slice.step == 1:
-            raise NotImplemented( """Don't know how to map stepped arrays yet""" )
+            raise NotImplementedError( """Don't know how to map stepped arrays yet""" )
         # TODO: handle e.g. mapping character data into an integer data-set
         data = self.arrayType.asArray( array )
         start = (slice.start or 0)
@@ -188,7 +189,7 @@ cdef class VBO:
         buffers = self.get_implementation().glGenBuffers(1)
         try:
             self.buffer = long( buffers )
-        except (TypeError,ValueError), err:
+        except (TypeError,ValueError) as err:
             self.buffer = buffers[0]
         self.target = self.c_resolve( self.target_spec )
         self.usage = self.c_resolve( self.usage_spec )
@@ -222,11 +223,11 @@ cdef class VBO:
             self.created = False
             try:
                 self.get_implementation().glDeleteBuffers(1, ctypes.c_uint32( self.buffer))
-            except (AttributeError, error.NullFunctionError), err:
+            except (AttributeError, error.NullFunctionError) as err:
                 pass
             try:
                 self.get_implementation()._DELETERS_.pop( id(self))
-            except KeyError, err:
+            except KeyError as err:
                 pass
     def bind( self ):
         """Bind this buffer for use in vertex calls"""

{PyOpenGL-accelerate-3.1.6 → pyopengl_accelerate-3.1.9}/src/wrapper.pyx

@@ -1,4 +1,5 @@
 """Cython-coded implementation of wrapper module"""
+#cython: language_level=3
 import ctypes
 from OpenGL import error
 from OpenGL._null import NULL as _NULL
@@ -64,7 +65,7 @@ cdef class CArgCalculatorElement:
                 return self.c_converter.c_call( pyArgs, self.index, self.wrapper )
             elif self.callable:
                 return self.converter.__call__( pyArgs, self.index, self.wrapper )
-        except Exception, err:
+        except Exception as err:
             err.args += ( self.index, self.wrapper )
             raise
         return self.converter
@@ -122,7 +123,7 @@ cdef class PyArgCalculatorElement:
                 return self.converter( 
                     args[self.index], self.wrapper, args 
                 )
-        except Exception, err:
+        except Exception as err:
             if hasattr( err, 'args' ):
                 err.args += ( self.converter, )
             raise
@@ -190,13 +191,13 @@ cdef class CArgumentCalculator:
                 # heavy operation.
                 try:
                     result[i] = (<cArgumentConverter>converter).c_call( cArgs[i] )
-                except Exception, err:
+                except Exception as err:
                     err.args += (converter,)
                     raise
             else:
                 try:
                     result[i] = converter( cArgs[i] )
-                except Exception, err:
+                except Exception as err:
                     err.args += (converter,)
                     raise
         return result
@@ -224,7 +225,7 @@ cdef class DefaultCConverter(cArgConverter):
     cdef object c_call( self, tuple pyArgs, int index, object baseOperation ):
         try:
             return pyArgs[ self.index ]
-        except IndexError, err:
+        except IndexError as err:
             raise ValueError(
                 """Expected parameter index %r, but pyArgs only length %s"""%(
                 self.index,
@@ -309,10 +310,10 @@ cdef class Wrapper:
             cArguments = cArgs
         try:
             result = self.wrappedOperation( *cArguments )
-        except (ctypes.ArgumentError,TypeError,AttributeError), err:
+        except (ctypes.ArgumentError,TypeError,AttributeError) as err:
             err.args = err.args + (cArguments,)
             raise err
-        except error.GLError, err:
+        except error.GLError as err:
             err.cArgs = cArgs 
             err.pyArgs = pyArgs
             raise err