numexpr 2.10.0__tar.gz → 2.10.2__tar.gz

{numexpr-2.10.0 → numexpr-2.10.2}/ANNOUNCE.rst

@@ -1,29 +1,28 @@
-========================
-Announcing NumExpr 2.9.0
-========================
+=========================
+Announcing NumExpr 2.10.2
+=========================
 
 Hi everyone,
 
-NumExpr 2.9.0 is a release offering support for latest versions of PyPy.
-The full test suite should pass now, at least for the Python 3.10 version.
-Thanks to @27rabbitlt for most of the work and @mgorny and @mattip for
-providing help and additional fixes.
+NumExpr 2.10.2 provides wheels for Python 2.13 for first time.
+Also, there is better support for CPUs that do not have a power
+of 2 number of cores.  Finally, numexpr is allowed to run with
+the multithreading package in Python.
 
 Project documentation is available at:
 
 http://numexpr.readthedocs.io/
 
-Changes from 2.8.8 to 2.9.0
----------------------------
+Changes from 2.10.1 to 2.10.2
+-----------------------------
 
-* Support for PyPy (see PRs #467 and #740).  The full test suite
-  should pass now, at least for the 3.10 version.  Thanks to
-  @27rabbitlt for most of the work and @mgorny and @mattip for
-  providing help and additional fixes.  Fixes #463.
+* Better support for CPUs that do not have a power of 2 number of
+  cores.  See #479 and #490.  Thanks to @avalentino.
 
-* Fixed more sanitizer issues (see PR #469).  Thanks to @27rabbitlt.
+* Allow numexpr to run with the multithreading package in Python.
+  See PR #496.  Thanks to @emmaai
 
-* Modernized the test suite to avoid some warnings.
+* Wheels for Python 3.13 are now provided.
 
 What's Numexpr?
 ---------------

{numexpr-2.10.0 → numexpr-2.10.2}/MANIFEST.in

@@ -1,4 +1,4 @@
-include MANIFEST.in
+include MANIFEST.in VERSION
 
 include *.rst *.txt *.cfg site.cfg.example
 

{numexpr-2.10.0 → numexpr-2.10.2}/PKG-INFO

@@ -1,29 +1,31 @@
 Metadata-Version: 2.1
 Name: numexpr
-Version: 2.10.0
+Version: 2.10.2
 Summary: Fast numerical expression evaluator for NumPy
-Home-page: https://github.com/pydata/numexpr
-Author: David M. Cooke, Francesc Alted, and others
-Maintainer: Francesc Alted
-Maintainer-email: faltet@gmail.com
-License: MIT
+Author-email: "David M. Cooke, Francesc Alted, and others" <blosc@blosc.org>
+Maintainer-email: Blosc Development Team <blosc@blosc.org>
+Project-URL: homepage, https://github.com/pydata/numexpr
+Project-URL: documentation, https://numexpr.readthedocs.io
+Project-URL: repository, https://github.com/pydata/numexpr
 Classifier: Development Status :: 6 - Mature
-Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: MacOS
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
-Requires-Dist: numpy>=1.19.3
+Requires-Dist: numpy>=1.23.0
 
 ======================================================
 NumExpr: Fast numerical expression evaluator for NumPy

{numexpr-2.10.0 → numexpr-2.10.2}/RELEASE_NOTES.rst

@@ -2,6 +2,36 @@
 Release notes for NumExpr 2.10 series
 =====================================
 
+Changes from 2.10.1 to 2.10.2
+-----------------------------
+
+* Better support for CPUs that do not have a power of 2 number of
+  cores.  See #479 and #490.  Thanks to @avalentino.
+
+* Allow numexpr to run with the multithreading package in Python.
+  See PR #496.  Thanks to @emmaai
+
+* Wheels for Python 3.13 are now provided.
+
+
+Changes from 2.10.0 to 2.10.1
+-----------------------------
+
+* The default number of 'safe' threads has been upgraded to 16 (instead of
+  previous 8). That means that if your CPU has > 16 cores, the default is
+  to use 16. You can always override this with the "NUMEXPR_MAX_THREADS"
+  environment variable.
+
+* NumPy 1.23 is now the minimum supported.
+
+* Preliminary support for Python 3.13. Thanks to Karolina Surma.
+
+* Fix tests on nthreads detection (closes: #479). Thanks to @avalentino.
+
+* The build process has been modernized and now uses the `pyproject.toml`
+  file for more of the configuration options.
+
+
 Changes from 2.9.0 to 2.10.0
 ----------------------------
 

numexpr-2.10.2/VERSION

@@ -0,0 +1 @@
+2.10.2

numexpr-2.10.2/bench/large_array_vs_numpy.py

@@ -0,0 +1,152 @@
+#################################################################################
+# To mimic the scenario that computation is i/o bound and constrained by memory
+#
+# It's a much simplified version that the chunk is computed in a loop,
+# and expression is evaluated in a sequence, which is not true in reality.
+# Neverthless, numexpr outperforms numpy.
+#################################################################################
+"""
+Benchmarking Expression 1:
+NumPy time (threaded over 32 chunks with 2 threads): 4.612313 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 2 threads): 0.951172 seconds
+numexpr speedup: 4.85x
+----------------------------------------
+Benchmarking Expression 2:
+NumPy time (threaded over 32 chunks with 2 threads): 23.862752 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 2 threads): 2.182058 seconds
+numexpr speedup: 10.94x
+----------------------------------------
+Benchmarking Expression 3:
+NumPy time (threaded over 32 chunks with 2 threads): 20.594895 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 2 threads): 2.927881 seconds
+numexpr speedup: 7.03x
+----------------------------------------
+Benchmarking Expression 4:
+NumPy time (threaded over 32 chunks with 2 threads): 12.834101 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 2 threads): 5.392480 seconds
+numexpr speedup: 2.38x
+----------------------------------------
+"""
+
+import os
+
+os.environ["NUMEXPR_NUM_THREADS"] = "16"
+import numpy as np
+import numexpr as ne
+import timeit
+import threading
+
+array_size = 10**8
+num_runs = 10
+num_chunks = 32  # Number of chunks
+num_threads = 2  # Number of threads constrained by how many chunks memory can hold
+
+a = np.random.rand(array_size).reshape(10**4, -1)
+b = np.random.rand(array_size).reshape(10**4, -1)
+c = np.random.rand(array_size).reshape(10**4, -1)
+
+chunk_size = array_size // num_chunks
+
+expressions_numpy = [
+    lambda a, b, c: a + b * c,
+    lambda a, b, c: a**2 + b**2 - 2 * a * b * np.cos(c),
+    lambda a, b, c: np.sin(a) + np.log(b) * np.sqrt(c),
+    lambda a, b, c: np.exp(a) + np.tan(b) - np.sinh(c),
+]
+
+expressions_numexpr = [
+    "a + b * c",
+    "a**2 + b**2 - 2 * a * b * cos(c)",
+    "sin(a) + log(b) * sqrt(c)",
+    "exp(a) + tan(b) - sinh(c)",
+]
+
+
+def benchmark_numpy_chunk(func, a, b, c, results, indices):
+    for index in indices:
+        start = index * chunk_size
+        end = (index + 1) * chunk_size
+        time_taken = timeit.timeit(
+            lambda: func(a[start:end], b[start:end], c[start:end]), number=num_runs
+        )
+        results.append(time_taken)
+
+
+def benchmark_numexpr_re_evaluate(expr, a, b, c, results, indices):
+    for index in indices:
+        start = index * chunk_size
+        end = (index + 1) * chunk_size
+        if index == 0:
+            # Evaluate the first chunk with evaluate
+            time_taken = timeit.timeit(
+                lambda: ne.evaluate(
+                    expr,
+                    local_dict={
+                        "a": a[start:end],
+                        "b": b[start:end],
+                        "c": c[start:end],
+                    },
+                ),
+                number=num_runs,
+            )
+        else:
+            # Re-evaluate subsequent chunks with re_evaluate
+            time_taken = timeit.timeit(
+                lambda: ne.re_evaluate(
+                    local_dict={"a": a[start:end], "b": b[start:end], "c": c[start:end]}
+                ),
+                number=num_runs,
+            )
+        results.append(time_taken)
+
+
+def run_benchmark_threaded():
+    chunk_indices = list(range(num_chunks))
+
+    for i in range(len(expressions_numpy)):
+        print(f"Benchmarking Expression {i+1}:")
+
+        results_numpy = []
+        results_numexpr = []
+
+        threads_numpy = []
+        for j in range(num_threads):
+            indices = chunk_indices[j::num_threads]  # Distribute chunks across threads
+            thread = threading.Thread(
+                target=benchmark_numpy_chunk,
+                args=(expressions_numpy[i], a, b, c, results_numpy, indices),
+            )
+            threads_numpy.append(thread)
+            thread.start()
+
+        for thread in threads_numpy:
+            thread.join()
+
+        numpy_time = sum(results_numpy)
+        print(
+            f"NumPy time (threaded over {num_chunks} chunks with {num_threads} threads): {numpy_time:.6f} seconds"
+        )
+
+        threads_numexpr = []
+        for j in range(num_threads):
+            indices = chunk_indices[j::num_threads]  # Distribute chunks across threads
+            thread = threading.Thread(
+                target=benchmark_numexpr_re_evaluate,
+                args=(expressions_numexpr[i], a, b, c, results_numexpr, indices),
+            )
+            threads_numexpr.append(thread)
+            thread.start()
+
+        for thread in threads_numexpr:
+            thread.join()
+
+        numexpr_time = sum(results_numexpr)
+        print(
+            f"numexpr time (threaded with re_evaluate over {num_chunks} chunks with {num_threads} threads): {numexpr_time:.6f} seconds"
+        )
+        print(f"numexpr speedup: {numpy_time / numexpr_time:.2f}x")
+        print("-" * 40)
+
+
+if __name__ == "__main__":
+    run_benchmark_threaded()

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr/__init__.py

@@ -28,8 +28,6 @@ is_cpu_amd_intel = False # DEPRECATION WARNING: WILL BE REMOVED IN FUTURE RELEAS
 # cpuinfo imports were moved into the test submodule function that calls them 
 # to improve import times.
 
-import os, os.path
-import platform
 from numexpr.expressions import E
 from numexpr.necompiler import (NumExpr, disassemble, evaluate, re_evaluate, 
     validate)

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr/interpreter.cpp

@@ -47,6 +47,12 @@
 #define AVAILABLE(Haystack, Haystack_Len, J, Needle_Len)   \
   ((Haystack_Len) >= (J) + (Needle_Len))
 
+// To allow building with NumPy<2 locally define the new NumPy macros:
+#if NPY_ABI_VERSION < 0x02000000
+  #define PyDataType_ELSIZE(descr) ((descr)->elsize)
+  #define PyDataType_SET_ELSIZE(descr, size) (descr)->elsize = size
+#endif
+
 #include "str-two-way.hpp"
 
 #ifdef DEBUG

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr/necompiler.py

@@ -19,7 +19,7 @@ import numpy
 
 is_cpu_amd_intel = False # DEPRECATION WARNING: WILL BE REMOVED IN FUTURE RELEASE
 from numexpr import interpreter, expressions, use_vml
-from numexpr.utils import CacheDict
+from numexpr.utils import CacheDict, ContextDict
 
 # Declare a double type that does not exist in Python space
 double = numpy.double
@@ -767,7 +767,7 @@ def getArguments(names, local_dict=None, global_dict=None, _frame_depth: int=2):
         # If we generated local_dict via an explicit reference to f_locals,
         # clear the dict to prevent creating extra ref counts in the caller's scope
         # See https://github.com/pydata/numexpr/issues/310
-        if clear_local_dict:
+        if clear_local_dict and hasattr(local_dict, 'clear'):
             local_dict.clear()
 
     return arguments
@@ -776,11 +776,9 @@ def getArguments(names, local_dict=None, global_dict=None, _frame_depth: int=2):
 # Dictionaries for caching variable names and compiled expressions
 _names_cache = CacheDict(256)
 _numexpr_cache = CacheDict(256)
-_numexpr_last = {}
+_numexpr_last = ContextDict()
 evaluate_lock = threading.Lock()
 
-# MAYBE: decorate this function to add attributes instead of having the 
-# _numexpr_last dictionary?
 def validate(ex: str, 
              local_dict: Optional[Dict] = None, 
              global_dict: Optional[Dict] = None,
@@ -887,7 +885,7 @@ def validate(ex: str,
             compiled_ex = _numexpr_cache[numexpr_key] = NumExpr(ex, signature, sanitize=sanitize, **context)
         kwargs = {'out': out, 'order': order, 'casting': casting,
                 'ex_uses_vml': ex_uses_vml}
-        _numexpr_last = dict(ex=compiled_ex, argnames=names, kwargs=kwargs)
+        _numexpr_last.set(ex=compiled_ex, argnames=names, kwargs=kwargs)
     except Exception as e:
         return e
     return None

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr/tests/test_numexpr.py

@@ -41,6 +41,7 @@ TestCase = unittest.TestCase
 
 double = np.double
 long = int
+MAX_THREADS = 16
 
 
 class test_numexpr(TestCase):
@@ -1128,7 +1129,7 @@ class test_threading_config(TestCase):
                 "if 'NUMEXPR_MAX_THREADS' in os.environ: os.environ.pop('NUMEXPR_MAX_THREADS')",
                 "if 'OMP_NUM_THREADS' in os.environ: os.environ.pop('OMP_NUM_THREADS')",
                 "import numexpr",
-                "assert(numexpr.nthreads <= 8)",
+                f"assert(numexpr.nthreads <= {MAX_THREADS})",
                 "exit(0)"])
         subprocess.check_call([sys.executable, '-c', script])
 
@@ -1164,14 +1165,14 @@ class test_threading_config(TestCase):
             if 'sparc' in platform.machine():
                 self.assertEqual(1, numexpr._init_num_threads())
             else:
-                self.assertEqual(detect_number_of_cores(), numexpr._init_num_threads())
+                self.assertEqual(min(detect_number_of_cores(), MAX_THREADS), numexpr._init_num_threads())
 
     def test_numexpr_max_threads_empty_string(self):
         with _environment('NUMEXPR_MAX_THREADS', ''):
             if 'sparc' in platform.machine():
                 self.assertEqual(1, numexpr._init_num_threads())
             else:
-                self.assertEqual(detect_number_of_cores(), numexpr._init_num_threads())
+                self.assertEqual(min(detect_number_of_cores(), MAX_THREADS), numexpr._init_num_threads())
 
     def test_vml_threads_round_trip(self):
         n_threads = 3
@@ -1200,6 +1201,7 @@ class test_threading(TestCase):
         test.join()
 
     def test_multithread(self):
+
         import threading
 
         # Running evaluate() from multiple threads shouldn't crash
@@ -1217,6 +1219,77 @@ class test_threading(TestCase):
         for t in threads:
             t.join()
 
+    def test_thread_safety(self):
+        """
+        Expected output
+
+        When not safe (before the pr this test is commited)
+        AssertionError: Thread-0 failed: result does not match expected
+
+        When safe (after the pr this test is commited)
+        Should pass without failure
+        """
+        import threading
+        import time
+
+        barrier = threading.Barrier(4)
+
+        # Function that each thread will run with different expressions
+        def thread_function(a_value, b_value, expression, expected_result, results, index):
+            validate(expression, local_dict={"a": a_value, "b": b_value})
+            # Wait for all threads to reach this point
+            # such that they all set _numexpr_last
+            barrier.wait()
+
+            # Simulate some work or a context switch delay
+            time.sleep(0.1)
+
+            result = re_evaluate(local_dict={"a": a_value, "b": b_value})
+            results[index] = np.array_equal(result, expected_result)
+
+        def test_thread_safety_with_numexpr():
+            num_threads = 4
+            array_size = 1000000
+
+            expressions = [
+                "a + b",
+                "a - b",
+                "a * b",
+                "a / b"
+            ]
+
+            a_value = [np.full(array_size, i + 1) for i in range(num_threads)]
+            b_value = [np.full(array_size, (i + 1) * 2) for i in range(num_threads)]
+
+            expected_results = [
+                a_value[i] + b_value[i] if expr == "a + b" else
+                a_value[i] - b_value[i] if expr == "a - b" else
+                a_value[i] * b_value[i] if expr == "a * b" else
+                a_value[i] / b_value[i] if expr == "a / b" else None
+                for i, expr in enumerate(expressions)
+            ]
+
+            results = [None] * num_threads
+            threads = []
+
+            # Create and start threads with different expressions
+            for i in range(num_threads):
+                thread = threading.Thread(
+                    target=thread_function,
+                    args=(a_value[i], b_value[i], expressions[i], expected_results[i], results, i)
+                )
+                threads.append(thread)
+                thread.start()
+
+            for thread in threads:
+                thread.join()
+
+            for i in range(num_threads):
+                if not results[i]:
+                    self.fail(f"Thread-{i} failed: result does not match expected")
+
+        test_thread_safety_with_numexpr()
+
 
 # The worker function for the subprocess (needs to be here because Windows
 # has problems pickling nested functions with the multiprocess module :-/)
@@ -1315,28 +1388,28 @@ def suite():
         add_method(func)
 
     for n in range(niter):
-        theSuite.addTest(unittest.makeSuite(test_numexpr))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_numexpr))
         if 'sparc' not in platform.machine():
-            theSuite.addTest(unittest.makeSuite(test_numexpr2))
-        theSuite.addTest(unittest.makeSuite(test_evaluate))
-        theSuite.addTest(unittest.makeSuite(TestExpressions))
-        theSuite.addTest(unittest.makeSuite(test_int32_int64))
-        theSuite.addTest(unittest.makeSuite(test_uint32_int64))
-        theSuite.addTest(unittest.makeSuite(test_strings))
+            theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_numexpr2))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_evaluate))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(TestExpressions))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_int32_int64))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_uint32_int64))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_strings))
         theSuite.addTest(
-            unittest.makeSuite(test_irregular_stride))
-        theSuite.addTest(unittest.makeSuite(test_zerodim))
-        theSuite.addTest(unittest.makeSuite(test_threading_config))
+            unittest.defaultTestLoader.loadTestsFromTestCase(test_irregular_stride))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_zerodim))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_threading_config))
 
         # multiprocessing module is not supported on Hurd/kFreeBSD
         if (pl.system().lower() not in ('gnu', 'gnu/kfreebsd')):
