hpr 0.1.0__tar.gz

hpr-0.1.0/.github/workflows/publish-pypi.yml

@@ -0,0 +1,114 @@
+name: Publish TestPyPI-validated HPR to PyPI
+on:
+  workflow_dispatch:
+    inputs:
+      testpypi_run_id:
+        description: Successful TestPyPI publish run with download and GPU validation
+        required: true
+        type: string
+permissions:
+  contents: read
+jobs:
+  retrieve:
+    runs-on: ubuntu-24.04
+    outputs:
+      validated_sha: ${{ steps.candidate.outputs.validated_sha }}
+      version: ${{ steps.candidate.outputs.version }}
+    permissions:
+      actions: read
+      contents: read
+    steps:
+      - name: Require successful TestPyPI publication and installation verification
+        uses: actions/github-script@v7
+        env:
+          TESTPYPI_RUN_ID: ${{ inputs.testpypi_run_id }}
+        with:
+          script: |
+            const run = (await github.rest.actions.getWorkflowRun({ ...context.repo, run_id: Number(process.env.TESTPYPI_RUN_ID) })).data;
+            const repo = (await github.rest.repos.get(context.repo)).data;
+            if (run.conclusion !== 'success' || run.event !== 'workflow_dispatch' || run.path !== '.github/workflows/publish-testpypi.yml' || run.head_branch !== repo.default_branch || run.head_repository.full_name !== repo.full_name) {
+              throw new Error('Require a successful TestPyPI publication and GPU download validation on the default branch');
+            }
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - uses: actions/download-artifact@v4
+        with:
+          name: publish-candidate
+          path: dist
+          run-id: ${{ inputs.testpypi_run_id }}
+          github-token: ${{ github.token }}
+      - uses: actions/download-artifact@v4
+        with:
+          name: publish-evidence
+          path: evidence
+          run-id: ${{ inputs.testpypi_run_id }}
+          github-token: ${{ github.token }}
+      - run: cd dist && sha256sum -c ../evidence/SHA256SUMS
+      - name: Verify exact stable release file set
+        id: candidate
+        run: python packaging/verify_candidate.py dist evidence/candidate-manifest.json --stable --github-output "$GITHUB_OUTPUT"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pypi-candidate
+          path: dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pypi-candidate-evidence
+          path: evidence/*
+  publish:
+    needs: retrieve
+    runs-on: ubuntu-24.04
+    environment:
+      name: pypi
+      url: https://pypi.org/p/hpr
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: pypi-candidate
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+  verify-index:
+    needs: [retrieve, publish]
+    timeout-minutes: 60
+    concurrency:
+      group: hpr-a40-gpu
+      cancel-in-progress: false
+    env:
+      HPR_CONTAINER_ENGINE: ${{ vars.HPR_CONTAINER_ENGINE || 'podman' }}
+      HPR_GPU_DEVICE: ${{ vars.HPR_GPU_DEVICE || '0' }}
+    runs-on: [self-hosted, linux, x64, hpr-cuda-12-8, a40]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.retrieve.outputs.validated_sha }}
+      - name: Prepare Python 3.12 controller
+        run: |
+          python3.12 -m venv "$RUNNER_TEMP/hpr-controller"
+          echo "$RUNNER_TEMP/hpr-controller/bin" >> "$GITHUB_PATH"
+      - uses: actions/download-artifact@v4
+        with:
+          name: pypi-candidate
+          path: candidate
+      - name: Download the exact version from PyPI and verify SHA256
+        run: python packaging/download_candidate.py candidate index-download --index-url https://pypi.org/simple/
+      - name: Fetch pinned test inputs
+        run: python packaging/prepare_inputs.py --runtime-only
+      - name: Install pinned version from PyPI in a clean GPU container
+        run: |
+          set -o pipefail
+          python packaging/run_clean_container.py index-download/*.whl --engine "$HPR_CONTAINER_ENGINE" --device "$HPR_GPU_DEVICE" --index-url https://pypi.org/simple/ 2>&1 | tee pypi-pinned-validation.log
+      - name: Verify unversioned PyPI resolution matches this release
+        run: python packaging/download_candidate.py candidate latest-download --index-url https://pypi.org/simple/ --unversioned
+      - name: Install unversioned hpr in another clean GPU container
+        run: |
+          set -o pipefail
+          python packaging/run_clean_container.py latest-download/*.whl --engine "$HPR_CONTAINER_ENGINE" --device "$HPR_GPU_DEVICE" --index-url https://pypi.org/simple/ --unversioned 2>&1 | tee pypi-latest-validation.log
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: pypi-install-evidence
+          path: pypi-*-validation.log

hpr-0.1.0/.github/workflows/publish-testpypi.yml

@@ -0,0 +1,115 @@
+name: Publish validated HPR to TestPyPI
+on:
+  workflow_dispatch:
+    inputs:
+      validation_run_id:
+        description: Successful Validate HPR workflow run containing the candidate
+        required: true
+        type: string
+permissions:
+  contents: read
+jobs:
+  retrieve:
+    runs-on: ubuntu-24.04
+    outputs:
+      validated_sha: ${{ steps.verify.outputs.result }}
+    permissions:
+      actions: read
+      contents: read
+    steps:
+      - name: Require a successful manual validation on the default branch
+        id: verify
+        uses: actions/github-script@v7
+        env:
+          VALIDATION_RUN_ID: ${{ inputs.validation_run_id }}
+        with:
+          script: |
+            const run = (await github.rest.actions.getWorkflowRun({ ...context.repo, run_id: Number(process.env.VALIDATION_RUN_ID) })).data;
+            const repo = (await github.rest.repos.get(context.repo)).data;
+            if (run.conclusion !== 'success' || run.event !== 'workflow_dispatch' || run.path !== '.github/workflows/validate.yml' || run.head_branch !== repo.default_branch || run.head_repository.full_name !== repo.full_name) {
+              throw new Error('Candidate must come from a successful manual validation of the default branch');
+            }
+            return run.head_sha;
+      - uses: actions/download-artifact@v4
+        with:
+          name: hpr-validated-candidate
+          path: dist
+          run-id: ${{ inputs.validation_run_id }}
+          github-token: ${{ github.token }}
+      - uses: actions/download-artifact@v4
+        with:
+          name: hpr-validation-evidence
+          path: evidence
+          run-id: ${{ inputs.validation_run_id }}
+          github-token: ${{ github.token }}
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ fromJSON(steps.verify.outputs.result) }}
+          path: release-tools
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: cd dist && sha256sum -c ../evidence/SHA256SUMS
+      - run: python release-tools/packaging/verify_candidate.py dist evidence/candidate-manifest.json
+      - uses: actions/upload-artifact@v4
+        with:
+          name: publish-evidence
+          path: |
+            evidence/candidate-manifest.json
+            evidence/SHA256SUMS
+      - uses: actions/upload-artifact@v4
+        with:
+          name: publish-candidate
+          path: dist/*
+  publish:
+    needs: retrieve
+    runs-on: ubuntu-24.04
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/hpr
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: publish-candidate
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+  verify-index:
+    needs: [retrieve, publish]
+    timeout-minutes: 30
+    concurrency:
+      group: hpr-a40-gpu
+      cancel-in-progress: false
+    env:
+      HPR_CONTAINER_ENGINE: ${{ vars.HPR_CONTAINER_ENGINE || 'podman' }}
+    runs-on: [self-hosted, linux, x64, hpr-cuda-12-8, a40]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ fromJSON(needs.retrieve.outputs.validated_sha) }}
+      - name: Prepare the Python 3.12 controller on the GPU runner
+        run: |
+          python3.12 -m venv "$RUNNER_TEMP/hpr-controller"
+          echo "$RUNNER_TEMP/hpr-controller/bin" >> "$GITHUB_PATH"
+      - uses: actions/download-artifact@v4
+        with:
+          name: publish-candidate
+          path: candidate
+      - name: Download exactly the uploaded wheel from TestPyPI
+        run: python packaging/download_candidate.py candidate index-download --index-url https://test.pypi.org/simple/
+      - name: Fetch pinned runtime inputs
+        run: python packaging/prepare_inputs.py --runtime-only
+      - name: Repeat clean GPU validation on the downloaded bytes
+        env:
+          HPR_GPU_DEVICE: ${{ vars.HPR_GPU_DEVICE || '0' }}
+        run: |
+          set -o pipefail
+          python packaging/run_clean_container.py index-download/*.whl --engine "$HPR_CONTAINER_ENGINE" --device "$HPR_GPU_DEVICE" 2>&1 | tee testpypi-validation.log
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: testpypi-install-evidence
+          path: testpypi-validation.log

hpr-0.1.0/.github/workflows/validate.yml

@@ -0,0 +1,66 @@
+name: Validate HPR
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  cpu-development:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: python -m pip install build scikit-build-core==1.1.1 pybind11==3.1.0 patchelf==0.19.1.0 pytest numpy scipy
+      - run: python -m pytest packaging/tests/test_release_tools.py
+      - run: python scripts/build_cpu_dev.py
+      - run: python -m pip install --no-deps dist-dev/*+cpu.internal-*.whl
+      - run: python -m pytest tests/test_contract.py
+      - name: Reject the partial artifact for release
+        run: if python scripts/check_wheel.py dist-dev/*+cpu.internal-*.whl; then exit 1; fi
+  gpu-candidate:
+    if: github.event_name == 'workflow_dispatch'
+    runs-on: [self-hosted, linux, x64, hpr-cuda-12-8, a40]
+    timeout-minutes: 90
+    concurrency:
+      group: hpr-a40-gpu
+      cancel-in-progress: false
+    env:
+      HPR_CONTAINER_ENGINE: ${{ vars.HPR_CONTAINER_ENGINE || 'podman' }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Prepare the Python 3.12 controller on the GPU runner
+        run: |
+          python3.12 -m venv "$RUNNER_TEMP/hpr-controller"
+          echo "$RUNNER_TEMP/hpr-controller/bin" >> "$GITHUB_PATH"
+      - name: Build in the pinned manylinux environment from final sdist
+        run: python packaging/run_release.py --engine "$HPR_CONTAINER_ENGINE"
+      - name: Validate the final wheel in a source-free GPU container
+        env:
+          HPR_GPU_DEVICE: ${{ vars.HPR_GPU_DEVICE || '0' }}
+        run: |
+          set -o pipefail
+          python packaging/run_clean_container.py dist-release/*.whl --engine "$HPR_CONTAINER_ENGINE" --device "$HPR_GPU_DEVICE" 2>&1 | tee artifacts/manylinux/logs/clean-runtime.log
+      - name: Additional GPU verification at the glibc 2.28 floor
+        env:
+          HPR_GPU_DEVICE: ${{ vars.HPR_GPU_DEVICE || '0' }}
+        run: |
+          set -o pipefail
+          python packaging/run_clean_container.py dist-release/*.whl --baseline --engine "$HPR_CONTAINER_ENGINE" --device "$HPR_GPU_DEVICE" 2>&1 | tee artifacts/manylinux/logs/baseline-runtime.log
+      - run: python -m pip install twine==6.2.0
+      - run: python -m twine check dist-release/*
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: hpr-validation-evidence
+          path: |
+            artifacts/manylinux/logs/
+            artifacts/manylinux/candidate-manifest.json
+            artifacts/manylinux/SHA256SUMS
+            artifacts/manylinux/builder-rpms.txt
+      - uses: actions/upload-artifact@v4
+        with:
+          name: hpr-validated-candidate
+          path: dist-release/*

hpr-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv*/
+build/
+dist*/
+__pycache__/
+*.pyc
+.pytest_cache/
+artifacts/

