Merge branch 'master' into 246-go-faster

Author: ogrisel

.github/workflows/test.yml

@@ -29,10 +29,10 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v4
         with:
-          python-version: "3.12"
+          python-version: "3.14"
       - name: Install black
         run: |
-          pip install black==25.1.0
+          pip install black==26.5.1
       - name: Run black
         run: |
           black --check --diff .
@@ -73,9 +73,9 @@ jobs:
             INSTALL_OPENCV: "true"
 
           # MacOS env with OpenMP installed through homebrew
-          - name: py39_conda_homebrew_libomp
+          - name: py310_conda_homebrew_libomp
             os: macos-latest
-            PYTHON_VERSION: "3.9"
+            PYTHON_VERSION: "3.10"
             PACKAGER: "conda"
             BLAS: "openblas"
             CC_OUTER_LOOP: "clang"
@@ -101,16 +101,16 @@ jobs:
 
           # Linux environments to test that packages that comes with Ubuntu 22.04
           # are correctly handled.
-          - name: py39_ubuntu_atlas_gcc_gcc
+          - name: py310_ubuntu_atlas_gcc_gcc
             os: ubuntu-22.04
-            PYTHON_VERSION: "3.9"
+            PYTHON_VERSION: "3.10"
             PACKAGER: "ubuntu"
             APT_BLAS: "libatlas3-base libatlas-base-dev"
             CC_OUTER_LOOP: "gcc"
             CC_INNER_LOOP: "gcc"
-          - name: py39_ubuntu_openblas_gcc_gcc
+          - name: py310_ubuntu_openblas_gcc_gcc
             os: ubuntu-22.04
-            PYTHON_VERSION: "3.9"
+            PYTHON_VERSION: "3.10"
             PACKAGER: "ubuntu"
             APT_BLAS: "libopenblas-base libopenblas-dev"
             CC_OUTER_LOOP: "gcc"
@@ -125,11 +125,11 @@ jobs:
             CC_INNER_LOOP: "gcc"
             INSTALL_OPENCV: "true"
 
-          # Linux + Python 3.9 and homogeneous runtime nesting.
-          - name: py39_conda_openblas_clang_clang
+          # Linux + Python 3.10 and homogeneous runtime nesting.
+          - name: py310_conda_openblas_clang_clang
             os: ubuntu-latest
             PACKAGER: "conda"
-            PYTHON_VERSION: "3.9"
+            PYTHON_VERSION: "3.10"
             BLAS: "openblas"
             CC_OUTER_LOOP: "clang-18"
             CC_INNER_LOOP: "clang-18"

CHANGES.md

@@ -77,6 +77,9 @@
   closures that can abort after ``os.fork()`` on some libffi builds.
   https://github.com/joblib/threadpoolctl/pull/242
 
+- Dropped official support for Python 3.9.
+  https://github.com/joblib/threadpoolctl/pull/255
+
 3.6.0 (2025-03-13)
 ==================
 

README.md

@@ -176,10 +176,10 @@ in specific sections of your Python program:
 ...     a_squared = a @ a
 ```
 
-The threadpools can also be controlled via the object oriented API, which is especially
-useful to avoid searching through all the loaded shared libraries each time. It will
-however not act on libraries loaded after the instantiation of the
-`ThreadpoolController`:
+The threadpools can also be controlled via the object oriented API, which is
+especially useful to avoid searching through all the loaded shared libraries
+each time. **Note that it will not act on libraries loaded after the instantiation
+of the `ThreadpoolController`!**
 
 ```python
 >>> from threadpoolctl import ThreadpoolController
@@ -225,44 +225,40 @@ controlled libraries in that thread.** With Python's
 `concurrent.futures.ThreadPoolExecutor`, you can do so by passing in an
 initializer function that will get called on thread startup.
 
