Merge pull request #2248 from kif/2237_remove_deprecated_cython

Remove deprecated code

src/pyFAI/ext/sparse_utils.pyx

@@ -33,7 +33,7 @@
 
 __author__ = "Jerome Kieffer"
 __contact__ = "Jerome.kieffer@esrf.fr"
-__date__ = "03/03/2023"
+__date__ = "21/08/2024"
 __status__ = "stable"
 __license__ = "MIT"
 
@@ -117,153 +117,3 @@ def CSR_to_LUT(data, indices, indptr):
                 lut[i, nelt] = point
                 nelt += 1
     return numpy.asarray(lut)
-
-
-cdef class Vector:
-    """Variable size vector: deprecated, please use sparse_builder"""
-    cdef:
-        readonly int size, allocated
-        data_t[::1] coef
-        index_t[::1] idx
-
-    def __cinit__(self, int min_size=4):
-        deprecated_warning("class", "Vector", reason=None, replacement="sparse_builder.SparseBuilder",
-                           since_version='0.21.0', only_once=True,
-                           skip_backtrace_count=0, deprecated_since='0.21.0')
-        self.allocated = min_size
-        self.coef = numpy.empty(self.allocated, dtype=data_d)
-        self.idx = numpy.empty(self.allocated, dtype=index_d)
-        self.size = 0
-
-    def __dealloc__(self):
-        self.coef = self.idx = None
-
-    def __len__(self):
-        return self.size
-
-    def __repr__(self):
-        return "Vector of size %i (%i elements allocated)" % (self.size, self.allocated)
-
-    @property
-    def nbytes(self):
-        "Calculate the actual size of the object (in bytes)"
-        return (self.allocated + 1) * 8
-
-    def get_data(self):
-        return numpy.asarray(self.idx[:self.size]), numpy.asarray(self.coef[:self.size])
-
-    cdef inline void _append(self, int idx, float coef) noexcept:
-        cdef:
-            int pos, new_allocated
-            index_t[::1] newidx
-            data_t[::1] newcoef
-        pos = self.size
-        self.size = pos + 1
-        if pos >= self.allocated - 1:
-            new_allocated = self.allocated * 2
-            newcoef = numpy.empty(new_allocated, dtype=data_d)
-            newcoef[:pos] = self.coef[:pos]
-            self.coef = newcoef
-            newidx = numpy.empty(new_allocated, dtype=index_d)
-            newidx[:pos] = self.idx[:pos]
-            self.idx = newidx
-            self.allocated = new_allocated
-
-        self.coef[pos] = coef
-        self.idx[pos] = idx
-
-    def append(self, idx, coef):
-        "Python implementation of _append in cython"
-        self._append(<int> idx, <float> coef)
-
-
-cdef class ArrayBuilder:
-    """Sparse matrix builder: deprecated, please use sparse_builder"""
-    cdef:
-        readonly int size
-        Vector[:] lines
-
-
-    def __cinit__(self, int nlines, min_size=4):
-        deprecated_warning("class", "ArrayBuilder", reason=None,
-                           replacement="sparse_builder.SparseBuilder",
-                           since_version='0.21.0', only_once=True,
-                           skip_backtrace_count=0, deprecated_since='0.21.0')
-        cdef int i
-        self.size = nlines
-        nullarray = numpy.array([None] * nlines)
-        self.lines = nullarray
-        for i in range(nlines):
-            self.lines[i] = Vector(min_size=min_size)
-
-    def __dealloc__(self):
-        cdef int i
-        for i in range(self.size):
-            self.lines[i] = None
-        self.lines = None
-
-    def __len__(self):
-        return self.size
-
-    def __repr__(self):
-        cdef int i, max_line = 0
-        for i in range(self.size):
-            max_line = max(max_line, self.lines[i].size)
-        return "ArrayBuilder of %i lines, the longest is %i" % (self.size, max_line)
-
-    @property
-    def nbytes(self):
-        "Calculate the actual size of the object (in bytes)"
-        cdef int i, sum = 0
-        for i in range(self.size):
-            sum += self.lines[i].nbytes
-        return sum
-
-    cdef inline void _append(self, int line, int col, float value) noexcept:
-        cdef:
-            Vector vector
-        vector = self.lines[line]
-        vector._append(col, value)
-
-    def append(self, line, col, value):
-        'Python wrapper for _append in cython'
-        self._append(<int> line, <int> col, <float> value)
-
-    def as_LUT(self):
-        cdef:
-            int i, j, max_size = 0
-            index_t[::1] local_idx
-            data_t[:] local_coef
-            lut_t[:, :] lut
-            Vector vector
-        for i in range(len(self.lines)):
-            if len(self.lines[i]) > max_size:
-                max_size = len(self.lines[i])
-        lut = numpy.zeros((len(self.lines), max_size), dtype=lut_d)
-        for i in range(len(self.lines)):
-            vector = self.lines[i]
-            local_idx, local_coef = vector.get_data()
-            for j in range(len(vector)):
-                lut[i, j] = lut_t(local_idx[j], local_coef[j])
-        return numpy.asarray(lut, dtype=lut_d)
-
-    def as_CSR(self):
-        cdef:
-            int i, start, end, total_size = 0
-            Vector vector
-            index_t[:] idptr, idx, local_idx
-            data_t[:] coef, local_coef
-        idptr = numpy.zeros(len(self.lines) + 1, dtype=index_d)
-        for i in range(len(self.lines)):
-            total_size += len(self.lines[i])
-            idptr[i + 1] = total_size
-        coef = numpy.zeros(total_size, dtype=numpy.float32)
-        idx = numpy.zeros(total_size, dtype=numpy.int32)
-        for i in range(len(self.lines)):
-            vector = self.lines[i]
-            local_idx, local_coef = vector.get_data()
-            start = idptr[i]
-            end = start + len(vector)
-            idx[start:end] = local_idx
-            coef[start:end] = local_coef
-        return numpy.asarray(idptr), numpy.asarray(idx), numpy.asarray(coef)