hpr-0.1.0/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## 0.1.0
+
+- First stable unified HPR package with `hpr.lp(...)` and `hpr.qp(...)`.
+- Support CPython 3.12, Linux x86-64, glibc >= 2.28 and CUDA 12.8;
+  GPU validation is limited to NVIDIA A40 / SM86 (driver 575.57.08).
+- Rebuild solvers, polishing worker and bundled native dependencies in a
+  digest-pinned manylinux environment, then build the wheel from the final sdist.
+- Validate numerical solves, alternating engines, polishing, runtime loading,
+  and uninstall/reinstall in clean GPU containers.
+- Promote the exact TestPyPI-validated wheel and sdist to PyPI using Trusted
+  Publishing, with SHA256 checks and versioned/unversioned installation checks.
+
+## 0.1.0.dev2 (TestPyPI)
+
+- Validate the manylinux build and clean GPU installation through remote CI.
+- Publish the development candidate to TestPyPI and verify the downloaded bytes.
+
+## 0.1.0.dev1 (unpublished)
+
+- Import pinned LP 0.1.3 and QP 0.1.0 sources into one HPR distribution.
+- Add common LP/QP functions, input validation, results, lazy loading and diagnostics.
+- Bundle LP/QP libraries, LP pybind11 extension and QP polishing worker.
+- Pin CUDA 12.8 runtime dependencies and use package-relative loading.
+- Add source-package, artifact-integrity and installed numerical checks.