-            theSuite.addTest(unittest.makeSuite(test_subprocess))
+            theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_subprocess))
 
         # I need to put this test after test_subprocess because
         # if not, the test suite locks immediately before test_subproces.
         # This only happens with Windows, so I suspect of a subtle bad
         # interaction with threads and subprocess :-/
-        theSuite.addTest(unittest.makeSuite(test_threading))
+        theSuite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_threading))
 
     return theSuite
 

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr/utils.py

@@ -13,6 +13,7 @@ log = logging.getLogger(__name__)
 
 import os
 import subprocess
+import contextvars
 
 from numexpr.interpreter import _set_num_threads, _get_num_threads, MAX_THREADS
 from numexpr import use_vml
@@ -143,10 +144,10 @@ def _init_num_threads():
         # configured NumExpr as desired, so we emit info logs.
         if n_cores > MAX_THREADS:
             log.info('Note: detected %d virtual cores but NumExpr set to maximum of %d, check "NUMEXPR_MAX_THREADS" environment variable.'%(n_cores, MAX_THREADS))
-        if n_cores > 8:
-            # The historical 'safety' limit.
-            log.info('Note: NumExpr detected %d cores but "NUMEXPR_MAX_THREADS" not set, so enforcing safe limit of 8.'%n_cores)
-            n_cores = 8
+        if n_cores > 16:
+            # Back in 2019, 8 threads would be considered safe for performance. We are in 2024 now, so adjusting.
+            log.info('Note: NumExpr detected %d cores but "NUMEXPR_MAX_THREADS" not set, so enforcing safe limit of 16.'%n_cores)
+            n_cores = 16
 
     # Now we check for 'NUMEXPR_NUM_THREADS' or 'OMP_NUM_THREADS' to set the 
     # actual number of threads used.
