- Drop test_numpyaccel.py and test_arraydatatypeaccel.py as they are

already included in the downloaded tarball

OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-opengl-accelerate?expand=0&rev=21

python-opengl-accelerate.changes

@@ -1,3 +1,9 @@
+-------------------------------------------------------------------
+Thu Jan  4 08:33:49 UTC 2024 - Markéta Machová <mmachova@suse.com>
+
+- Drop test_numpyaccel.py and test_arraydatatypeaccel.py as they are
+  already included in the downloaded tarball
+
 -------------------------------------------------------------------
 Wed Jan  3 16:22:55 UTC 2024 - Scott Bradnick <scott.bradnick@suse.com>
 

python-opengl-accelerate.spec

@@ -16,9 +16,9 @@
 #
 
 
-#%%{?!python_module:%%define python_module() python-%%{**} python3-%%{**}}
 %define tarname PyOpenGL-accelerate
 %define _version 3.1.7
+%{?sle15_python_module_pythons}
 Name:           python-opengl-accelerate
 Version:        %{_version}
 Release:        0
@@ -27,12 +27,6 @@ License:        BSD-3-Clause
 Group:          Development/Libraries/Python
 URL:            http://pyopengl.sourceforge.net
 Source0:        %{tarname}-%{_version}.tar.gz
-# test files: GitHub repo has no tags, use commit hash
-#Source1:        https://github.com/mcfletch/pyopengl/raw/c26398b91a/accelerate/tests/test_arraydatatypeaccel.py
-#Source2:        https://github.com/mcfletch/pyopengl/raw/c26398b91a/accelerate/tests/test_numpyaccel.py
-Source1:        https://github.com/mcfletch/pyopengl/raw/master/accelerate/tests/test_arraydatatypeaccel.py
-Source2:        https://github.com/mcfletch/pyopengl/raw/master/accelerate/tests/test_numpyaccel.py
-#
 BuildRequires:  %{python_module Cython}
 BuildRequires:  %{python_module devel}
 BuildRequires:  %{python_module opengl >= %{version}}

test_arraydatatypeaccel.py

@@ -1,115 +0,0 @@
-import unittest, ctypes
-from OpenGL.arrays import arraydatatype as adt
-from OpenGL.arrays import vbo
-from OpenGL import GL
-from OpenGL._bytes import integer_types
-import pytest
-try:
-    import numpy 
-except ImportError:
-    numpy = None
-try:
-    import OpenGL_accelerate
-except ImportError:
-    pytest.skip('Accelerate not installed, skipping', allow_module_level=True)
-
-class _BaseTest( object ):
-    array = None
-    def setUp( self ):
-        self.handler = adt.ArrayDatatype
-        assert self.handler.isAccelerated
-    def test_from_param( self ):
-        p = self.handler.from_param( self.array )
-        assert isinstance( p, ctypes.c_void_p )
-    def test_dataPointer( self ):
-        p = self.handler.dataPointer( self.array )
-        assert isinstance( p, integer_types)
-    def test_arraySize( self ):
-        p = self.handler.arraySize( self.array )
-        assert p == 6, p
-    def test_arrayByteCount( self ):
-        p = self.handler.arrayByteCount( self.array )
-        assert p == 24, p
-    def test_asArray( self ):
-        p = self.handler.asArray( self.array )
-        assert p is self.array 
-    def test_unitSize( self ):
-        p = self.handler.unitSize( self.array )
-        assert p == 3, p
-    def test_dimensions( self ):
-        p = self.handler.dimensions( self.array )
-        assert p == (2,3), p
-    
-    def test_arrayToGLType( self ):
-        p = self.handler.arrayToGLType( self.array )
-        assert p == GL.GL_FLOAT
-
-# Skip if modifies the functions, which are *shared* between the 
-# classes...
-@pytest.mark.skipif( not numpy, reason="Numpy not available")
-class TestNumpy( _BaseTest, unittest.TestCase ):
-    def setUp( self ):
-        super(TestNumpy,self).setUp()
-        self.array = numpy.array( [[1,2,3],[4,5,6]],'f')
-        handler = adt.ArrayDatatype.getHandler( self.array )
-        handler.registerReturn( )
-
-    def test_dataPointer( self ):
-        p = self.handler.dataPointer( self.array )
-        assert isinstance( p, integer_types)
-        assert p == self.array.ctypes.data
-    def test_zeros( self ):
-        p = self.handler.zeros( (2,3,4), 'f' )
-        assert p.shape == (2,3,4)
-        assert p.dtype == numpy.float32
-    def test_asArrayConvert( self ):
-        p = self.handler.asArray( self.array, GL.GL_DOUBLE )
-        assert p is not self.array 
-        assert p.dtype == numpy.float64
-        p = self.handler.asArray( self.array, 'd' )
-        assert p is not self.array 
-        assert p.dtype == numpy.float64
-    def test_zeros_typed( self ):
-        z = self.handler.zeros( (2,3,4), GL.GL_FLOAT)
-        assert z.shape == (2,3,4)
-        assert z.dtype == numpy.float32
-    def test_downconvert( self ):
-        p = self.handler.asArray( numpy.array( [1,2,3],'d'), GL.GL_FLOAT )
-        assert p.dtype == numpy.float32
-    def test_zeros_small( self ):
-        z = self.handler.zeros( (0,), GL.GL_BYTE )
-        assert z.dtype == numpy.byte, z
-
-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]]))
-        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
-        super(TestVBOOffset,self).setUp()
-        
-class TestNones( unittest.TestCase ):
-    def setUp( self ):
-        self.array = None
-        self.handler = adt.ArrayDatatype
-        assert self.handler.isAccelerated
-    def test_from_param( self ):
-        p = self.handler.from_param( self.array )
-        assert p is None, p
-    def test_dataPointer( self ):
-        p = self.handler.dataPointer( self.array )
-        assert p is None
-    def test_asArray( self ):
-        p = self.handler.asArray( self.array )
-        assert p is self.array 
-    def test_dimensions( self ):
-        p = self.handler.dimensions( self.array )
-        assert p == (0,), p

