ggml-python 0.0.38__tar.gz → 0.0.39__tar.gz

{ggml_python-0.0.38 → ggml_python-0.0.39}/.github/workflows/wheels-index.yaml

@@ -43,6 +43,9 @@ jobs:
           ./scripts/releases-to-pep-503.sh index/whl/cu125 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-cu125$'
           ./scripts/releases-to-pep-503.sh index/whl/cu130 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-cu130$'
           ./scripts/releases-to-pep-503.sh index/whl/cu132 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-cu132$'
+          ./scripts/releases-to-pep-503.sh index/whl/vulkan '^[v]?[0-9]+\.[0-9]+\.[0-9]+-vulkan$'
+          ./scripts/releases-to-pep-503.sh index/whl/rocm72 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-rocm72$'
+          ./scripts/releases-to-pep-503.sh index/whl/hip-radeon '^[v]?[0-9]+\.[0-9]+\.[0-9]+-hip-radeon$'
           ./scripts/releases-to-pep-503.sh index/whl/metal '^[v]?[0-9]+\.[0-9]+\.[0-9]+-metal$'
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3

ggml_python-0.0.39/.github/workflows/wheels-rocm.yaml

@@ -0,0 +1,227 @@
+name: Wheels ROCm
+
+on:
+  workflow_dispatch:
+    inputs:
+      amdgpu_targets:
+        description: AMDGPU targets to compile into the Linux ROCm wheel
+        required: false
+        default: gfx908;gfx90a;gfx942;gfx1030;gfx1100;gfx1101;gfx1102;gfx1150;gfx1151;gfx1200;gfx1201
+      windows_amdgpu_targets:
+        description: AMDGPU targets to compile into the Windows HIP Radeon wheel
+        required: false
+        default: gfx1150;gfx1151;gfx1200;gfx1201;gfx1100;gfx1101;gfx1102;gfx1030;gfx1031;gfx1032
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  build_wheels:
+    name: Build Wheel ${{ matrix.os }} ${{ matrix.pyver }} ROCm ${{ matrix.rocm }}
+    runs-on: ${{ matrix.os }}
+    container:
+      image: rocm/dev-ubuntu-22.04:${{ matrix.rocm }}-complete
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            pyver: "3.9"
+            rocm: "7.2.4"
+            amdgpu_targets: gfx908;gfx90a;gfx942;gfx1030;gfx1100;gfx1101;gfx1102;gfx1150;gfx1151;gfx1200;gfx1201
+
+    steps:
+      - name: Install system dependencies
+        run: |
+          apt-get update
+          apt-get install -y --no-install-recommends git cmake lsb-release ninja-build
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.pyver }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build wheel
+
+      - name: Build wheel
+        env:
+          MATRIX_AMDGPU_TARGETS: ${{ matrix.amdgpu_targets }}
+          INPUT_AMDGPU_TARGETS: ${{ inputs.amdgpu_targets }}
+        run: |
+          export ROCM_PATH="${ROCM_PATH:-/opt/rocm}"
+          export HIP_PATH="${HIP_PATH:-$ROCM_PATH}"
+          export PATH="$ROCM_PATH/bin:$ROCM_PATH/llvm/bin:$PATH"
+          export LD_LIBRARY_PATH="$ROCM_PATH/lib:$ROCM_PATH/lib64:${LD_LIBRARY_PATH:-}"
+          export CC="$ROCM_PATH/llvm/bin/clang"
+          export CXX="$ROCM_PATH/llvm/bin/clang++"
+          export HIPCXX="$ROCM_PATH/llvm/bin/clang"
+          export CMAKE_GENERATOR=Ninja
+
+          hipconfig --version
+          hipcc --version
+
+          rocm_tag="$(hipconfig --version | sed -E 's/^([0-9]+)\.([0-9]+).*/\1\2/')"
+          echo "ROCM_VERSION=$rocm_tag" >> "$GITHUB_ENV"
+
+          amdgpu_targets="${INPUT_AMDGPU_TARGETS:-$MATRIX_AMDGPU_TARGETS}"
+          export CMAKE_ARGS="-DGGML_HIP=on -DGGML_NATIVE=off -DGGML_AVX=off -DGGML_AVX2=off -DGGML_FMA=off -DGGML_F16C=off -DAMDGPU_TARGETS=$amdgpu_targets -DCMAKE_HIP_ARCHITECTURES=$amdgpu_targets"
+          python -m build --wheel
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-rocm${{ env.ROCM_VERSION }}-${{ matrix.os }}
+          path: dist/*.whl
+
+      - uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: dist/*
+          # Set tag_name to <tag>-rocm<rocm_version>.
+          tag_name: ${{ github.ref_name }}-rocm${{ env.ROCM_VERSION }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  build_wheels_windows_hip:
+    name: Build Wheel windows-2022 ${{ matrix.pyver }} HIP ${{ matrix.name }}
+    runs-on: windows-2022
+    env:
+      HIPSDK_INSTALLER_VERSION: "26.Q1"
+    strategy:
+      matrix:
+        include:
+          - name: radeon
+            pyver: "3.9"
+            amdgpu_targets: gfx1150;gfx1151;gfx1200;gfx1201;gfx1100;gfx1101;gfx1102;gfx1030;gfx1031;gfx1032
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.pyver }}
+          cache: "pip"
+
+      - name: Grab rocWMMA package
+        run: |
+          curl -o rocwmma.deb "https://repo.radeon.com/rocm/apt/7.2.1/pool/main/r/rocwmma-dev/rocwmma-dev_2.2.0.70201-81~24.04_amd64.deb"
+          7z x rocwmma.deb
+          7z x data.tar
+
+      - name: Cache ROCm installation
+        id: cache-rocm
+        uses: actions/cache@v4
+        with:
+          path: C:\Program Files\AMD\ROCm
+          key: cache-gha-rocm-${{ env.HIPSDK_INSTALLER_VERSION }}-${{ runner.os }}
+
+      - name: Install ROCm
+        if: steps.cache-rocm.outputs.cache-hit != 'true'
+        run: |
+          $ErrorActionPreference = "Stop"
+          Write-Host "Downloading AMD HIP SDK installer"
+          Invoke-WebRequest `
+            -Uri "https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-${{ env.HIPSDK_INSTALLER_VERSION }}-Win11-For-HIP.exe" `
+            -OutFile "${env:RUNNER_TEMP}\rocm-install.exe"
+          Write-Host "Installing AMD HIP SDK"
+          $proc = Start-Process "${env:RUNNER_TEMP}\rocm-install.exe" -ArgumentList '-install' -NoNewWindow -PassThru
+          $completed = $proc.WaitForExit(600000)
+          if (-not $completed) {
+            Write-Error "ROCm installation timed out after 10 minutes"
+            $proc.Kill()
+            exit 1
+          }
+          if ($proc.ExitCode -ne 0) {
+            Write-Error "ROCm installation failed with exit code $($proc.ExitCode)"
+            exit 1
+          }
+
+      - name: Verify ROCm
+        run: |
+          $clangPath = Get-ChildItem 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' | Select-Object -First 1
+          if (-not $clangPath) {
+            Write-Error "ROCm installation not found"
+            exit 1
+          }
+          & $clangPath.FullName --version
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build wheel
+
+      - name: Build wheel
+        env:
+          MATRIX_AMDGPU_TARGETS: ${{ matrix.amdgpu_targets }}
+          INPUT_AMDGPU_TARGETS: ${{ inputs.windows_amdgpu_targets }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          $hipPath = Resolve-Path 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' | Split-Path | Split-Path
+          $rocwmmaInclude = (Join-Path $PWD 'opt\rocm-7.2.1\include').Replace('\', '/')
+          $amdgpuTargets = if ($env:INPUT_AMDGPU_TARGETS) { $env:INPUT_AMDGPU_TARGETS } else { $env:MATRIX_AMDGPU_TARGETS }
+
+          $env:HIP_PATH = $hipPath
+          $env:ROCM_PATH = $hipPath
+          $env:CMAKE_PREFIX_PATH = $hipPath
+          $env:HIP_PLATFORM = 'amd'
+          $env:PATH = "$hipPath\bin;$env:PATH"
+          $env:CC = "$hipPath\bin\clang.exe"
+          $env:CXX = "$hipPath\bin\clang++.exe"
+          $env:HIPCXX = "$hipPath\bin\clang.exe"
+          $env:CMAKE_GENERATOR = 'Unix Makefiles'
+          $env:CXXFLAGS = "-I$rocwmmaInclude -Wno-ignored-attributes -Wno-nested-anon-types"
+          $env:CMAKE_ARGS = "-DGGML_HIP=ON -DGGML_HIP_ROCWMMA_FATTN=ON -DGGML_NATIVE=OFF -DGGML_AVX=OFF -DGGML_AVX2=OFF -DGGML_FMA=OFF -DGGML_F16C=OFF -DGPU_TARGETS=$amdgpuTargets"
+
+          python -m build --wheel
+
+      - name: Bundle ROCm runtime DLLs
+        run: |
+          $ErrorActionPreference = "Stop"
+          $hipPath = Resolve-Path 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' | Split-Path | Split-Path
+          $wheel = Get-ChildItem dist\*.whl | Select-Object -First 1
+          python -m wheel unpack $wheel.FullName -d wheel-unpacked
+          $wheelRoot = Get-ChildItem wheel-unpacked -Directory | Select-Object -First 1
+          $libDir = Join-Path $wheelRoot.FullName 'ggml\lib'
+          New-Item -ItemType Directory -Force $libDir | Out-Null
+
+          $dllPatterns = @(
+            'amdhip64.dll',
+            'hiprtc*.dll',
+            'libhipblas.dll',
+            'libhipblaslt.dll',
+            'rocblas.dll'
+          )
+          foreach ($pattern in $dllPatterns) {
+            Copy-Item (Join-Path $hipPath "bin\$pattern") $libDir -ErrorAction SilentlyContinue
+          }
+
+          New-Item -ItemType Directory -Force (Join-Path $libDir 'rocblas\library') | Out-Null
+          New-Item -ItemType Directory -Force (Join-Path $libDir 'hipblaslt\library') | Out-Null
+          Copy-Item "$hipPath\bin\rocblas\library\*" (Join-Path $libDir 'rocblas\library') -Recurse -Force
+          Copy-Item "$hipPath\bin\hipblaslt\library\*" (Join-Path $libDir 'hipblaslt\library') -Recurse -Force
+
+          Remove-Item dist\*.whl
+          python -m wheel pack $wheelRoot.FullName -d dist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-hip-${{ matrix.name }}-windows-2022
+          path: dist/*.whl
+
+      - uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: dist/*
+          # Set tag_name to <tag>-hip-radeon.
+          tag_name: ${{ github.ref_name }}-hip-${{ matrix.name }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

ggml_python-0.0.39/.github/workflows/wheels-vulkan.yaml

@@ -0,0 +1,127 @@
+name: Wheels Vulkan
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+env:
+  VULKAN_SDK_VERSION: "1.4.341.0"
+  VULKAN_SDK_LINUX_SHA256: "ed66477d587a5587dc3601b1c2cdcc1fab5529c505f53a00171876cecd9b4fbe"
+
+jobs:
+  build_wheels:
+    name: Build Vulkan wheel on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            pyver: "3.9"
+            artifact: wheels-vulkan-ubuntu-22.04
+          - os: windows-2022
+            pyver: "3.9"
+            artifact: wheels-vulkan-windows-2022
+
+    steps:
+      - name: Set up MSVC
+        if: runner.os == 'Windows'
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x64
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.pyver }}
+          cache: "pip"
+
+      - name: Install Vulkan SDK
+        if: runner.os == 'Linux'
+        run: |
+          curl -fL \
+            "https://sdk.lunarg.com/sdk/download/${VULKAN_SDK_VERSION}/linux/vulkansdk-linux-x86_64-${VULKAN_SDK_VERSION}.tar.xz" \
+            -o vulkan-sdk.tar.xz
+          echo "${VULKAN_SDK_LINUX_SHA256}  vulkan-sdk.tar.xz" | sha256sum -c -
+          mkdir -p "$RUNNER_TEMP/vulkan-sdk"
+          tar -xf vulkan-sdk.tar.xz -C "$RUNNER_TEMP/vulkan-sdk"
+          source "$RUNNER_TEMP/vulkan-sdk/${VULKAN_SDK_VERSION}/setup-env.sh"
+          {
+            echo "VULKAN_SDK=$VULKAN_SDK"
+            echo "LD_LIBRARY_PATH=$VULKAN_SDK/lib:${LD_LIBRARY_PATH:-}"
+          } >> "$GITHUB_ENV"
+          echo "$VULKAN_SDK/bin" >> "$GITHUB_PATH"
+          "$VULKAN_SDK/bin/glslc" --version
+
+      - name: Install Vulkan SDK
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          choco install vulkan-sdk --version="$env:VULKAN_SDK_VERSION" --no-progress -y
+          $vulkanSdk = Join-Path 'C:\VulkanSDK' $env:VULKAN_SDK_VERSION
+          if (-not (Test-Path $vulkanSdk)) {
+            throw "Failed to find Vulkan SDK at $vulkanSdk"
+          }
+          "VULKAN_SDK=$vulkanSdk" >> $env:GITHUB_ENV
+          "$vulkanSdk\Bin" >> $env:GITHUB_PATH
+          & "$vulkanSdk\Bin\glslc.exe" --version
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build wheel
+
+      - name: Install Windows build dependencies
+        if: runner.os == 'Windows'
+        run: python -m pip install ninja
+
+      - name: Build Vulkan wheel
+        if: runner.os == 'Linux'
+        run: |
+          export CMAKE_ARGS="-DGGML_NATIVE=off -DGGML_METAL=OFF -DGGML_VULKAN=on"
+          python -m build --wheel
+          mkdir -p wheelhouse
+          cp dist/*.whl wheelhouse/
+
+      - name: Build Vulkan wheel
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $env:CMAKE_GENERATOR = 'Ninja'
+          $env:CMAKE_ARGS = '-DGGML_NATIVE=off -DGGML_VULKAN=on'
+          python -m build --wheel
+          New-Item -ItemType Directory -Force wheelhouse | Out-Null
+          Copy-Item dist/*.whl wheelhouse/
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact }}
+          path: ./wheelhouse/*.whl
+
+  release:
+    name: Release
+    needs: [build_wheels]
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+          path: dist
+
+      - uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*
+          # Set release name to <tag>-vulkan.
+          tag_name: ${{ github.ref_name }}-vulkan
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{ggml_python-0.0.38 → ggml_python-0.0.39}/CHANGELOG.md

@@ -7,7 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.38] - 2026-06-02
+## [0.0.39]
 
-- ci: update pre-built wheels to py3-none and add CUDA 11.8-13.2 support
+- ci: add Vulkan wheel builds by @abetlen in #108
+- ci: add ROCm and Windows HIP wheel builds by @abetlen in #109
+- feat: add tensor layout helper bindings by @abetlen in #106
+- feat: add ggml_is_contiguous_{0,1,2} by @aisk in #95
+
+## [0.0.38]
+
+- ci: update pre-built wheels to py3-none and add CUDA 11.8-13.2 support by @abetlen in #104
 - feat: Update ggml to ggml-org/ggml@1e33fed3 and sync Python bindings by @abetlen in #100

ggml_python-0.0.39/CONTRIBUTING.md

@@ -0,0 +1,77 @@
+# Contributing
+
+Hello human and AI contributors, this document exists to help you understand the project and set some rules for contributions.
+
+## Contribution Workflow
+
+Before opening a pull request, search existing issues and PRs to avoid duplicate work.
+Keep each PR focused on one feature, bug fix, or vendor update.
+Avoid mixing unrelated Python changes, ctypes binding updates, documentation edits, and `vendor/ggml` changes unless they are required for the same fix.
+
+Describe what changed, why it changed, and how it was tested.
+Link relevant issues, include any required build flags or hardware assumptions, and add a `CHANGELOG.md` entry for user-visible fixes or features (see `CHANGELOG.md` for examples).
+
+BREAKING CHANGES WILL ALMOST CERTAINLY BE REJECTED OR REFACTORED.
+
+## PR Titles and Changelog Entries
+
+Use PR titles in the form `<tag>: <title>`, with an optional scope when it adds clarity: `feat: add X`, `fix(ci): repair Y`, or `chore: bump version to N`.
+Prefer tags already used in the project history, such as `feat`, `fix`, `chore`, `ci`, `docs`, and `refactor`.
+
+Add changelog entries under `## [Unreleased]` using the PR title followed by `by @contributor in #1234`.
+
+```md
+- feat: add support for X by @contributor in #1234
+- fix(ci): repair Y wheel builds by @contributor in #1234
+```
+
+## Local Development
+
+Prerequisites: Python 3.8+, CMake 3.21+, a C/C++ compiler, and Git submodules.
+From a fresh checkout of the repository, initialize submodules and create a virtual environment:
+
+```bash
+git submodule update --init --recursive
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install --upgrade pip
+make build
+```
+
+Run tests and lint checks before submitting changes:
+
+```bash
+make test
+python -m ruff check ggml tests
+python -m ruff format --check --exclude ggml/ggml.py ggml tests
+```
+
+Use backend-specific build targets when validating native acceleration or backend-specific fixes, for example `make build.openblas`, `make build.cuda`, or `make build.clblast`.
+
+## Testing Expectations
+
+Add or update tests for behavior changes or fixing regressions.
+The test suite uses pytest and lives under `tests/`; name files `test_*.py` and test functions `test_*`.
+
+For changes involving native backends, tensor behavior, performance, or platform compatibility, document the environment used for validation in the PR.
+If a change cannot be covered by automated tests, include a short manual validation recipe instead.
+
+## Code Style
+
+Python code is formatted with Ruff using an 88-character line length.
+Run `python -m ruff format --exclude ggml/ggml.py ggml tests` to apply automatic formatting and `python -m ruff check ggml tests` to check lint rules.
+
+Use 4-space indentation, `snake_case` for functions and variables, `PascalCase` for classes, and `UPPER_CASE` for constants.
+Follow existing patterns when touching ctypes bindings or examples, and avoid adding dependencies unless they are necessary for the feature or fix.
+
+## Documentation Style
+
+Write Markdown with one sentence or core idea per physical line to keep diffs focused and easier to review.
+Do not manually wrap lines at a fixed column width.
+Keep `README.md` focused on user-facing setup and usage; link to this guide for contribution workflow details rather than duplicating them.
+
+## Project Layout
+
+The Python package lives in `ggml/`, with tests in `tests/` and examples in `examples/`.
+Documentation lives in `docs/` and is built with `mkdocs.yml`.
+The `vendor/ggml/` directory is a Git submodule containing the upstream ggml sources used by the bindings.

{ggml_python-0.0.38 → ggml_python-0.0.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ggml_python
-Version: 0.0.38
+Version: 0.0.39
 Summary: Python bindings for ggml
 Author-Email: Andrei Betlen <abetlen@gmail.com>
 License: MIT
@@ -113,6 +113,27 @@ pip install ggml-python \
   --extra-index-url https://abetlen.github.io/ggml-python/whl/metal
 ```
 
+Pre-built Vulkan wheels are available for Linux and Windows:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/vulkan
+```
+
+Pre-built ROCm wheels are available for Linux x86_64 with ROCm 7.2:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/rocm72
+```
+
+Pre-built HIP Radeon wheels are available for Windows x86_64:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/hip-radeon
+```
+
 When installing from source, pip compiles ggml with CMake and requires a C compiler installed on your system.
 To build ggml with specific features (ie. OpenBLAS, GPU Support, etc) you can pass specific cmake options through the `cmake.args` pip install configuration setting. For example to install ggml-python with cuBLAS support you can run:
 
@@ -126,10 +147,12 @@ pip install ggml-python --config-settings=cmake.args='-DGGML_CUDA=ON'
 | Option | Description | Default |
 | --- | --- | --- |
 | `GGML_CUDA` | Enable cuBLAS support | `OFF` |
+| `GGML_HIP` | Enable HIP / ROCm support | `OFF` |
 | `GGML_OPENCL` | Enable OpenCL support | `OFF` |
 | `GGML_BLAS` | Enable BLAS support | `OFF` |
 | `GGML_BLAS_VENDOR` | Select BLAS vendor, for example `OpenBLAS` | unset |
 | `GGML_METAL` | Enable Metal support | `OFF` |
+| `GGML_VULKAN` | Enable Vulkan support | `OFF` |
 | `GGML_RPC` | Enable RPC support | `OFF` |
 
 # Usage

{ggml_python-0.0.38 → ggml_python-0.0.39}/README.md

@@ -72,6 +72,27 @@ pip install ggml-python \
   --extra-index-url https://abetlen.github.io/ggml-python/whl/metal
 ```
 
+Pre-built Vulkan wheels are available for Linux and Windows:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/vulkan
+```
+
+Pre-built ROCm wheels are available for Linux x86_64 with ROCm 7.2:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/rocm72
+```
+
+Pre-built HIP Radeon wheels are available for Windows x86_64:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/hip-radeon
+```
+
 When installing from source, pip compiles ggml with CMake and requires a C compiler installed on your system.
 To build ggml with specific features (ie. OpenBLAS, GPU Support, etc) you can pass specific cmake options through the `cmake.args` pip install configuration setting. For example to install ggml-python with cuBLAS support you can run:
 
@@ -85,10 +106,12 @@ pip install ggml-python --config-settings=cmake.args='-DGGML_CUDA=ON'
 | Option | Description | Default |
 | --- | --- | --- |
 | `GGML_CUDA` | Enable cuBLAS support | `OFF` |
+| `GGML_HIP` | Enable HIP / ROCm support | `OFF` |
 | `GGML_OPENCL` | Enable OpenCL support | `OFF` |
 | `GGML_BLAS` | Enable BLAS support | `OFF` |
 | `GGML_BLAS_VENDOR` | Select BLAS vendor, for example `OpenBLAS` | unset |
 | `GGML_METAL` | Enable Metal support | `OFF` |
+| `GGML_VULKAN` | Enable Vulkan support | `OFF` |
 | `GGML_RPC` | Enable RPC support | `OFF` |
 
 # Usage

{ggml_python-0.0.38 → ggml_python-0.0.39}/docs/index.md

@@ -7,7 +7,7 @@ title: Getting Started
 ggml-python is a python library for working with [ggml](https://github.com/ggml-org/ggml).
 
 ggml is a tensor library for machine learning developed by Georgi Gerganov, the library has been used to run models like Whisper and LLaMa on a wide range of devices.
-ggml is written in C/C++ and is designed to be fast, portable and easily embeddable; making use of various hardware acceleration systems like BLAS, CUDA, OpenCL, and Metal.
+ggml is written in C/C++ and is designed to be fast, portable and easily embeddable; making use of various hardware acceleration systems like BLAS, CUDA, HIP / ROCm, OpenCL, and Metal.
 ggml supports quantized inference for reduced memory footprint and faster inference.
 
 You can use ggml-python to:
@@ -69,6 +69,20 @@ pip install ggml-python \
   --extra-index-url https://abetlen.github.io/ggml-python/whl/metal
 ```
 
+Pre-built ROCm wheels are available for Linux x86_64 with ROCm 7.2:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/rocm72
+```
+
+Pre-built HIP Radeon wheels are available for Windows x86_64:
+
+```bash
+pip install ggml-python \
+  --extra-index-url https://abetlen.github.io/ggml-python/whl/hip-radeon
+```
+
 When installing from source, pip compiles ggml with CMake and requires a C compiler installed on your system.
 
 Below are the available options for building ggml-python with additional options for optimized inference.
@@ -85,6 +99,12 @@ Below are the available options for building ggml-python with additional options
     CMAKE_ARGS="-DGGML_CUDA=ON" pip install ggml-python
     ```
 
+=== "**HIP / ROCm**"
+
+    ```bash
+    CMAKE_ARGS="-DGGML_HIP=ON" pip install ggml-python
+    ```
+
 === "**Metal**"
 
     ```bash

ggml_python-0.0.39/ggml/__init__.py

@@ -0,0 +1,3 @@
+from .ggml import *
+
+__version__ = "0.0.39"

{ggml_python-0.0.38 → ggml_python-0.0.39}/ggml/ggml.py

@@ -1663,6 +1663,66 @@ def ggml_is_contiguous(tensor: ggml_tensor_p, /) -> bool:
     ...
 
 
+# GGML_API GGML_CALL bool ggml_is_contiguous_0(const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_contiguous_0", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_contiguous_0(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor is contiguous (same as ggml_is_contiguous)
+
+    Parameters:
+        tensor: tensor
+
+    Returns:
+        True if tensor is contiguous else False"""
+    ...
+
+
+# GGML_API GGML_CALL bool ggml_is_contiguous_1(const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_contiguous_1", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_contiguous_1(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor is contiguous for dimensions >= 1
+
+    Parameters:
+        tensor: tensor
+
+    Returns:
+        True if tensor is contiguous for dims >= 1 else False"""
+    ...
+
+
+# GGML_API GGML_CALL bool ggml_is_contiguous_2(const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_contiguous_2", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_contiguous_2(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor is contiguous for dimensions >= 2
+
+    Parameters:
+        tensor: tensor
+
+    Returns:
+        True if tensor is contiguous for dims >= 2 else False"""
+    ...
+
+
+# GGML_API bool ggml_is_contiguously_allocated(const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_contiguously_allocated", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_contiguously_allocated(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor is allocated as one contiguous block"""
+    ...
+
+
+# GGML_API bool ggml_is_contiguous_channels(const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_contiguous_channels", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_contiguous_channels(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor is stored as contiguous channels"""
+    ...
+
+
+# GGML_API bool ggml_is_contiguous_rows(const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_contiguous_rows", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_contiguous_rows(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor has contiguous rows"""
+    ...
+
+
 # GGML_API GGML_CALL bool ggml_is_permuted  (const struct ggml_tensor * tensor);
 @ggml_function("ggml_is_permuted", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
 def ggml_is_permuted(tensor: ggml_tensor_p, /) -> bool:
@@ -1682,6 +1742,13 @@ def ggml_is_empty(tensor: ggml_tensor_p, /) -> bool:
     ...
 
 
+# GGML_API bool ggml_is_view      (const struct ggml_tensor * tensor);
+@ggml_function("ggml_is_view", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
+def ggml_is_view(tensor: ggml_tensor_p, /) -> bool:
+    """Check if a tensor is a view"""
+    ...
+
+
 # GGML_API           bool ggml_is_scalar    (const struct ggml_tensor * tensor);
 @ggml_function("ggml_is_scalar", [ctypes.POINTER(ggml_tensor)], ctypes.c_bool)
 def ggml_is_scalar(tensor: ggml_tensor_p, /) -> bool:

ggml_python-0.0.38/ggml/__init__.py

@@ -1,3 +0,0 @@
-from .ggml import *
-
-__version__ = "0.0.38"