src/pyFAI/test/test_sparse.py

@@ -32,7 +32,7 @@
 __contact__ = "Jerome.Kieffer@ESRF.eu"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "21/05/2024"
+__date__ = "21/08/2024"
 
 import unittest
 import numpy
@@ -245,51 +245,12 @@ def test_matrix_conversion(self):
         self.assertEqual(abs(sparse["csr"][2] - csr2[2]).max(), 0, "CSR indptr matches")
 
 
-class TestContainer(unittest.TestCase):
-    "Those classes are deprecated"
-
-    def test_vector(self):
-        nelem = 12
-        cont = sparse_utils.Vector()
-        self.assertEqual(cont.size, 0, "initialized vector is empty")
-        self.assertGreaterEqual(cont.allocated, 4, "Initialized vector has some space")
-        for i in range(nelem):
-            cont.append(i, 0.1 * i)
-        self.assertEqual(cont.size, nelem, "initialized vector is empty")
-        self.assertGreaterEqual(cont.allocated, nelem, "Initialized vector has some space")
-        i, f = cont.get_data()
-        d = abs(numpy.arange(nelem) - i).max()
-        self.assertEqual(d, 0, "result is OK")
-        self.assertLess(abs(f - i / 10.0).max(), 1e-6, "result is OK")
-
-    def test_container(self):
-        nlines = 11
-        ncol = 12
-        nelem = nlines * ncol
-        cont = sparse_utils.ArrayBuilder(nlines)
-        for i in range(nelem):
-            cont.append(i % nlines, i, 0.1 * i)
-        s = numpy.arange(nelem).reshape((ncol, nlines)).T.ravel()
-        a, b, c = cont.as_CSR()
-        err = abs(a - numpy.arange(0, nelem + 1, ncol)).max()
-        self.assertEqual(err, 0, "idxptr OK")
-        err = abs(s - b).max()
-        self.assertEqual(err, 0, "idx OK")
-        err = abs((s / 10.0) - c).max()
-        self.assertLessEqual(err, 1e-6, "value OK: %s" % err)
-        lut = cont.as_LUT()
-        s = numpy.arange(nelem).reshape((ncol, nlines)).T
-        self.assertEqual(abs(lut["idx"] - s).max(), 0, "LUT idx OK")
-        self.assertLessEqual(abs(lut["coef"] - s / 10.0).max(), 1e-6, "LUT coef OK")
-
-
 def suite():
     loader = unittest.defaultTestLoader.loadTestsFromTestCase
     testsuite = unittest.TestSuite()
     testsuite.addTest(loader(TestSparseIntegrate1d))
     testsuite.addTest(loader(TestSparseIntegrate2d))
     testsuite.addTest(loader(TestSparseUtils))
-    testsuite.addTest(loader(TestContainer))
     return testsuite