test_numpyaccel.py

@@ -1,96 +0,0 @@
-import unittest, ctypes
-try:
-    import numpy 
-    from OpenGL_accelerate import numpy_formathandler as npf
-except ImportError:
-    numpy = None
-    npf = None
-try:
-    from OpenGL_accelerate import buffers_formathandler as bpf
-except ImportError:
-    bpf = None
-from OpenGL import error
-from OpenGL import GL
-from OpenGL._bytes import integer_types
-from OpenGL._configflags import ERROR_ON_COPY
-import pytest
-pytestmark = pytest.mark.skipif(not numpy, reason="No numpy installed in order to run tests")
-
-class _AccelArray( object ):
-    handler_class = None
-    def setUp( self ):
-        self.array = numpy.array( [[1,2,3],[4,5,6]],'f')
-        self.handler = self.handler_class()
-    def test_from_param( self ):
-        p = self.handler.from_param( self.handler.asArray(self.array ))
-        assert isinstance( p, ctypes.c_void_p )
-    def test_dataPointer( self ):
-        p = self.handler.dataPointer( self.array )
-        assert isinstance( p, integer_types)
-        assert p == self.array.ctypes.data
-    def test_arraySize( self ):
-        p = self.handler.arraySize( self.array )
-        assert p == 6, p
-    def test_arrayByteCount( self ):
-        p = self.handler.arrayByteCount( self.array )
-        assert p == 24, p
-    def test_unitSize( self ):
-        p = self.handler.unitSize( self.array )
-        assert p == 3, p
-    def test_dimensions( self ):
-        p = self.handler.dimensions( self.array )
-        assert p == (2,3), p
-    
-    def test_arrayToGLType( self ):
-        p = self.handler.arrayToGLType( self.array )
-        assert p == GL.GL_FLOAT
-        
-    
-
-@pytest.mark.skipif(not npf,reason="No numpy native format handler available")
-class TestNumpyNative(_AccelArray,unittest.TestCase):
-    handler_class = getattr(npf,'NumpyHandler',None)
-    def setUp(self):
-        super(TestNumpyNative,self).setUp()
-        self.eoc_handler = self.handler_class( True )
-        
-    def test_asArray( self ):
-        p = self.handler.asArray( self.array )
-        assert p is self.array 
-    def test_downconvert( self ):
-        p = self.handler.asArray( numpy.array( [1,2,3],'d'), GL.GL_FLOAT )
-        assert p.dtype == numpy.float32
-    def test_zeros_constant( self ):
-        z = self.handler.zeros( (2,3,4), GL.GL_FLOAT)
-        assert z.shape == (2,3,4)
-        assert z.dtype == numpy.float32
-    def test_zeros( self ):
-        p = self.handler.zeros( (2,3,4), 'f' )
-        assert p.shape == (2,3,4)
-        assert p.dtype == numpy.float32
-    def test_asArrayCopy( self ):
-        a2 = self.array[:,0]
-        assert not a2.flags.contiguous 
-        self.assertRaises(
-            error.CopyError,
-            self.eoc_handler.asArray,
-                a2
-        )
-    def test_asArrayConvert( self ):
-        self.failUnlessRaises(
-            error.CopyError,
-            self.eoc_handler.asArray,
-                self.array, GL.GL_DOUBLE 
-        )
-    def test_asArrayConvert( self ):
-        p = self.handler.asArray( self.array, GL.GL_DOUBLE )
-        assert p is not self.array 
-        assert p.dtype == numpy.float64
-        p = self.handler.asArray( self.array, 'd' )
-        assert p is not self.array 
-        assert p.dtype == numpy.float64
-
-
-@pytest.mark.skipif(not npf,reason="No numpy native format handler available")
-class TestBufferAPI(_AccelArray,unittest.TestCase):
-    handler_class = getattr(bpf,'MemoryviewHandler',None)