@@ -226,3 +227,83 @@ class CacheDict(dict):
                 super(CacheDict, self).__delitem__(k)
         super(CacheDict, self).__setitem__(key, value)
 
+
+class ContextDict:
+    """
+    A context aware version dictionary
+    """
+    def __init__(self):
+        self._context_data = contextvars.ContextVar('context_data', default={})
+
+    def set(self, key=None, value=None, **kwargs):
+        data = self._context_data.get().copy()
+
+        if key is not None:
+            data[key] = value
+
+        for k, v in kwargs.items():
+            data[k] = v
+
+        self._context_data.set(data)
+
+    def get(self, key, default=None):
+        data = self._context_data.get()
+        return data.get(key, default)
+
+    def delete(self, key):
+        data = self._context_data.get().copy()
+        if key in data:
+            del data[key]
+        self._context_data.set(data)
+
+    def clear(self):
+        self._context_data.set({})
+
+    def all(self):
+        return self._context_data.get()
+
+    def update(self, *args, **kwargs):
+        data = self._context_data.get().copy()
+
+        if args:
+            if len(args) > 1:
+                raise TypeError(f"update() takes at most 1 positional argument ({len(args)} given)")
+            other = args[0]
+            if isinstance(other, dict):
+                data.update(other)
+            else:
+                for k, v in other:
+                    data[k] = v
+
+        data.update(kwargs)
+        self._context_data.set(data)
+
+    def keys(self):
+        return self._context_data.get().keys()
+
+    def values(self):
+        return self._context_data.get().values()
+
+    def items(self):
+        return self._context_data.get().items()
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def __setitem__(self, key, value):
+        self.set(key, value)
+
+    def __delitem__(self, key):
+        self.delete(key)
+
+    def __contains__(self, key):
+        return key in self._context_data.get()
+
+    def __len__(self):
+        return len(self._context_data.get())
+
+    def __iter__(self):
+        return iter(self._context_data.get())
+
+    def __repr__(self):
+        return repr(self._context_data.get())