hpr-0.1.0/CMakeLists.txt

@@ -0,0 +1,75 @@
+cmake_minimum_required(VERSION 3.26)
+project(HPR LANGUAGES C CXX)
+option(HPR_BUILD_LP "Build LP" ON)
+option(HPR_BUILD_QP "Build QP" ON)
+option(HPR_QP_ENABLE_CUDA "Build QP CUDA and native polishing" ON)
+option(HPR_DEVELOPER_PARTIAL_BUILD "Internal partial development build" OFF)
+if(NOT HPR_DEVELOPER_PARTIAL_BUILD AND (NOT HPR_BUILD_LP OR NOT HPR_BUILD_QP OR NOT HPR_QP_ENABLE_CUDA))
+  message(FATAL_ERROR "Complete HPR requires both LP and QP CUDA. Partial builds require explicit developer mode.")
+endif()
+if(HPR_DEVELOPER_PARTIAL_BUILD AND NOT SKBUILD_PROJECT_VERSION_FULL MATCHES "dev")
+  message(FATAL_ERROR "Partial builds require a development version")
+endif()
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_CXX_STANDARD 17)
+set(HPR_UNIFIED_BUILD ON)
+set(HPR_RUNTIME_DEPS "" CACHE PATH "Rebuilt runtime dependencies and licenses")
+set(CMAKE_BUILD_RPATH_USE_ORIGIN ON)
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH OFF)
+set(CMAKE_INSTALL_RPATH "$ORIGIN;$ORIGIN/../_lib")
+find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
+set(Python3_EXECUTABLE "${Python_EXECUTABLE}")
+find_package(pybind11 CONFIG REQUIRED)
+if(HPR_BUILD_LP OR HPR_QP_ENABLE_CUDA)
+  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    message(FATAL_ERROR "Set CMAKE_CUDA_ARCHITECTURES explicitly (tested: 86)")
+  endif()
+  enable_language(CUDA)
+  find_package(CUDAToolkit REQUIRED)
+  if(NOT CUDAToolkit_VERSION VERSION_GREATER_EQUAL 12.8 OR NOT CUDAToolkit_VERSION VERSION_LESS 12.9)
+    message(FATAL_ERROR "This candidate is pinned to CUDA Toolkit 12.8")
+  endif()
+endif()
+function(hpr_add_lp)
+ set(BUILD_STATIC_LIB OFF)
+ set(BUILD_SHARED_LIB ON)
+ set(BUILD_PYTHON_BINDINGS OFF)
+ set(BUILD_TESTING OFF)
+ add_subdirectory(native/lp)
+endfunction()
+function(hpr_add_qp)
+ set(BUILD_SHARED_LIBS ON)
+ set(HPRQP_ENABLE_CUDA ${HPR_QP_ENABLE_CUDA})
+ set(HPRQP_REQUIRE_CUDSS ON)
+ set(HPRQP_CHECK_CUDA_DRIVER OFF)
+ add_subdirectory(native/qp)
+endfunction()
+if(HPR_BUILD_LP)
+ hpr_add_lp()
+ pybind11_add_module(_hprlp_core bindings/native/hprlp_pybind.cpp)
+ target_compile_definitions(_hprlp_core PRIVATE _GLIBCXX_USE_CXX11_ABI=0)
+ target_link_libraries(_hprlp_core PRIVATE hprlp_shared)
+ target_include_directories(_hprlp_core PRIVATE native/lp/include ${CUDAToolkit_INCLUDE_DIRS})
+ install(TARGETS _hprlp_core LIBRARY DESTINATION hpr/_native COMPONENT HPR)
+ install(TARGETS hprlp_shared LIBRARY DESTINATION hpr/_lib COMPONENT HPR NAMELINK_COMPONENT HPR)
+endif()
+if(HPR_BUILD_QP)
+ hpr_add_qp()
+ set_target_properties(hprqp PROPERTIES INSTALL_RPATH "$ORIGIN" INSTALL_RPATH_USE_LINK_PATH OFF)
+ install(TARGETS hprqp LIBRARY DESTINATION hpr/_lib COMPONENT HPR NAMELINK_COMPONENT HPR)
+ if(TARGET hprqp_polish_worker)
+  set_target_properties(hprqp_polish_worker PROPERTIES INSTALL_RPATH "$ORIGIN/../_lib" INSTALL_RPATH_USE_LINK_PATH OFF)
+  install(TARGETS hprqp_polish_worker RUNTIME DESTINATION hpr/_bin COMPONENT HPR)
+ endif()
+endif()
+configure_file(native/SOURCES.json "${CMAKE_CURRENT_BINARY_DIR}/_sources.json" COPYONLY)
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_sources.json" DESTINATION hpr COMPONENT HPR)
+set(HPR_PARTIAL_JSON false)
+if(HPR_DEVELOPER_PARTIAL_BUILD)
+ set(HPR_PARTIAL_JSON true)
+endif()
+configure_file(cmake/build_info.json.in "${CMAKE_CURRENT_BINARY_DIR}/_build_info.json" @ONLY)
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_build_info.json" DESTINATION hpr COMPONENT HPR)
+install(DIRECTORY licenses/ DESTINATION hpr/licenses COMPONENT HPR)
+configure_file(cmake/install_runtime.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/install_runtime.cmake" @ONLY)
+install(SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/install_runtime.cmake" COMPONENT HPR)

hpr-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,13 @@
+# Contributing
+
+Use `native/SOURCES.json` to identify engine snapshots. Import future upstream
+changes as explicit reviewed commits; preserve source licenses and update the
+local-changes list. Public Python code is maintained in `src/hpr`, glue in
+`bindings/native`, and joint build changes in root CMake / `cmake` / `scripts`.
+Original Python distribution configurations under `native/` are upstream
+reference files, not additional installed HPR projects.
+
+Build and test complete wheels before changing support claims. A partial CPU
+artifact is internal development output and must fail the release integrity gate.
+Record exact source commits, wheel hashes, environment and numerical evidence.
+Do not publish until the release gaps in `docs/BUILD_ZH.md` are resolved.

hpr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaihuang Chen, Defeng Sun, Yancheng Yuan, Guojun Zhang, Xinyuan Zhao
+
+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.

hpr-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: hpr
+Version: 0.1.0
+Summary: Unified HPR LP and convex QP solvers
+Maintainer: bay
+License-Expression: MIT
+License-File: LICENSE
+License-File: licenses/lp/LICENSE
+License-File: licenses/lp/third_party/GPU-Presolver-C/LICENSE
+License-File: licenses/lp/third_party/GPU-Presolver-C/cpp/third_party/cpu_presolve_reference/LICENSE
+License-File: licenses/lp/third_party/PSLP/LICENSE
+License-File: licenses/qp/LICENSE
+License-File: licenses/qp/third_party/SCIPY_LICENSE.txt
+License-File: licenses/qp/third_party/eigen/COPYING.APACHE
+License-File: licenses/qp/third_party/eigen/COPYING.BSD
+License-File: licenses/qp/third_party/eigen/COPYING.GPL
+License-File: licenses/qp/third_party/eigen/COPYING.LGPL
+License-File: licenses/qp/third_party/eigen/COPYING.MINPACK
+License-File: licenses/qp/third_party/eigen/COPYING.MPL2
+License-File: licenses/qp/third_party/eigen/COPYING.README
+License-File: licenses/qp/third_party/nlohmann/LICENSE.MIT
+License-File: licenses/qp/third_party/pocketfft/LICENSE.md
+License-File: licenses/qp/third_party/superlu/License.txt
+License-File: licenses/runtime/gcc/COPYING
+License-File: licenses/runtime/gcc/COPYING.LIB
+License-File: licenses/runtime/gcc/COPYING.RUNTIME
+License-File: licenses/runtime/gcc/COPYING3
+License-File: licenses/runtime/gcc/COPYING3.LIB
+License-File: licenses/runtime/libquadmath/COPYING.LIB.libquadmath
+License-File: licenses/runtime/openblas/LICENSE
+License-File: licenses/runtime/openssl-libs/LICENSE.txt
+License-File: licenses/runtime/zlib/README
+Project-URL: Repository, https://github.com/Simonsbay/hpr
+Project-URL: Issues, https://github.com/Simonsbay/hpr/issues
+Requires-Python: <3.13,>=3.12
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.12
+Requires-Dist: nvidia-cuda-runtime-cu12==12.8.90
+Requires-Dist: nvidia-nvjitlink-cu12==12.8.93
+Requires-Dist: nvidia-cublas-cu12==12.8.4.1
+Requires-Dist: nvidia-cusparse-cu12==12.5.8.93
+Requires-Dist: nvidia-cusolver-cu12==11.7.3.90
+Requires-Dist: nvidia-cufft-cu12==11.3.3.83
+Requires-Dist: nvidia-curand-cu12==10.3.9.90
+Requires-Dist: nvidia-cudss-cu12==0.7.1.6
+Requires-Dist: cuda-toolkit==12.8.1
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Provides-Extra: cvxpy
+Requires-Dist: cvxpy>=1.4; extra == "cvxpy"
+Description-Content-Type: text/markdown
+
+# HPR
+
+One Python package containing LP and convex QP engines.
+Validated target: Linux x86-64 with glibc >= 2.28 / CPython 3.12 / CUDA 12.8 / A40 (SM 86).
+
+Install from [PyPI](https://pypi.org/project/hpr/) in a Python 3.12 environment:
+
+```sh
+python -m pip install --index-url https://pypi.org/simple/ --only-binary=:all: hpr==0.1.0
+python -m pip check
+```
+
+GPU solving requires a compatible NVIDIA GPU and driver. A CUDA Toolkit or compiler
+is not needed for wheel installation. See the [0.1.0 release procedure](docs/RELEASE_0_1_0_ZH.md).
+
+```python
+import hpr
+import numpy as np
+A = np.array([[1., 1.]])
+lp = hpr.lp([1., 2.], A, row_lower=[1.], row_upper=[1.])
+qp = hpr.qp(2*np.eye(2), [-2., -4.], A, row_lower=[1.], row_upper=[1.])
+print(lp.status, lp.objective)  # approximately 1
+print(qp.status, qp.objective)  # approximately -3
+assert lp.success and qp.success
+assert np.isclose(lp.objective, 1.0, atol=1e-5)
+assert np.isclose(qp.objective, -3.0, atol=1e-5)
+```
+
+The manylinux build fixes the build image and source checksums, rebuilds native
+runtime dependencies for baseline x86-64, and validates the final sdist-derived
+wheel in a clean GPU container. NVIDIA runtime libraries are exact pip dependencies;
+the host supplies the driver. The recorded GPU configuration is A40 / SM 86 with
+driver 575.57.08. Other combinations remain unverified.
+[API and migration](docs/API_ZH.md), [reproducible build and release procedure](docs/MANYLINUX_RELEASE_ZH.md).

hpr-0.1.0/README.md

@@ -0,0 +1,34 @@
+# HPR
+
+One Python package containing LP and convex QP engines.
+Validated target: Linux x86-64 with glibc >= 2.28 / CPython 3.12 / CUDA 12.8 / A40 (SM 86).
+
+Install from [PyPI](https://pypi.org/project/hpr/) in a Python 3.12 environment:
+
+```sh
+python -m pip install --index-url https://pypi.org/simple/ --only-binary=:all: hpr==0.1.0
+python -m pip check
+```
+
+GPU solving requires a compatible NVIDIA GPU and driver. A CUDA Toolkit or compiler
+is not needed for wheel installation. See the [0.1.0 release procedure](docs/RELEASE_0_1_0_ZH.md).
+
+```python
+import hpr
+import numpy as np
+A = np.array([[1., 1.]])
+lp = hpr.lp([1., 2.], A, row_lower=[1.], row_upper=[1.])
+qp = hpr.qp(2*np.eye(2), [-2., -4.], A, row_lower=[1.], row_upper=[1.])
+print(lp.status, lp.objective)  # approximately 1
+print(qp.status, qp.objective)  # approximately -3
+assert lp.success and qp.success
+assert np.isclose(lp.objective, 1.0, atol=1e-5)
+assert np.isclose(qp.objective, -3.0, atol=1e-5)
+```
+
+The manylinux build fixes the build image and source checksums, rebuilds native
+runtime dependencies for baseline x86-64, and validates the final sdist-derived
+wheel in a clean GPU container. NVIDIA runtime libraries are exact pip dependencies;
+the host supplies the driver. The recorded GPU configuration is A40 / SM 86 with
+driver 575.57.08. Other combinations remain unverified.
+[API and migration](docs/API_ZH.md), [reproducible build and release procedure](docs/MANYLINUX_RELEASE_ZH.md).

hpr-0.1.0/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,17 @@
+# Third-party notices
+
+Original engine licenses and vendored dependency notices are preserved under
+`native/` and copied to `licenses/lp` and `licenses/qp`. Source provenance and
+local modifications are recorded in `native/SOURCES.json` and git history.
+
+The local binary candidate also collects the following host runtime components:
+OpenBLAS (BSD-3-Clause), GCC runtime libraries including libgfortran/libgomp
+(with applicable GCC Runtime Library Exception) and libquadmath (see its LGPL
+notice), OpenSSL 3 (Apache 2.0), and zlib. The corresponding installed license
+texts are under `licenses/runtime`. Each installed ELF and its hash is listed
+in `hpr/_runtime_manifest.json`; NVIDIA libraries and the driver are not copied
+into HPR. Pinned NVIDIA wheels carry their own licensing and metadata.
+
+A public release still needs a final third-party source/notice and redistribution
+review against the exact manylinux build artifacts. This local candidate is not
+represented as having completed that release review.