numexpr 2.10.2__cp313-cp313-win32.whl

numexpr/utils.py

@@ -0,0 +1,309 @@
+###################################################################
+#  Numexpr - Fast numerical array expression evaluator for NumPy.
+#
+#      License: MIT
+#      Author:  See AUTHORS.txt
+#
+#  See LICENSE.txt and LICENSES/*.txt for details about copyright and
+#  rights to use.
+####################################################################
+
+import logging
+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
+from . import version
+
+if use_vml:
+    from numexpr.interpreter import (
+        _get_vml_version, _set_vml_accuracy_mode, _set_vml_num_threads,
+        _get_vml_num_threads)
+
+
+def get_vml_version():
+    """
+    Get the VML/MKL library version.
+    """
+    if use_vml:
+        return _get_vml_version()
+    else:
+        return None
+
+
+def set_vml_accuracy_mode(mode):
+    """
+    Set the accuracy mode for VML operations.
+
+    The `mode` parameter can take the values:
+    - 'high': high accuracy mode (HA), <1 least significant bit
+    - 'low': low accuracy mode (LA), typically 1-2 least significant bits
+    - 'fast': enhanced performance mode (EP)
+    - None: mode settings are ignored
+
+    This call is equivalent to the `vmlSetMode()` in the VML library.
+    See:
+
+    http://www.intel.com/software/products/mkl/docs/webhelp/vml/vml_DataTypesAccuracyModes.html
+
+    for more info on the accuracy modes.
+
+    Returns old accuracy settings.
+    """
+    if use_vml:
+        acc_dict = {None: 0, 'low': 1, 'high': 2, 'fast': 3}
+        acc_reverse_dict = {1: 'low', 2: 'high', 3: 'fast'}
+        if mode not in list(acc_dict.keys()):
+            raise ValueError(
+                "mode argument must be one of: None, 'high', 'low', 'fast'")
+        retval = _set_vml_accuracy_mode(acc_dict.get(mode, 0))
+        return acc_reverse_dict.get(retval)
+    else:
+        return None
+
+
+def set_vml_num_threads(nthreads):
+    """
+    Suggests a maximum number of threads to be used in VML operations.
+
+    This function is equivalent to the call
+    `mkl_domain_set_num_threads(nthreads, MKL_DOMAIN_VML)` in the MKL
+    library.  See:
+
+    http://www.intel.com/software/products/mkl/docs/webhelp/support/functn_mkl_domain_set_num_threads.html
+
+    for more info about it.
+    """
+    if use_vml:
+        _set_vml_num_threads(nthreads)
+    pass
+
+def get_vml_num_threads():
+    """
+    Gets the maximum number of threads to be used in VML operations.
+
+    This function is equivalent to the call
+    `mkl_domain_get_max_threads (MKL_DOMAIN_VML)` in the MKL
+    library.  See:
+
+    http://software.intel.com/en-us/node/522118
+
+    for more info about it.
+    """
+    if use_vml:
+        return _get_vml_num_threads()
+    return None
+
+def set_num_threads(nthreads):
+    """
+    Sets a number of threads to be used in operations.
+
+    DEPRECATED: returns the previous setting for the number of threads.
+
+    During initialization time NumExpr sets this number to the number
+    of detected cores in the system (see `detect_number_of_cores()`).
+    """
+    old_nthreads = _set_num_threads(nthreads)
+    return old_nthreads
+
+def get_num_threads():
+    """
+    Gets the number of threads currently in use for operations.
+    """
+    return _get_num_threads()
+
+def _init_num_threads():
+    """
+    Detects the environment variable 'NUMEXPR_MAX_THREADS' to set the threadpool 
+    size, and if necessary the slightly redundant 'NUMEXPR_NUM_THREADS' or 
+    'OMP_NUM_THREADS' env vars to set the initial number of threads used by 
+    the virtual machine.
+    """
+    # Any platform-specific short-circuits
+    if 'sparc' in version.platform_machine:
+        log.warning('The number of threads have been set to 1 because problems related '
+                  'to threading have been reported on some sparc machine. '
+                  'The number of threads can be changed using the "set_num_threads" '
+                  'function.')
+        set_num_threads(1)
+        return 1
+
+    env_configured = False
+    n_cores = detect_number_of_cores()
+    if ('NUMEXPR_MAX_THREADS' in os.environ and os.environ['NUMEXPR_MAX_THREADS'] != '' or
+        'OMP_NUM_THREADS' in os.environ and os.environ['OMP_NUM_THREADS'] != ''):
+        # The user has configured NumExpr in the expected way, so suppress logs.
+        env_configured = True
+        n_cores = MAX_THREADS
+    else:
+        # The use has not set 'NUMEXPR_MAX_THREADS', so likely they have not 
+        # 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 > 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.
+    if 'NUMEXPR_NUM_THREADS' in os.environ and os.environ['NUMEXPR_NUM_THREADS'] != '':
+        requested_threads = int(os.environ['NUMEXPR_NUM_THREADS'])
+    elif 'OMP_NUM_THREADS' in os.environ and os.environ['OMP_NUM_THREADS'] != '':
+        # Empty string is commonly used to unset the variable
+        requested_threads = int(os.environ['OMP_NUM_THREADS'])
+    else:
+        requested_threads = n_cores
+        if not env_configured:
+            log.info('NumExpr defaulting to %d threads.'%n_cores)
+
+    # The C-extension function performs its own checks against `MAX_THREADS`
+    set_num_threads(requested_threads)
+    return requested_threads
+
+    
+def detect_number_of_cores():
+    """
+    Detects the number of cores on a system. Cribbed from pp.
+    """
+    # Linux, Unix and MacOS:
+    if hasattr(os, "sysconf"):
+        if "SC_NPROCESSORS_ONLN" in os.sysconf_names:
+            # Linux & Unix:
+            ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
+            if isinstance(ncpus, int) and ncpus > 0:
+                return ncpus
+        else:  # OSX:
+            return int(subprocess.check_output(["sysctl", "-n", "hw.ncpu"]))
+    # Windows:
+    try:
+        ncpus = int(os.environ.get("NUMBER_OF_PROCESSORS", ""))
+        if ncpus > 0:
+            return ncpus
+    except ValueError:
+        pass
+    return 1  # Default
+
+
+def detect_number_of_threads():
+    """
+    DEPRECATED: use `_init_num_threads` instead.
+    If this is modified, please update the note in: https://github.com/pydata/numexpr/wiki/Numexpr-Users-Guide
+    """
+    log.warning('Deprecated, use `init_num_threads` instead.')
+    try:
+        nthreads = int(os.environ.get('NUMEXPR_NUM_THREADS', ''))
+    except ValueError:
+        try:
+            nthreads = int(os.environ.get('OMP_NUM_THREADS', ''))
+        except ValueError:
+            nthreads = detect_number_of_cores()
+
+    # Check that we don't surpass the MAX_THREADS in interpreter.cpp
+    if nthreads > MAX_THREADS:
+        nthreads = MAX_THREADS
+    return nthreads
+
+
+class CacheDict(dict):
+    """
+    A dictionary that prevents itself from growing too much.
+    """
+
+    def __init__(self, maxentries):
+        self.maxentries = maxentries
+        super(CacheDict, self).__init__(self)
+
+    def __setitem__(self, key, value):
+        # Protection against growing the cache too much
+        if len(self) > self.maxentries:
+            # Remove a 10% of (arbitrary) elements from the cache
+            entries_to_remove = self.maxentries // 10
+            for k in list(self.keys())[:entries_to_remove]:
+                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/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/win32/pthread.c

