Add workflows to the project (#1)

* Add workflows to the project

* add tests

* don't run on python 3.13

Author: guilhermeleobas

.github/workflows/release.yml

@@ -46,4 +46,4 @@ jobs:
           name: Release ${{ github.event.release.tag_name }}
           commit: main
           body: Release ${{ github.event.release.tag_name }}
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -0,0 +1,77 @@
+name: Numba-cache-lock
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  pull_request:
+    branches:
+      - main
+
+# kill any previous running job on a new commit
+concurrency:
+  group: build-and-test-cache-lock-${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip-tests') }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ['3.12']
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+
+      - name: Install dependencies
+        run: poetry install --no-interaction
+
+      - name: Run black
+        run: poetry run black --check .
+
+      - name: Run ruff
+        run: poetry run ruff check .
+
+      - name: Run mypy
+        run: poetry run mypy .
+
+  test:
+    name:  ${{ matrix.os }} - Python v${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ['3.11', '3.12']
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+
+      - name: Install dependencies
+        run: poetry install --no-interaction
+
+      - name: Run tests
+        shell: bash -l {0}
+        run: |
+          poetry run python -m unittest discover -s tests

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "numba-cache-lock"
-version = "0.1.0"
+version = "0.1.0a1"
 description = "A caching system for Numba with file locking support"
 authors = [
     {name = "Guilherme Leobas"}
@@ -21,7 +21,6 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
 ]
 
 [project.urls]

src/numba_cache_lock/__init__.py

@@ -1,6 +1,6 @@
 import os
 from datetime import timedelta
-from typing import Final, Optional
+from typing import Final
 
 from flufl.lock import Lock
 from numba.core.caching import FunctionCache
@@ -41,9 +41,17 @@ def save_overload(self, sig, data):
 
 
 def patch_numba_cache(lifetime: timedelta = DEFAULT_LOCK_LIFETIME):
-    Dispatcher = dispatcher_registry[target_registry["CPU"]]
+    dispatcher = dispatcher_registry[target_registry["CPU"]]
 
     def enable_caching(self):
         self._cache = FileLockFunctionCache(self.py_func, lifetime=lifetime)
 
-    Dispatcher.enable_caching = enable_caching
+    dispatcher.enable_caching = enable_caching
+
+
+try:
+    from importlib.metadata import version
+except ImportError:
+    from importlib_metadata import version  # type: ignore[no-redef]
+
+__version__ = version("numba_cache_lock")

tests/cache_usecases.py

@@ -0,0 +1,15 @@
+from numba import jit
+
+from numba_cache_lock import patch_numba_cache
+
+patch_numba_cache()
+
+
+@jit(cache=True, nopython=True)
+def add_fn_usecase(x, y):
+    return x + y
+
+
+@jit(cache=True, nopython=True)
+def incr_fn_usecase(x):
+    return x + 1

tests/test_cache_lock.py

@@ -0,0 +1,42 @@
+import multiprocessing
+import os
+import unittest
+
+from numba.tests.test_caching import DispatcherCacheUsecasesTest
+
+
+class TestCacheLock(DispatcherCacheUsecasesTest):
+    here = os.path.dirname(__file__)
+    usecases_file = os.path.join(here, "cache_usecases.py")
+
+    def test_caching(self):
+        self.check_pycache(0)
+        mod = self.import_module()
+        self.check_pycache(0)
+
+        f = mod.add_fn_usecase
+        self.assertPreciseEqual(f(2, 3), 5)
+        self.check_pycache(2)  # 1 index, 1 data
+
+    def test_multiprocessing(self):
+        # Check caching works from multiple processes at once (#2028)
+        mod = self.import_module()
+        # Calling a pure Python caller of the JIT-compiled function is
+        # necessary to reproduce the issue.
+        f = mod.incr_fn_usecase
+        n = 3
+        try:
+            ctx = multiprocessing.get_context("spawn")
+        except AttributeError:
+            ctx = multiprocessing
+        pool = ctx.Pool(n)
+        args = range(n)
+        try:
+            res = sum(pool.imap(f, args))
+        finally:
+            pool.close()
+        self.assertEqual(res, sum(range(n)) + n)
+
+
+if __name__ == "__main__":
+    unittest.main()