numexpr-2.10.2/numexpr/version.py

@@ -0,0 +1,5 @@
+# THIS FILE IS GENERATED BY `setup.py`
+__version__ = '2.10.2'
+version = '2.10.2'
+numpy_build_version = '2.1.3'
+platform_machine = 'AMD64'

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr.egg-info/PKG-INFO

@@ -1,29 +1,31 @@
 Metadata-Version: 2.1
 Name: numexpr
-Version: 2.10.0
+Version: 2.10.2
 Summary: Fast numerical expression evaluator for NumPy
-Home-page: https://github.com/pydata/numexpr
-Author: David M. Cooke, Francesc Alted, and others
-Maintainer: Francesc Alted
-Maintainer-email: faltet@gmail.com
-License: MIT
+Author-email: "David M. Cooke, Francesc Alted, and others" <blosc@blosc.org>
+Maintainer-email: Blosc Development Team <blosc@blosc.org>
+Project-URL: homepage, https://github.com/pydata/numexpr
+Project-URL: documentation, https://numexpr.readthedocs.io
+Project-URL: repository, https://github.com/pydata/numexpr
 Classifier: Development Status :: 6 - Mature
-Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: MacOS
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
-Requires-Dist: numpy>=1.19.3
+Requires-Dist: numpy>=1.23.0
 
 ======================================================
 NumExpr: Fast numerical expression evaluator for NumPy