@@ -0,0 +1,218 @@
+/*
+ * Code for simulating pthreads API on Windows.  This is Git-specific,
+ * but it is enough for Numexpr needs too.
+ *
+ * Copyright (C) 2009 Andrzej K. Haczewski <ahaczewski@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * DISCLAIMER: The implementation is Git-specific, it is subset of original
+ * Pthreads API, without lots of other features that Git doesn't use.
+ * Git also makes sure that the passed arguments are valid, so there's
+ * no need for double-checking.
+ */
+
+#include "pthread.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+#include <process.h>
+
+
+void die(const char *err, ...)
+{
+    printf("%s", err);
+    exit(-1);
+}
+
+static unsigned __stdcall win32_start_routine(void *arg)
+{
+    pthread_t *thread = arg;
+    thread->arg = thread->start_routine(thread->arg);
+    return 0;
+}
+
+int pthread_create(pthread_t *thread, const void *unused,
+           void *(*start_routine)(void*), void *arg)
+{
+    thread->arg = arg;
+    thread->start_routine = start_routine;
+    thread->handle = (HANDLE)
+        _beginthreadex(NULL, 0, win32_start_routine, thread, 0, NULL);
+
+    if (!thread->handle)
+        return errno;
+    else
+        return 0;
+}
+
+int win32_pthread_join(pthread_t *thread, void **value_ptr)
+{
+    DWORD result = WaitForSingleObject(thread->handle, INFINITE);
+    switch (result) {
+        case WAIT_OBJECT_0:
+            if (value_ptr)
+                *value_ptr = thread->arg;
+            return 0;
+        case WAIT_ABANDONED:
+            return EINVAL;
+        default:
+            return GetLastError();
+    }
+}
+
+int pthread_cond_init(pthread_cond_t *cond, const void *unused)
+{
+    cond->waiters = 0;
+    cond->was_broadcast = 0;
+    InitializeCriticalSection(&cond->waiters_lock);
+
+    cond->sema = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
+    if (!cond->sema)
+        die("CreateSemaphore() failed");
+
+    cond->continue_broadcast = CreateEvent(NULL,    /* security */
+                FALSE,            /* auto-reset */
+                FALSE,            /* not signaled */
+                NULL);            /* name */
+    if (!cond->continue_broadcast)
+        die("CreateEvent() failed");
+
+    return 0;
+}
+
+int pthread_cond_destroy(pthread_cond_t *cond)
+{
+    CloseHandle(cond->sema);
+    CloseHandle(cond->continue_broadcast);
+    DeleteCriticalSection(&cond->waiters_lock);
+    return 0;
+}
+
+int pthread_cond_wait(pthread_cond_t *cond, CRITICAL_SECTION *mutex)
+{
+    int last_waiter;
+
+    EnterCriticalSection(&cond->waiters_lock);
+    cond->waiters++;
+    LeaveCriticalSection(&cond->waiters_lock);
+
+    /*
+     * Unlock external mutex and wait for signal.
+     * NOTE: we've held mutex locked long enough to increment
+     * waiters count above, so there's no problem with
+     * leaving mutex unlocked before we wait on semaphore.
+     */
+    LeaveCriticalSection(mutex);
+
+    /* let's wait - ignore return value */
+    WaitForSingleObject(cond->sema, INFINITE);
+
+    /*
+     * Decrease waiters count. If we are the last waiter, then we must
+     * notify the broadcasting thread that it can continue.
+     * But if we continued due to cond_signal, we do not have to do that
+     * because the signaling thread knows that only one waiter continued.
+     */
+    EnterCriticalSection(&cond->waiters_lock);
+    cond->waiters--;
+    last_waiter = cond->was_broadcast && cond->waiters == 0;
+    LeaveCriticalSection(&cond->waiters_lock);
+
+    if (last_waiter) {
+        /*
+         * cond_broadcast was issued while mutex was held. This means
+         * that all other waiters have continued, but are contending
+         * for the mutex at the end of this function because the
+         * broadcasting thread did not leave cond_broadcast, yet.
+         * (This is so that it can be sure that each waiter has
+         * consumed exactly one slice of the semaphor.)
+         * The last waiter must tell the broadcasting thread that it
+         * can go on.
+         */
+        SetEvent(cond->continue_broadcast);
+        /*
+         * Now we go on to contend with all other waiters for
+         * the mutex. Auf in den Kampf!
+         */
+    }
+    /* lock external mutex again */
+    EnterCriticalSection(mutex);
+
+    return 0;
+}
+
+/*
+ * IMPORTANT: This implementation requires that pthread_cond_signal
+ * is called while the mutex is held that is used in the corresponding
+ * pthread_cond_wait calls!
+ */
+int pthread_cond_signal(pthread_cond_t *cond)
+{
+    int have_waiters;
+
+    EnterCriticalSection(&cond->waiters_lock);
+    have_waiters = cond->waiters > 0;
+    LeaveCriticalSection(&cond->waiters_lock);
+
+    /*
+     * Signal only when there are waiters
+     */
+    if (have_waiters)
+        return ReleaseSemaphore(cond->sema, 1, NULL) ?
+            0 : GetLastError();
+    else
+        return 0;
+}
+
+/*
+ * DOUBLY IMPORTANT: This implementation requires that pthread_cond_broadcast
+ * is called while the mutex is held that is used in the corresponding
+ * pthread_cond_wait calls!
+ */
+int pthread_cond_broadcast(pthread_cond_t *cond)
+{
+    EnterCriticalSection(&cond->waiters_lock);
+
+    if ((cond->was_broadcast = cond->waiters > 0)) {
+        /* wake up all waiters */
+        ReleaseSemaphore(cond->sema, cond->waiters, NULL);
+        LeaveCriticalSection(&cond->waiters_lock);
+        /*
+         * At this point all waiters continue. Each one takes its
+         * slice of the semaphor. Now it's our turn to wait: Since
+         * the external mutex is held, no thread can leave cond_wait,
+         * yet. For this reason, we can be sure that no thread gets
+         * a chance to eat *more* than one slice. OTOH, it means
+         * that the last waiter must send us a wake-up.
+         */
+        WaitForSingleObject(cond->continue_broadcast, INFINITE);
+        /*
+         * Since the external mutex is held, no thread can enter
+         * cond_wait, and, hence, it is safe to reset this flag
+         * without cond->waiters_lock held.
+         */
+        cond->was_broadcast = 0;
+    } else {
+        LeaveCriticalSection(&cond->waiters_lock);
+    }
+    return 0;
+}