-```python
-from threadpoolctl import threadpool_limits
-from concurrent.futures import ThreadPoolExecutor
-
-# This top-level limiter doesn't actually change the limits initially; it is
-# there to ensure the limits are reset _after_ the Python thread pool is done.
-# This is necessary because some underlying limiting APIs operate on a
-# process-wide basis.
-with threadpool_limits():
-    # Make sure each Python worker thread also calls threadpool_limits(). If
-    # you're using another thread pool class, you will need to do so some other
-    # way.
-    with ThreadPoolExecutor(4, initializer=lambda: threadpool_limits(limits=1)) as pool:
-        # ... run some BLAS-using code in the thread pool ...
-        pool.map(somefunc, someargs)
-```
-
-Whenever `threadpool_limits` is called, it needs to do some work (inspecting and getting access to third-party shared libraries) that can take some time.
-To prevent the performance cost of doing this work every time, you can reuse a
-`ThreadpoolController` object:
+Whenever `threadpool_limits` is called, it creates a new `ThreadpoolController`,
+which needs to do some work (inspecting and getting access to third-party shared
+libraries) that can take some time. To prevent the performance cost of doing
+this work in all the threads, you can reuse a `ThreadpoolController` object
+across the threads.
 
 ```python
 from threadpoolctl import ThreadpoolController
 
-# This won't have any side-effects:
-CONTROLLER = ThreadpoolController()
+# This won't have any side-effects. Because it caches its list of loaded
+# libraries, you need to create a new one if you've imported or loaded any
+# relevant libraries in the interim. So storing this on module level may not be
+# a good idea if you e.g. only do `import numpy` later on.
+controller = ThreadpoolController()
 
 with (
-    CONTROLLER.limit(),
-    ThreadPoolExecutor(4, initializer=lambda: CONTROLLER.limit(limits=1)) as pool,
+    # This top-level limiter doesn't actually change the limits initially; it
+    # is there to ensure the limits are reset _after_ the Python thread pool is
+    # done. This is necessary because some underlying limiting APIs operate on
+    # a process-wide basis.
+    controller.limit(),
+    # Make sure each Python worker thread also calls threadpool_limits(). If
+    # you're using another thread pool class, you will need to do so some other
+    # way.
+    ThreadPoolExecutor(4, initializer=lambda: controller.limit(limits=1)) as pool,
 ):
     # ... run some BLAS-using code in the thread pool ...
     pool.map(somefunc, someargs)
 
 # Later...
+controller = ThreadpoolController()
 with (
-    CONTROLLER.limit(),
-    ThreadPoolExecutor(4, initializer=lambda: CONTROLLER.limit(limits=2)) as pool,
+    controller.limit(),
+    ThreadPoolExecutor(4, initializer=lambda: controller.limit(limits=2)) as pool,
 ):
     # ... run some BLAS-using code in the thread pool ...
     pool.map(somefunc, someargs)
@@ -273,11 +269,12 @@ You can also operate without a context manager:
 ```python
 from threadpoolctl import ThreadpoolController
 
-CONTROLLER = ThreadpoolController()
+controller = ThreadpoolController()
 try:
-    limiter = CONTROLLER.limit()
+    limiter = controller.limit()
     with ThreadPoolExecutor(
-            4, initializer=lambda: CONTROLLER.limit(limits=1)) as pool:
+        4, initializer=lambda: controller.limit(limits=1)
+    ) as pool:
         # ... run some BLAS-using code in the thread pool ...
         pool.map(somefunc, someargs)
 finally:

pyproject.toml

@@ -6,13 +6,12 @@ build-backend = "flit_core.buildapi"
 name = "threadpoolctl"
 authors = [{name = "Thomas Moreau", email = "thomas.moreau.2010@gmail.com"}]
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "BSD-3-Clause"
 dynamic = ["version", "description"]
 classifiers = [
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -27,7 +26,7 @@ homepage = "https://github.com/joblib/threadpoolctl"
 
 [tool.black]
 line-length = 88
-target_version = ['py39', 'py310', 'py311', 'py312', 'py313']
+target_version = ['py310', 'py311', 'py312', 'py313', 'py314']
 preview = true
 
 [tool.ruff]

tests/test_threadpoolctl.py

@@ -595,9 +595,6 @@ def test_command_line_command_flag():
         assert lib_info in this_process_info
 
 
-@pytest.mark.skipif(
-    sys.version_info < (3, 7), reason="need recent subprocess.run options"
-)
 def test_command_line_import_flag():
     result = subprocess.run(
         [