{numexpr-2.10.0 → numexpr-2.10.2}/numexpr.egg-info/SOURCES.txt

@@ -4,14 +4,15 @@ LICENSE.txt
 MANIFEST.in
 README.rst
 RELEASE_NOTES.rst
+VERSION
 pyproject.toml
 requirements.txt
-setup.cfg
 setup.py
 site.cfg.example
 bench/boolean_timing.py
 bench/issue-36.py
 bench/issue-47.py
+bench/large_array_vs_numpy.py
 bench/multidim.py
 bench/poly.py
 bench/timing.py
@@ -43,7 +44,6 @@ numexpr/version.py
 numexpr.egg-info/PKG-INFO
 numexpr.egg-info/SOURCES.txt
 numexpr.egg-info/dependency_links.txt
-numexpr.egg-info/not-zip-safe
 numexpr.egg-info/requires.txt
 numexpr.egg-info/top_level.txt
 numexpr/win32/pthread.c

numexpr-2.10.2/numexpr.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.23.0

numexpr-2.10.2/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = [
+    "setuptools",
+    "wheel",
+    "numpy>=2.0.0",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["numexpr"]
+
+[project]
+name = "numexpr"
+description = "Fast numerical expression evaluator for NumPy"
+readme = "README.rst"
+authors = [{name = "David M. Cooke, Francesc Alted, and others", email = "blosc@blosc.org"}]
+maintainers = [{ name = "Blosc Development Team", email = "blosc@blosc.org"}]
+classifiers = [
+    "Development Status :: 6 - Mature",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: Unix",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+requires-python = ">=3.9"
+# Follow guidelines from https://scientific-python.org/specs/spec-0000/
+dependencies = [
+    "numpy>=1.23.0",
+]
+dynamic = ["version"]
+
+[project.urls]
+homepage = "https://github.com/pydata/numexpr"
+documentation = "https://numexpr.readthedocs.io"
+repository = "https://github.com/pydata/numexpr"
+
+[tool.cibuildwheel]
+skip = "cp36-* cp37-* pp37-* cp38-* pp* *-manylinux_i686 *_ppc64le *_s390x"
+# Let's use a more recent version of the manylinux image for more modern compilers
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"

numexpr-2.10.2/requirements.txt

@@ -0,0 +1 @@
+numpy >= 1.23.0 # keep in sync with NPY_TARGET_VERSION (setup.py)

numexpr-2.10.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{numexpr-2.10.0 → numexpr-2.10.2}/setup.py

@@ -10,32 +10,38 @@
 ####################################################################
 
 import os, os.path as op
-from setuptools import setup, Extension
 import platform
 import configparser
 import numpy as np
+from setuptools import setup, Extension
+
 
 with open('requirements.txt') as f:
     requirements = f.read().splitlines()
 
+version = open("VERSION").read().strip()
 with open('numexpr/version.py', 'w') as fh:
-    cfg = configparser.ConfigParser()
-    cfg.read('setup.cfg')
-    fh.write('# THIS FILE IS GENERATED BY `SETUP.PY`\n')
-    fh.write("version = '%s'\n" % cfg['metadata']['version'])
+    # Create the version.py file
+    fh.write("# THIS FILE IS GENERATED BY `setup.py`\n")
+    fh.write(f"__version__ = '{version}'\n")
+    fh.write(f"version = '{version}'\n")
     try:
         fh.write("numpy_build_version = '%s'\n" % np.__version__)
     except ImportError:
         pass
     fh.write("platform_machine = '%s'\n" % platform.machine())
 
+# Read the contents of your README file
+with open('README.rst', encoding='utf-8') as f:
+    long_description = f.read()
+
 lib_dirs = []
 inc_dirs = [np.get_include()]
 libs = []  # Pre-built libraries ONLY, like python36.so
 clibs = []
 def_macros = [
     # keep in sync with minimal runtime requirement (requirements.txt) 
-    ('NPY_TARGET_VERSION', 'NPY_1_19_API_VERSION')
+    ('NPY_TARGET_VERSION', 'NPY_1_23_API_VERSION')
 ]
 sources = ['numexpr/interpreter.cpp',
            'numexpr/module.cpp',
@@ -98,6 +104,9 @@ def setup_package():
     )
 
     metadata = dict(
+        version=version,
+        long_description=long_description,
+        long_description_content_type='text/x-rst',
         install_requires=requirements,
         libraries=clibs,
         ext_modules=[

numexpr-2.10.0/numexpr/version.py

@@ -1,4 +0,0 @@
-# THIS FILE IS GENERATED BY `SETUP.PY`
-version = '2.10.0'
-numpy_build_version = '2.0.0rc1'
-platform_machine = 'AMD64'

numexpr-2.10.0/numexpr.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

numexpr-2.10.0/numexpr.egg-info/requires.txt

@@ -1 +0,0 @@
-numpy>=1.19.3

numexpr-2.10.0/pyproject.toml

@@ -1,7 +0,0 @@
-[build-system]
-requires = [
-    "setuptools",
-    "wheel",
-    "numpy>=2.0.0rc1",
-]
-build-backend = "setuptools.build_meta"

numexpr-2.10.0/requirements.txt

@@ -1 +0,0 @@
-numpy >= 1.19.3 # keep in sync with NPY_TARGET_VERSION (setup.py)

numexpr-2.10.0/setup.cfg

@@ -1,34 +0,0 @@
-[metadata]
-name = numexpr
-version = 2.10.0
-description = Fast numerical expression evaluator for NumPy
-author = David M. Cooke, Francesc Alted, and others
-maintainer = Francesc Alted
-maintainer_email = faltet@gmail.com
-url = https://github.com/pydata/numexpr
-long_description = file: README.rst
-long_description_content_type = text/x-rst
-license = MIT
-classifiers = 
-	Development Status :: 6 - Mature
-	Intended Audience :: Financial and Insurance Industry
-	Intended Audience :: Science/Research
-	License :: OSI Approved :: MIT License
-	Programming Language :: Python :: 3
-	Programming Language :: Python :: 3.9
-	Programming Language :: Python :: 3.10
-	Programming Language :: Python :: 3.11
-	Programming Language :: Python :: 3.12
-	Operating System :: Microsoft :: Windows
-	Operating System :: POSIX
-	Operating System :: MacOS
-
-[options]
-zip_safe = False
-packages = find:
-python_requires = >=3.9
-
-[egg_info]
-tag_build = 
-tag_date = 0
-