numexpr/win32/pthread.h

@@ -0,0 +1,119 @@
+/*
+ * Code for simulating pthreads API on Windows.  This is Git-specific,
+ * but it is enough for Numexpr needs too.
+ *
+ * Copyright (C) 2009 Andrzej K. Haczewski <ahaczewski@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * DISCLAIMER: The implementation is Git-specific, it is subset of original
+ * Pthreads API, without lots of other features that Git doesn't use.
+ * Git also makes sure that the passed arguments are valid, so there's
+ * no need for double-checking.
+ */
+
+#ifndef PTHREAD_H
+#define PTHREAD_H
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Defines that adapt Windows API threads to pthreads API
+ */
+#define pthread_mutex_t CRITICAL_SECTION
+
+#define pthread_mutex_init(a,b) InitializeCriticalSection((a))
+#define pthread_mutex_destroy(a) DeleteCriticalSection((a))
+#define pthread_mutex_lock EnterCriticalSection
+#define pthread_mutex_unlock LeaveCriticalSection
+
+/*
+ * Implement simple condition variable for Windows threads, based on ACE
+ * implementation.
+ *
+ * See original implementation: http://bit.ly/1vkDjo
+ * ACE homepage: http://www.cse.wustl.edu/~schmidt/ACE.html
+ * See also: http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
+ */
+typedef struct {
+	LONG waiters;
+	int was_broadcast;
+	CRITICAL_SECTION waiters_lock;
+	HANDLE sema;
+	HANDLE continue_broadcast;
+} pthread_cond_t;
+
+extern int pthread_cond_init(pthread_cond_t *cond, const void *unused);
+extern int pthread_cond_destroy(pthread_cond_t *cond);
+extern int pthread_cond_wait(pthread_cond_t *cond, CRITICAL_SECTION *mutex);
+extern int pthread_cond_signal(pthread_cond_t *cond);
+extern int pthread_cond_broadcast(pthread_cond_t *cond);
+
+/*
+ * Simple thread creation implementation using pthread API
+ */
+typedef struct {
+	HANDLE handle;
+	void *(*start_routine)(void*);
+	void *arg;
+} pthread_t;
+
+extern int pthread_create(pthread_t *thread, const void *unused,
+			  void *(*start_routine)(void*), void *arg);
+
+/*
+ * To avoid the need of copying a struct, we use small macro wrapper to pass
+ * pointer to win32_pthread_join instead.
+ */
+#define pthread_join(a, b) win32_pthread_join(&(a), (b))
+
+extern int win32_pthread_join(pthread_t *thread, void **value_ptr);
+
+/*
+ * The POSIX signal system has a more developed interface than what's in
+ * Windows. We create a no-op shim layer to proivde enough of the API to
+ * pretend to support what's used when creating threads on POSIX systems.
+ */
+typedef int sigset_t;
+enum sigop {
+    SIG_BLOCK,
+    SIG_UNBLOCK,
+    SIG_SETMASK
+};
+
+static inline int sigemptyset(sigset_t *sigs) { return 0; }
+static inline int sigfillset(sigset_t *sigs) { return 0; }
+static inline int sigaddset(sigset_t *sigs, int sig) { return 0; }
+static inline int sigdelset(sigset_t *sigs, int sig) { return 0; }
+static inline int pthread_sigmask(int how, sigset_t *newmask,
+                                  sigset_t *oldmask) { return 0; }
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* PTHREAD_H */