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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL-accelerate
-Version: 4.0.0a1
+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,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.0a5
 Dynamic: download-url
 Dynamic: license-file
+Dynamic: requires-dist
 
 # Acceleration code for PyOpenGL
 
@@ -33,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.0a1 → 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.0a1
+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,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.0a5
 Dynamic: download-url
 Dynamic: license-file
+Dynamic: requires-dist
 
 # Acceleration code for PyOpenGL
 
@@ -33,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.0a1 → pyopengl_accelerate-4.0.0a5}/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.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.0a1 → pyopengl_accelerate-4.0.0a5}/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.0a5/setup.py

@@ -0,0 +1,314 @@
+#!/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(),)
+
+
+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.
+
+    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',
+        # 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'],
+            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())
+
+
+#: 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=(),
+):
+    """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__"
+):
+    # 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
+    # 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.0a5}/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: