pyomp 0.4.0__tar.gz → 0.5.0__tar.gz

{pyomp-0.4.0 → pyomp-0.5.0}/.github/workflows/build-upload-wheels.yml

@@ -35,13 +35,13 @@ jobs:
       - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
 
       - name: Install cibuildwheel
-        run: python -m pip install cibuildwheel==3.1.4
+        run: python -m pip install cibuildwheel==3.3.1
 
       - name: Build wheels {{ matrix.os }}
         # Set LLVM_VERSION for the host to forward to the cibuildwheel
         # environment.
         env:
-          LLVM_VERSION: "15.0.7"
+          LLVM_VERSION: "20.1.8"
         run: python -m cibuildwheel --output-dir wheelhouse
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
@@ -58,7 +58,7 @@ jobs:
 
       - name: Build sdist
         env:
-          LLVM_VERSION: "15.0.7"
+          LLVM_VERSION: "20.1.8"
         run: pipx run build --sdist
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
@@ -73,8 +73,14 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, ubuntu-24.04-arm]
-        python-version: ['3.10', '3.11', '3.12', '3.13']
-        numba-version: ['0.61.0', '0.61.2']
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
+        numba-version: ['0.62.0', '0.62.1', '0.63.0', '0.63.1']
+        exclude:
+          - python-version: '3.14'
+            numba-version: '0.62.0'
+          - python-version: '3.14'
+            numba-version: '0.62.1'
+
     steps:
       - name: Download built wheels
         uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0

{pyomp-0.4.0 → pyomp-0.5.0}/.gitlab/jobs/tioga.yml

@@ -56,6 +56,7 @@ variables:
         - "3.11"
         - "3.12"
         - "3.13"
+        - "3.14"
 
 build-and-test-tioga:
   extends: [.base-job, .python-variants]

pyomp-0.5.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src/numba/openmp/libs *.py *.so *.a *.bc

{pyomp-0.4.0 → pyomp-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyomp
-Version: 0.4.0
+Version: 0.5.0
 Summary: Python OpenMP library based on Numba
 Maintainer-email: Giorgis Georgakoudis <georgakoudis1@llnl.gov>
 License-Expression: BSD-2-Clause
@@ -11,11 +11,11 @@ Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Compilers
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: LICENSE-OPENMP.txt
-Requires-Dist: numba<0.62,>=0.61
+Requires-Dist: numba<0.64,>=0.62
 Requires-Dist: lark
 Requires-Dist: cffi
 Requires-Dist: setuptools
@@ -68,6 +68,7 @@ conda install -c python-for-hpc -c conda-forge pyomp
 
 | PyOMP | Numba           |
 | ----- | --------------- |
+| 0.5.x | 0.62.x - 0.63.x |
 | 0.4.x | 0.61.x          |
 | 0.3.x | 0.57.x - 0.60.x |
 

{pyomp-0.4.0 → pyomp-0.5.0}/README.md

@@ -45,6 +45,7 @@ conda install -c python-for-hpc -c conda-forge pyomp
 
 | PyOMP | Numba           |
 | ----- | --------------- |
+| 0.5.x | 0.62.x - 0.63.x |
 | 0.4.x | 0.61.x          |
 | 0.3.x | 0.57.x - 0.60.x |
 

{pyomp-0.4.0 → pyomp-0.5.0}/buildscripts/cibuildwheel/setup-miniconda3.sh

@@ -23,6 +23,6 @@ echo "Miniconda installed"
 source "_stage/miniconda3/bin/activate" base
 export CONDA_PLUGINS_AUTO_ACCEPT_TOS=true
 
-# Create clangdev ${LLVM_VERSION}
-echo "Installing manylinux llvmdev ${LLVM_VERSION}..."
-conda create -n llvmdev-${LLVM_VERSION} -c conda-forge -q -y clang=${LLVM_VERSION} clang-tools=${LLVM_VERSION} llvmdev=${LLVM_VERSION}
+# Create conda environment with tools and libraries for the LLVM_VERSION.
+echo "Installing llvmdev ${LLVM_VERSION}..."
+conda create -n llvmdev-${LLVM_VERSION} -c conda-forge -q -y clang=${LLVM_VERSION} clangxx=${LLVM_VERSION} clang-tools=${LLVM_VERSION} llvmdev=${LLVM_VERSION} zstd

pyomp-0.5.0/buildscripts/conda-recipes/pyomp/meta.yaml

@@ -0,0 +1,77 @@
+{% set version = environ.get('GIT_DESCRIBE_TAG', '0.0.0').lstrip('v') %}
+{% set LLVM_VERSION = environ.get('LLVM_VERSION', '20.1.8') %}
+
+package:
+  name: pyomp
+  version: {{ version }}
+
+source:
+   path: ../../..
+
+build:
+  string: py{{ PY_VER }}h{{ PKG_HASH }}_{{GIT_DESCRIBE_HASH}}_{{ GIT_DESCRIBE_NUMBER }}
+  script_env:
+    - PY_VCRUNTIME_REDIST # [win]
+  script:
+    - export LLVM_VERSION={{ LLVM_VERSION }}
+    - export LLVM_DIR=${PREFIX}
+    - export CC=${PREFIX}/bin/clang
+    - export CXX=${PREFIX}/bin/clang++
+    - export VERBOSE=1
+    - export CPPFLAGS="-mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET} -isystem ${PREFIX}/include -D_FORTIFY_SOURCE=2" # [osx]
+    - export ENABLE_BUNDLED_LIBOMPTARGET=1 # [linux]
+    - rm -rf build dist src/*.egg-info
+    - {{ PYTHON }} -m pip install -v .
+
+requirements:
+  build:
+    - {{ compiler('c') }}
+    - {{ compiler('cxx') }}
+    # Add sysroot to ensure compatibility on linux builds.
+    - sysroot_linux-64       # [linux64]
+    - sysroot_linux-aarch64  # [aarch64]
+    - cmake
+    - ninja
+    - setuptools_scm
+    - elfutils # [linux]
+    - libffi # [linux]
+  host:
+    - python
+    - pip
+    # Add sysroot to ensure compatibility on linux builds.
+    - sysroot_linux-64       # [linux64]
+    - sysroot_linux-aarch64  # [aarch64]
+    - setuptools
+    - setuptools_scm
+    - numba >=0.62, <0.64
+    - clang {{ LLVM_VERSION }}
+    - clangxx {{ LLVM_VERSION }}
+    - clang-tools {{ LLVM_VERSION }}
+    - llvmdev {{ LLVM_VERSION }}
+    - zlib
+    # require llvm-openmp for the openmp cpu runtime.
+    - llvm-openmp {{ LLVM_VERSION }}
+    - elfutils # [linux]
+    - libffi # [linux]
+  run:
+    - python
+    - setuptools
+    - numba >=0.62, <0.64
+    # require llvm-openmp for the openmp cpu runtime.
+    - llvm-openmp {{ LLVM_VERSION }}
+    - lark
+    - cffi
+
+test:
+  commands:
+    - test -f $SP_DIR/numba/openmp/libs/pass/libIntrinsicsOpenMP.dylib                 # [osx]
+    - test -f $SP_DIR/numba/openmp/libs/pass/libIntrinsicsOpenMP.so                    # [linux]
+    - test -f $SP_DIR/numba/openmp/libs/openmp/lib/libomptarget-amdgpu.bc        # [linux]
+    - test -f $SP_DIR/numba/openmp/libs/openmp/lib/libomptarget-nvptx.bc         # [linux]
+    - test -f $SP_DIR/numba/openmp/libs/openmp/lib/libomptarget.so               # [linux]
+
+about:
+  home: https://github.com/Python-for-HPC/PyOMP
+  license: BSD-2-Clause
+  license_file: LICENSE
+  summary: "PyOMP: OpenMP for portable CPU/GPU parallel programming in Python using Numba."

{pyomp-0.4.0 → pyomp-0.5.0}/buildscripts/gitlab/build-and-test.sh

@@ -4,11 +4,12 @@ set -e
 
 # Create a unique temporary directory for this job.
 TMPDIR=/tmp/pyomp/${CI_JOB_ID}
+rm -rf ${TMPDIR}
 mkdir -p ${TMPDIR}
 pushd ${TMPDIR}
 
 # Set the LLVM_VERSION to use.
-export LLVM_VERSION="15.0.7"
+export LLVM_VERSION="20.1.8"
 
 # Set the envs directory under the temporary directory.
 export CONDA_ENVS_DIRS="${TMPDIR}/_stage/miniconda3/envs"
@@ -17,14 +18,18 @@ export CONDA_ENVS_DIRS="${TMPDIR}/_stage/miniconda3/envs"
 source ${CI_PROJECT_DIR}/buildscripts/cibuildwheel/setup-miniconda3.sh
 
 # Export environment variables for building and testing.
+export ENABLE_BUNDLED_LIBOMP="1"
+export ENABLE_BUNDLED_LIBOMPTARGET="1"
 export LLVM_DIR="${CONDA_ENVS_DIRS}/llvmdev-${LLVM_VERSION}"
-export PATH="${CONDA_ENVS_DIRS}/llvmdev-${LLVM_VERSION}/bin:${PATH}"
+export CMAKE_PREFIX_PATH="${CONDA_PREFIX}"
 export USE_CXX11_ABI="1"
 export PIP_NO_INPUT="1"
 
 # Create and activate a conda environment with the desired Python version.
 conda create -n py-${PYOMP_CI_PYTHON_VERSION} -c conda-forge -y python=${PYOMP_CI_PYTHON_VERSION}
 conda activate py-${PYOMP_CI_PYTHON_VERSION}
+# Add extra packages needed to build openmp libraries.
+conda install -c conda-forge -y zstd libffi
 
 # Clone and fetch the commit with history for package versioning.
 git clone https://github.com/${GITHUB_PROJECT_ORG}/${GITHUB_PROJECT_NAME}.git --single-branch
@@ -33,7 +38,7 @@ git fetch origin ${CI_COMMIT_SHA}
 git checkout ${CI_COMMIT_SHA}
 
 # Install pyomp.
-CC=gcc CXX=g++ python -m pip install -v .
+CC=clang CXX=clang++ python -m pip install -v .
 
 # Run host OpenMP tests.
 TEST_DEVICES=0 RUN_TARGET=0 python -m numba.runtests -v -- numba.openmp.tests.test_openmp

{pyomp-0.4.0 → pyomp-0.5.0}/examples/ploop.1.py

@@ -1,13 +1,14 @@
-import numba
+from numba.openmp import njit
 from numba.openmp import openmp_context as openmp
-from numba.openmp import omp_set_num_threads, omp_get_thread_num, omp_get_num_threads, omp_get_wtime
 import numpy as np
 
-@numba.njit
+
+@njit
 def simple(n, a, b):
     with openmp("parallel for"):
         for i in range(1, n):
-            b[i] = (a[i] + a[i-1]) / 2.0
+            b[i] = (a[i] + a[i - 1]) / 2.0
+
 
 a = np.ones(100)
 b = np.empty(len(a))

{pyomp-0.4.0 → pyomp-0.5.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=75.3", "wheel", "setuptools-scm>=8", "cmake>=3.20"]
+requires = ["setuptools>=75.3", "setuptools-scm>=8", "cmake>=3.20", "ninja"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -7,7 +7,7 @@ name = "pyomp"
 dynamic = ["version"]
 description = "Python OpenMP library based on Numba"
 readme = "README.md"
-requires-python = ">=3.10, <3.14"
+requires-python = ">=3.10, <3.15"
 license = "BSD-2-Clause"
 license-files = ["LICENSE", "LICENSE-OPENMP.txt"]
 classifiers = [
@@ -17,7 +17,7 @@ classifiers = [
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Compilers",
 ]
-dependencies = ["numba>=0.61, <0.62", "lark", "cffi", "setuptools"]
+dependencies = ["numba>=0.62, <0.64", "lark", "cffi", "setuptools"]
 maintainers = [
     { name = "Giorgis Georgakoudis", email = "georgakoudis1@llnl.gov" },
 ]
@@ -37,7 +37,7 @@ include = ["numba.openmp*"]
 
 # Bundle the CMake-installed artifacts into the wheel.
 [tool.setuptools.package-data]
-"numba.openmp.libs" = ["pass/*", "libomp/**/*"]
+"numba.openmp.libs" = ["pass/*", "openmp/**/*"]
 
 # setuptools-scm config
 [tool.setuptools_scm]
@@ -49,7 +49,6 @@ archs = ["native"]
 # Pass LLVM_VERSION from the host environment to cibuildwheel.
 environment-pass = ["LLVM_VERSION"]
 # We use miniconda3 to get the clang/llvm toolchain on Linux.
-before-all = ["bash buildscripts/cibuildwheel/setup-miniconda3.sh"]
 before-build = ["rm -rf build dist src/*.egg-info"]
 skip = ["*-musllinux_*", "cp38-*"]
 test-command = [
@@ -59,14 +58,32 @@ test-command = [
     "OMP_TARGET_OFFLOAD=mandatory TEST_DEVICES=1 RUN_TARGET=1 python -m numba.runtests -v -- numba.openmp.tests.test_openmp.TestOpenmpTarget",
 ]
 
+[tool.cibuildwheel.environment]
+USE_CXX11_ABI = "1"
+PIP_NO_INPUT = "1"
+
 [tool.cibuildwheel.linux]
 before-all = [
-    "yum install -y elfutils-libelf-devel libffi-devel",
-    "bash buildscripts/cibuildwheel/setup-miniconda3.sh",
+    "yum install -y elfutils-libelf-devel libffi-devel clang-devel-20.1.8 llvm-devel-20.1.8",
 ]
 
-[tool.cibuildwheel.environment]
-LLVM_DIR = "${PWD}/_stage/miniconda3/envs/llvmdev-${LLVM_VERSION}"
-PATH = "${PWD}/_stage/miniconda3/envs/llvmdev-${LLVM_VERSION}/bin:${PATH}"
-USE_CXX11_ABI = "1"
-PIP_NO_INPUT = "1"
+[tool.cibuildwheel.linux.environment]
+ENABLE_BUNDLED_LIBOMP = "1"
+ENABLE_BUNDLED_LIBOMPTARGET = "1"
+LLVM_DIR = "/usr/lib64/cmake/llvm"
+CC = "/usr/bin/clang"
+CXX = "/usr/bin/clang++"
+
+[tool.cibuildwheel.macos]
+before-all = ["bash buildscripts/cibuildwheel/setup-miniconda3.sh"]
+
+[tool.cibuildwheel.macos.environment]
+ENABLE_BUNDLED_LIBOMP = "1"
+LLVM_DIR = "${PWD}/_stage/miniconda3/envs/llvmdev-${LLVM_VERSION}/lib/cmake/llvm"
+CC = "${PWD}/_stage/miniconda3/envs/llvmdev-${LLVM_VERSION}/bin/clang"
+CXX = "${PWD}/_stage/miniconda3/envs/llvmdev-${LLVM_VERSION}/bin/clang++"
+# Set the deplioyment target to macOS 11.0.
+MACOSX_DEPLOYMENT_TARGET = "11.0"
+# Set the cmake prefix path to find libraries in the conda environment which is
+# compatible with the macos target.
+CMAKE_PREFIX_PATH = "${PWD}/_stage/miniconda3/envs/llvmdev-${LLVM_VERSION}/"

pyomp-0.5.0/setup.py

@@ -0,0 +1,288 @@
+from pathlib import Path
+import subprocess
+import shutil
+import tarfile
+import urllib
+import sys
+import os
+from setuptools import setup, Extension
+from setuptools import Command
+from setuptools.command.build_ext import build_ext
+from setuptools.command.bdist_wheel import bdist_wheel
+
+
+class CleanCommand(Command):
+    """Custom clean command to tidy up the project root."""
+
+    user_options = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        for path in ["build", "dist", "src/numba/openmp/libs"]:
+            shutil.rmtree(path, ignore_errors=True)
+        for egg_info in Path("src").rglob("*.egg-info"):
+            shutil.rmtree(egg_info, ignore_errors=True)
+
+
+class CustomBdistWheel(bdist_wheel):
+    def run(self):
+        # Ensure all build steps are run before bdist_wheel
+        self.run_command("build_ext")
+        super().run()
+
+
+class CMakeExtension(Extension):
+    def __init__(
+        self,
+        name,
+        *,
+        source_dir=None,
+        install_dir=None,
+        url=None,
+        sha256=None,
+        cmake_args=[],
+    ):
+        # Don't invoke the original build_ext for this special extension.
+        super().__init__(name, sources=[])
+        if source_dir and url:
+            raise ValueError(
+                "CMakeExtension should have either a source_dir or a url, not both."
+            )
+        self.source_dir = source_dir
+        self.install_dir = install_dir
+        self.url = url
+        self.sha256 = sha256
+        self.cmake_args = cmake_args
+
+
+class BuildCMakeExt(build_ext):
+    def run(self):
+        for ext in self.extensions:
+            if isinstance(ext, CMakeExtension):
+                self._build_cmake(ext)
+            else:
+                super().run()
+
+    def finalize_options(self):
+        super().finalize_options()
+        # Create placeholder directories for package-data validation.
+        Path("src/numba/openmp/libs/openmp/lib").mkdir(parents=True, exist_ok=True)
+
+    def _build_cmake(self, ext: CMakeExtension):
+        print("Build CMake extension:", ext.name)
+        # Delete build directory if it exists to avoid errors with stale
+        # CMakeCache.txt leftovers.
+        build_dir = Path(self.build_temp) / ext.name
+        shutil.rmtree(build_dir, ignore_errors=True)
+        build_dir.mkdir(parents=True, exist_ok=True)
+
+        lib_dir = Path(
+            self.get_finalized_command("build_py").get_package_dir("numba.openmp.libs")
+        )
+
+        extra_cmake_args = self._env_toolchain_args(ext)
+        # Set RPATH.
+        if sys.platform.startswith("linux"):
+            extra_cmake_args.append(r"-DCMAKE_INSTALL_RPATH=$ORIGIN")
+        elif sys.platform == "darwin":
+            extra_cmake_args.append(r"-DCMAKE_INSTALL_RPATH=@loader_path")
+
+        if ext.install_dir is None:
+            install_dir = Path(lib_dir) / ext.name
+        else:
+            install_dir = Path(lib_dir) / ext.install_dir
+        install_dir.mkdir(parents=True, exist_ok=True)
+
+        cfg = (
+            [
+                "cmake",
+                "-S",
+                ext.source_dir,
+                "-B",
+                build_dir,
+                "-G",
+                "Ninja",
+                "-DCMAKE_BUILD_TYPE=Release",
+                f"-DCMAKE_INSTALL_PREFIX={install_dir}",
+            ]
+            + ext.cmake_args
+            + extra_cmake_args
+        )
+        print("Configure cmake with args:", cfg)
+        subprocess.run(cfg, check=True, stdin=subprocess.DEVNULL)
+
+        print("Build at dir ", build_dir)
+        subprocess.run(
+            ["cmake", "--build", build_dir, "-j"], check=True, stdin=subprocess.DEVNULL
+        )
+        print("Install at dir ", install_dir)
+        subprocess.run(
+            ["cmake", "--install", build_dir], check=True, stdin=subprocess.DEVNULL
+        )
+
+        # Remove unnecessary files after installing libomp.
+        if ext.name.startswith("libomp"):
+            # Remove include directory after install.
+            include_dir = install_dir / "include"
+            if include_dir.exists():
+                shutil.rmtree(include_dir)
+            # Remove cmake directory after install.
+            include_dir = install_dir / "lib/cmake"
+            if include_dir.exists():
+                shutil.rmtree(include_dir)
+
+    def _env_toolchain_args(self, ext):
+        args = []
+        # Forward LLVM_DIR if provided.
+        if os.environ.get("LLVM_DIR"):
+            args.append(f"-DLLVM_DIR={os.environ['LLVM_DIR']}")
+        # Forward CC, CXX if provided.
+        if os.environ.get("CC"):
+            args.append(f"-DCMAKE_C_COMPILER={os.environ['CC']}")
+        if os.environ.get("CXX"):
+            args.append(f"-DCMAKE_CXX_COMPILER={os.environ['CXX']}")
+        return args
+
+
+def _prepare_source_openmp(sha256=None):
+    LLVM_VERSION = os.environ.get("LLVM_VERSION", None)
+    assert LLVM_VERSION is not None, "LLVM_VERSION environment variable must be set."
+    url = f"https://github.com/llvm/llvm-project/releases/download/llvmorg-{LLVM_VERSION}/llvm-project-{LLVM_VERSION}.src.tar.xz"
+
+    tmp = Path("_downloads/libomp") / f"llvm-project-{LLVM_VERSION}.tar.gz"
+    tmp.parent.mkdir(parents=True, exist_ok=True)
+
+    # Download the source tarball if it does not exist.
+    if not tmp.exists():
+        print(f"Downloading llvm-project version {LLVM_VERSION} url:", url)
+        with urllib.request.urlopen(url) as r:
+            with tmp.open("wb") as f:
+                f.write(r.read())
+    else:
+        print(f"Using downloaded llvm-project at {tmp}")
+
+    if sha256:
+        import hashlib
+
+        hasher = hashlib.sha256()
+        with tmp.open("rb") as f:
+            hasher.update(f.read())
+        if hasher.hexdigest() != sha256:
+            raise ValueError(f"SHA256 mismatch for {url}")
+
+    print("Extracting llvm-project...")
+    with tarfile.open(tmp) as tf:
+        # The root dir llvm-project-20.1.8.src
+        root_name = tf.getnames()[0]
+
+        # Extract only needed subdirectories
+        members = [
+            m
+            for m in tf.getmembers()
+            if m.name.startswith(f"{root_name}/openmp/")
+            or m.name.startswith(f"{root_name}/offload/")
+            or m.name.startswith(f"{root_name}/runtimes/")
+            or m.name.startswith(f"{root_name}/cmake/")
+            or m.name.startswith(f"{root_name}/llvm/cmake/")
+            or m.name.startswith(f"{root_name}/llvm/utils/")
+            or m.name.startswith(f"{root_name}/libc/")
+        ]
+
+        parentdir = tmp.parent
+        # Base arguments for extractall.
+        kwargs = {"path": parentdir, "members": members}
+
+        # Check if data filter is available.
+        if hasattr(tarfile, "data_filter"):
+            # If this exists, the 'filter' argument is guaranteed to work
+            kwargs["filter"] = "data"
+
+        tf.extractall(**kwargs)
+
+        source_dir = parentdir / root_name
+        print("Extracted llvm-project to:", source_dir)
+
+    print("Applying patches to llvm-project...")
+    for patch in sorted(
+        Path(f"src/numba/openmp/libs/openmp/patches/{LLVM_VERSION}")
+        .absolute()
+        .glob("*.patch")
+    ):
+        print("applying patch", patch)
+        subprocess.run(
+            ["patch", "-p1", "-i", str(patch)],
+            cwd=source_dir,
+            check=True,
+            stdin=subprocess.DEVNULL,
+        )
+
+    return f"{source_dir}/runtimes"
+
+
+def _check_true(env_var):
+    val = os.environ.get(env_var, "0")
+    return val.lower() in ("1", "true", "yes", "on")
+
+
+# Build extensions: always include 'pass', conditionally include 'openmp'
+# libraries.
+ext_modules = [CMakeExtension("pass", source_dir="src/numba/openmp/libs/pass")]
+
+
+# Prepare source directory if either bundled libomp or libomptarget is enabled.
+if _check_true("ENABLE_BUNDLED_LIBOMP") or _check_true("ENABLE_BUNDLED_LIBOMPTARGET"):
+    openmp_source_dir = _prepare_source_openmp()
+
+# Optionally enable bundled libomp build via ENABLE_BUNDLED_LIBOMP=1.  We want
+# to avoid bundling for conda builds to avoid duplicate OpenMP runtime conflicts
+# (e.g., numba 0.62+ and libopenblas already require llvm-openmp).
+if _check_true("ENABLE_BUNDLED_LIBOMP"):
+    ext_modules.append(
+        CMakeExtension(
+            "libomp",
+            source_dir=openmp_source_dir,
+            install_dir="openmp",
+            cmake_args=[
+                "-DOPENMP_STANDALONE_BUILD=ON",
+                "-DLLVM_ENABLE_RUNTIMES=openmp",
+                "-DLIBOMP_OMPD_SUPPORT=OFF",
+                "-DOPENMP_ENABLE_OMPT_TOOLS=OFF",
+                # Avoid conflicts in manylinux builds with packaged clang/llvm
+                # under /usr/include and its gcc-toolset provided header files.
+                "-DCMAKE_NO_SYSTEM_FROM_IMPORTED=ON",
+            ],
+        )
+    )
+
+# Optionally enable bundled libomptarget build via ENABLE_BUNDLED_LIBOMPTARGET=1.
+# We avoid building and bundling for unsupported platforms.
+if _check_true("ENABLE_BUNDLED_LIBOMPTARGET"):
+    ext_modules.append(
+        CMakeExtension(
+            "libomptarget",
+            source_dir=openmp_source_dir,
+            install_dir="openmp",
+            cmake_args=[
+                "-DOPENMP_STANDALONE_BUILD=ON",
+                "-DLLVM_ENABLE_RUNTIMES=offload",
+                # Avoid conflicts in manylinux builds with packaged clang/llvm
+                # under /usr/include and its gcc-toolset provided header files.
+                "-DCMAKE_NO_SYSTEM_FROM_IMPORTED=ON",
+            ],
+        )
+    )
+
+
+setup(
+    ext_modules=ext_modules,
+    cmdclass={
+        "clean": CleanCommand,
+        "build_ext": BuildCMakeExt,
+        **({"bdist_wheel": CustomBdistWheel} if CustomBdistWheel else {}),
+    },
+)

{pyomp-0.4.0 → pyomp-0.5.0}/src/numba/openmp/__init__.py

@@ -60,25 +60,45 @@ from .decorators import jit, njit  # noqa: F401
 
 def _init():
     sys_platform = sys.platform
+    from ctypes.util import find_library
 
     omplib = (
         libpath
-        / "libomp"
+        / "openmp"
         / "lib"
         / f"libomp{'.dylib' if sys_platform == 'darwin' else '.so'}"
     )
-    if DEBUG_OPENMP >= 1:
-        print("Found OpenMP runtime library at", omplib)
-    ll.load_library_permanently(str(omplib))
+
+    # Prefer bundled libomp if it exists.
+    if omplib.exists():
+        if DEBUG_OPENMP >= 1:
+            print("Found bundled OpenMP runtime library at", omplib)
+        ll.load_library_permanently(str(omplib))
+    else:
+        # There is no bundled libomp, try to find it in standard library paths.
+        system_omplib = find_library("omp")
+        if system_omplib:
+            if DEBUG_OPENMP >= 1:
+                print(f"Found system OpenMP runtime library: {system_omplib}")
+            ll.load_library_permanently(system_omplib)
+        else:
+            raise RuntimeError(
+                f"OpenMP runtime not found. Bundled library missing at {omplib} "
+                "and no system libomp found via ctypes.util.find_library('omp'). "
+                "Ensure libomp is available in library paths."
+            )
 
     # libomptarget is unavailable on apple, windows, so return.
     if sys_platform.startswith("darwin") or sys_platform.startswith("win32"):
         return
 
-    omptargetlib = libpath / "libomp" / "lib" / "libomptarget.so"
-    if DEBUG_OPENMP >= 1:
-        print("Found OpenMP target runtime library at", omptargetlib)
-    ll.load_library_permanently(str(omptargetlib))
+    omptargetlib = libpath / "openmp" / "lib" / "libomptarget.so"
+    if omptargetlib.exists():
+        if DEBUG_OPENMP >= 1:
+            print("Found OpenMP target runtime library at", omptargetlib)
+        ll.load_library_permanently(str(omptargetlib))
+    else:
+        raise RuntimeError(f"OpenMP target runtime not found at {omptargetlib}")
 
 
 _init()

{pyomp-0.4.0 → pyomp-0.5.0}/src/numba/openmp/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
 
-__commit_id__ = commit_id = 'gd8780ff7f'
+__commit_id__ = commit_id = 'g6d955c9a6'