ggml-python 0.0.33__tar.gz → 0.0.35__tar.gz

{ggml_python-0.0.33 → ggml_python-0.0.35}/.github/workflows/test.yaml

@@ -10,7 +10,6 @@ on:
 
 jobs:
   build-linux:
-
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -27,13 +26,18 @@ jobs:
       - name: Install dependencies
         run: |
           python3 -m pip install --upgrade pip pytest cmake scikit-build setuptools
-          python3 -m pip install --verbose --editable .
+          python3 -m pip install \
+            --verbose \
+            --config-settings cmake.args='-DCMAKE_BUILD_TYPE=Debug;-DCMAKE_CXX_FLAGS=-g3;-DCMAKE_C_FLAGS=-g3' \
+            --config-settings cmake.verbose=true \
+            --config-settings logging.level=INFO \
+            --config-settings install.strip=false \
+            --editable .
       - name: Test with pytest
         run: |
-          python3 -m pytest
+          python -m pytest -s -vvvv
 
   build-windows:
-
     runs-on: windows-latest
     strategy:
       matrix:
@@ -51,13 +55,12 @@ jobs:
       - name: Install dependencies
         run: |
           python3 -m pip install --upgrade pip pytest cmake scikit-build setuptools
-          python3 -m pip install --verbose --editable .
+          python3 -m pip install --verbose --config-settings cmake.args='-DCMAKE_BUILD_TYPE=Debug;-DCMAKE_CXX_FLAGS=-g3;-DCMAKE_C_FLAGS=-g3' --config-settings cmake.verbose=true --config-settings logging.level=INFO --config-settings install.strip=false --editable .
       - name: Test with pytest
         run: |
-          python3 -m pytest
+          python -m pytest -s -vvvv
 
   build-macos:
-
     runs-on: macos-latest
     strategy:
       matrix:
@@ -74,38 +77,18 @@ jobs:
       - name: Install dependencies
         run: |
           python3 -m pip install --upgrade pip pytest cmake scikit-build setuptools
-          python3 -m pip install --verbose --editable .
+          python3 -m pip install \
+            --verbose \
+            --config-settings cmake.args='-DCMAKE_BUILD_TYPE=Debug;-DCMAKE_CXX_FLAGS=-g3;-DCMAKE_C_FLAGS=-g3' \
+            --config-settings cmake.verbose=true \
+            --config-settings logging.level=INFO \
+            --config-settings install.strip=false \
+            --editable .
       - name: Test with pytest
         run: |
-          python3 -m pytest
-
-  # build-linux-opencl:
-  #   runs-on: ubuntu-latest
-
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #       with:
-  #         submodules: "true"
-
-  #     - name: Dependencies
-  #       run: |
-  #         wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
-  #         echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list  
-  #         sudo apt-get update
-  #         sudo apt-get install -y --no-install-recommends llvm intel-oneapi-runtime-opencl intel-oneapi-runtime-compilers libclblast-dev
-  #         sudo apt-get install -y python3-dev python3-pip make
-      
-  #     - name: Setup
-  #       run: |
-  #         python3 -m pip install pytest
-  #         make build.clblast
-
-  #     - name: Test with pytest
-  #       run: |
-  #         make test
+          python -m pytest -s -vvvv
 
   build-macos-metal:
-
     runs-on: macos-latest
 
     steps:
@@ -119,7 +102,13 @@ jobs:
       - name: Install dependencies
         run: |
           python3 -m pip install --upgrade pip pytest cmake scikit-build setuptools
-          python3 -m pip install --verbose --editable . --config-settings=cmake.args='-DGGML_METAL=On'
+          python3 -m pip install \
+            --verbose \
+            --config-settings cmake.args='-DCMAKE_BUILD_TYPE=Debug;-DCMAKE_CXX_FLAGS=-g3;-DCMAKE_C_FLAGS=-g3;-DGGML_METAL=On' \
+            --config-settings cmake.verbose=true \
+            --config-settings logging.level=INFO \
+            --config-settings install.strip=false \
+            --editable .
       - name: Test with pytest
         run: |
-          python3 -m pytest
+          python -m pytest -s -vvvv

{ggml_python-0.0.33 → ggml_python-0.0.35}/.github/workflows/wheels-index.yaml

@@ -38,6 +38,7 @@ jobs:
           ./scripts/releases-to-pep-503.sh index/whl/cu121 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-cu121$'
           ./scripts/releases-to-pep-503.sh index/whl/cu122 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-cu122$'
           ./scripts/releases-to-pep-503.sh index/whl/cu123 '^[v]?[0-9]+\.[0-9]+\.[0-9]+-cu123$'
+          ./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
         with:

ggml_python-0.0.35/.github/workflows/wheels-metal.yaml

@@ -0,0 +1,87 @@
+name: Wheels Metal
+
+on: workflow_dispatch
+
+permissions:
+  contents: write
+
+jobs:
+  define_matrix:
+    name: Define Build Matrix
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    defaults:
+      run:
+        shell: pwsh
+
+    steps:
+      - name: Define Job Output
+        id: set-matrix
+        run: |
+          $matrix = @{
+              'os' = @('macos-11', 'macos-12', 'macos-13')
+              'pyver' = @('3.10', '3.11', '3.12')
+          }
+
+          $matrixOut = ConvertTo-Json $matrix -Compress
+          Write-Output ('matrix=' + $matrixOut) >> $env:GITHUB_OUTPUT
+
+  build_wheels:
+    name: ${{ matrix.os }} Python ${{ matrix.pyver }}
+    needs: define_matrix
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix: ${{ fromJSON(needs.define_matrix.outputs.matrix) }}
+    env:
+      OSVER: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.pyver }}
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install build wheel cmake
+
+      - name: Build Wheel
+        run: |
+          XCODE15PATH="/Applications/Xcode_15.0.app/Contents/Developer"
+          XCODE15BINPATH="${XCODE15PATH}/Toolchains/XcodeDefault.xctoolchain/usr/bin"
+          export CMAKE_ARGS="-DGGML_NATIVE=off -DGGML_METAL=on"
+          [[ "$OSVER" == "macos-13" ]] && export CC="${XCODE15BINPATH}/cc" && export CXX="${XCODE15BINPATH}/c++" && export MACOSX_DEPLOYMENT_TARGET="13.0"
+          [[ "$OSVER" == "macos-12" ]] && export MACOSX_DEPLOYMENT_TARGET="12.0"
+          [[ "$OSVER" == "macos-11" ]] && export MACOSX_DEPLOYMENT_TARGET="11.0"
+
+          export CMAKE_OSX_ARCHITECTURES="arm64" && export ARCHFLAGS="-arch arm64"
+          VERBOSE=1 python -m build --wheel
+
+          if [[ "$OSVER" == "macos-13" ]]; then
+            export SDKROOT="${XCODE15PATH}/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk"
+            export MACOSX_DEPLOYMENT_TARGET="14.0"
+            VERBOSE=1 python -m build --wheel
+          fi
+
+          for file in ./dist/*.whl; do cp "$file" "${file/arm64.whl/aarch64.whl}"; done
+
+          export CMAKE_OSX_ARCHITECTURES="x86_64" && export CMAKE_ARGS="-DGGML_NATIVE=off -DGGML_AVX=off -DGGML_AVX2=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_METAL=on" && export ARCHFLAGS="-arch x86_64"
+          VERBOSE=1 python -m build --wheel
+
+          if [[ "$OSVER" == "macos-13" ]]; then
+            export SDKROOT="${XCODE15PATH}/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk"
+            export MACOSX_DEPLOYMENT_TARGET="14.0"
+            VERBOSE=1 python -m build --wheel
+          fi
+
+      - uses: softprops/action-gh-release@v1
+        with:
+          files: dist/*
+          # set release name to <tag>-metal
+          tag_name: ${{ github.ref_name }}-metal
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{ggml_python-0.0.33 → ggml_python-0.0.35}/CMakeLists.txt

@@ -16,6 +16,16 @@ endif()
 
 set(BUILD_SHARED_LIBS "On")
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+if (APPLE)
+    if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
+        set(GGML_AVX "Off" CACHE BOOL "ggml: enable AVX" FORCE)
+        set(GGML_AVX2 "Off" CACHE BOOL "ggml: enable AVX2" FORCE)
+        set(GGML_FMA "Off" CACHE BOOL "ggml: enable FMA" FORCE)
+        set(GGML_F16C "Off" CACHE BOOL "ggml: enable F16C" FORCE)
+    endif()
+
+    set(GGML_METAL_EMBED_LIBRARY "On" CACHE BOOL "ggml: embed metal library" FORCE)
+endif()
 add_subdirectory(vendor/ggml)
 install(
     TARGETS ggml 
@@ -24,4 +34,8 @@ install(
     RUNTIME DESTINATION ${GGML_PYTHON_INSTALL_DIR}
     FRAMEWORK DESTINATION ${GGML_PYTHON_INSTALL_DIR}
     RESOURCE DESTINATION ${GGML_PYTHON_INSTALL_DIR}
+)
+install(
+    FILES $<TARGET_RUNTIME_DLLS:ggml>
+    DESTINATION ${GGML_PYTHON_INSTALL_DIR}
 )

{ggml_python-0.0.33 → ggml_python-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ggml_python
-Version: 0.0.33
+Version: 0.0.35
 Summary: Python bindings for ggml
 Author-Email: Andrei Betlen <abetlen@gmail.com>
 License: MIT

ggml_python-0.0.35/ggml/__init__.py

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

{ggml_python-0.0.33 → ggml_python-0.0.35}/ggml/ggml.py

@@ -265,33 +265,24 @@ def ggml_fp32_to_fp16(x: ctypes.c_float, /) -> int:
     ...
 
 
-# GGML_API void ggml_fp16_to_fp32_row(const ggml_fp16_t * x, float * y, size_t n);
+# GGML_API void ggml_fp16_to_fp32_row(const ggml_fp16_t * x, float * y, int64_t n);
 @ctypes_function(
     "ggml_fp16_to_fp32_row",
-    [ctypes.POINTER(ggml_fp16_t), ctypes.POINTER(ctypes.c_float), ctypes.c_int],
+    [ctypes.POINTER(ggml_fp16_t), ctypes.POINTER(ctypes.c_float), ctypes.c_int64],
     None,
-)
-def ggml_fp16_to_fp32_row(
-    x: CtypesArray[ggml_fp16_t],
-    y: CtypesArray[ctypes.c_float],
-    n: Union[ctypes.c_int, int],
-    /,
-) -> None:
+)   
+def ggml_fp16_to_fp32_row(x: CtypesPointer[ggml_fp16_t], y: CtypesPointer[ctypes.c_float], n: int, /) -> None:
     ...
 
 
-# GGML_API void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, size_t n);
+
+# GGML_API void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, int64_t n);
 @ctypes_function(
     "ggml_fp32_to_fp16_row",
-    [ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ggml_fp16_t), ctypes.c_int],
+    [ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ggml_fp16_t), ctypes.c_int64],
     None,
 )
-def ggml_fp32_to_fp16_row(
-    x: CtypesArray[ctypes.c_float],
-    y: CtypesArray[ggml_fp16_t],
-    n: Union[ctypes.c_int, int],
-    /,
-) -> None:
+def ggml_fp32_to_fp16_row(x: CtypesPointer[ctypes.c_float], y: CtypesPointer[ggml_fp16_t], n: int, /) -> None:
     ...
 
 
@@ -679,7 +670,21 @@ GGML_TENSOR_FLAG_PARAM = 4
 #     char padding[4];
 # };
 class ggml_object(ctypes.Structure):
-    pass
+    """ggml object
+    
+    Attributes:
+        offs (int): offset
+        size (int): size
+        next (ctypes.pointer[ggml_object]): pointer to next object
+        type (int): ggml object type
+        padding (bytes): padding"""
+
+    if TYPE_CHECKING:
+        offs: int
+        size: int
+        next: CtypesPointer[ggml_object]
+        type: int
+        padding: bytes
 
 
 ggml_object._fields_ = [
@@ -760,7 +765,25 @@ class ggml_tensor(ctypes.Structure):
         extra (ctypes.c_void_p): extra data (e.g. for CUDA)
     """
 
-    pass
+    if TYPE_CHECKING:
+        type: int
+        backend: int
+        buffer: CtypesPointer[ggml_backend_buffer]
+        ne: Sequence[int]
+        nb: Sequence[int]
+        op: int
+        op_params: Sequence[int]
+        flags: int
+        grad: CtypesPointer[ggml_tensor]
+        src: CtypesArray[ggml_tensor_p]
+        perf_runs: int
+        perf_cycles: int
+        perf_time_us: int
+        view_src: CtypesPointer[ggml_tensor]
+        view_offs: int
+        data: Optional[ctypes.c_void_p]
+        name: bytes
+        extra: Optional[ctypes.c_void_p]
 
 
 ggml_tensor._fields_ = [
@@ -828,6 +851,13 @@ class ggml_cplan(ctypes.Structure):
         abort_callback_data (ctypes.c_void_p): abort callback data
     """
 
+    if TYPE_CHECKING:
+        work_size: int
+        work_data: CtypesPointer[ctypes.c_uint8]
+        n_threads: int
+        abort_callback: Callable[[ctypes.c_void_p], bool]
+        abort_callback_data: Optional[ctypes.c_void_p]
+
     _fields_ = [
         ("work_size", ctypes.c_size_t),
         ("work_data", ctypes.POINTER(ctypes.c_uint8)),
@@ -863,6 +893,16 @@ GGML_CGRAPH_EVAL_ORDER_COUNT = 2
 #     struct ggml_tensor ** keys;
 # };
 class ggml_hash_set(ctypes.Structure):
+    """ggml hash set
+    
+    Attributes:
+        size (int): size
+        keys (ctypes.Array[ctypes.POINTER(ggml_tensor)]): array of tensor keys"""
+
+    if TYPE_CHECKING:
+        size: int
+        keys: CtypesArray[CtypesPointer[ggml_tensor]]
+
     _fields_ = [
         ("size", ctypes.c_size_t),
         ("keys", ctypes.POINTER(ctypes.POINTER(ggml_tensor))),
@@ -893,6 +933,7 @@ class ggml_cgraph(ctypes.Structure):
     """ggml computation graph
 
     Attributes:
+        size (int): size
         n_nodes (int): number of nodes
         n_leafs (int): number of leafs
         nodes (ctypes.Array[ggml_tensor_p]): `n_nodes`-length array of compute tensors
@@ -903,6 +944,19 @@ class ggml_cgraph(ctypes.Structure):
         perf_runs (int): number of runs
         perf_cycles (int): number of cycles
         perf_time_us (int): computation time in microseconds"""
+    
+    if TYPE_CHECKING:
+        size: int
+        n_nodes: int
+        n_leafs: int
+        nodes: CtypesArray[CtypesPointer[ggml_tensor]]
+        grads: CtypesArray[CtypesPointer[ggml_tensor]]
+        leafs: CtypesArray[CtypesPointer[ggml_tensor]]
+        visited_hash_table: ggml_hash_set
+        order: int
+        perf_runs: int
+        perf_cycles: int
+        perf_time_us: int
 
     _fields_ = [
         ("size", ctypes.c_int),
@@ -932,6 +986,18 @@ the `.contents` attribute."""
 #     void * data;
 # };
 class ggml_scratch(ctypes.Structure):
+    """Scratch memory for ggml
+    
+    Attributes:
+        offs (int): offset
+        size (int): size
+        data (ctypes.c_void_p): data pointer"""
+    
+    if TYPE_CHECKING:
+        offs: int
+        size: int
+        data: Optional[ctypes.c_void_p]
+
     _fields_ = [
         ("offs", ctypes.c_size_t),
         ("size", ctypes.c_size_t),
@@ -958,6 +1024,11 @@ class ggml_init_params(ctypes.Structure):
         no_alloc (bool): don't allocate memory for tensor data
     """
 
+    if TYPE_CHECKING:
+        mem_size: int
+        mem_buffer: Optional[ctypes.c_void_p]
+        no_alloc: bool
+
     _fields_ = [
         ("mem_size", ctypes.c_size_t),
         ("mem_buffer", ctypes.c_void_p),
@@ -990,6 +1061,22 @@ GGML_TASK_TYPE_FINALIZE = 2
 #     void * wdata;
 # };
 class ggml_compute_params(ctypes.Structure):
+    """Compute parameters for ggml
+    
+    Attributes:
+        type (int): task type
+        ith (int): thread index
+        nth (int): number of threads
+        wsize (int): work buffer size
+        wdata (ctypes.c_void_p): work buffer data"""
+
+    if TYPE_CHECKING:
+        type: int
+        ith: int
+        nth: int
+        wsize: int
+        wdata: Optional[ctypes.c_void_p]
+
     _fields_ = [
         ("type", ctypes.c_int),
         ("ith", ctypes.c_int),
@@ -7668,9 +7755,9 @@ def ggml_quantize_requires_imatrix(
 #         enum ggml_type   type,
 #            const float * src,
 #                   void * dst,
-#                    int   start,
-#                    int   nrows,
-#                    int   n_per_row,
+#                int64_t   start,
+#                int64_t   nrows,
+#                int64_t   n_per_row,
 #            const float * imatrix);
 @ctypes_function(
     "ggml_quantize_chunk",
@@ -7678,9 +7765,9 @@ def ggml_quantize_requires_imatrix(
         ctypes.c_int,
         ctypes.POINTER(ctypes.c_float),
         ctypes.c_void_p,
-        ctypes.c_int,
-        ctypes.c_int,
-        ctypes.c_int,
+        ctypes.c_int64,
+        ctypes.c_int64,
+        ctypes.c_int64,
         ctypes.POINTER(ctypes.c_float),
     ],
     ctypes.c_size_t,
@@ -7689,9 +7776,9 @@ def ggml_quantize_chunk(
     type: Union[ctypes.c_int, int],
     src: CtypesArray[ctypes.c_float],
     dst: Union[ctypes.c_void_p, int, None],
-    start: Union[ctypes.c_int, int],
-    nrows: Union[ctypes.c_int, int],
-    n_per_row: Union[ctypes.c_int, int],
+    start: Union[ctypes.c_int64, int],
+    nrows: Union[ctypes.c_int64, int],
+    n_per_row: Union[ctypes.c_int64, int],
     imatrix: CtypesArray[ctypes.c_float],
 ) -> int:
     ...
@@ -7741,6 +7828,16 @@ gguf_context_p_ctypes = ctypes.c_void_p
 #     struct ggml_context ** ctx;
 # };
 class gguf_init_params(ctypes.Structure):
+    """Initialization parameters for gguf.
+    
+    Parameters:
+        no_alloc(bool): No allocation.
+        ctx(ggml_context_p): The context."""
+
+    if TYPE_CHECKING:
+        no_alloc: bool
+        ctx: ggml_context_p
+
     _fields_ = [
         ("no_alloc", ctypes.c_bool),
         ("ctx", ctypes.POINTER(ggml_context_p_ctypes)),
@@ -8854,6 +8951,44 @@ ggml_vec_dot_t = ctypes.CFUNCTYPE(
 #     int64_t           nrows; // number of rows to process simultaneously;
 # } ggml_type_traits_t;
 class ggml_type_traits_t(ctypes.Structure):
+    """Internal types and functions exposed for tests and benchmarks.
+    
+    Attributes:
+        type_name(bytes): Name of the type
+        blck_size(int): Block size
+        type_size(int): Size of the type
+        is_quantized(bool): Is quantized
+        to_float(ggml_to_float_t): Convert to float
+        from_float(ggml_from_float_t): Convert from float
+        from_float_reference(ggml_from_float_t): Convert from float reference
+        vec_dot(ggml_vec_dot_t): Vector dot
+        vec_dot_type(int): Vector dot type
+        nrows(int): Number of rows to process simultaneously"""
+
+    if TYPE_CHECKING:
+        type_name: bytes
+        blck_size: int
+        type_size: int
+        is_quantized: bool
+        to_float: Callable[[ctypes.c_void_p, CtypesPointer[ctypes.c_float], int], None]
+        from_float: Callable[[CtypesPointer[ctypes.c_float], ctypes.c_void_p, int], None]
+        from_float_reference: Callable[[CtypesPointer[ctypes.c_float], ctypes.c_void_p, int], None]
+        vec_dot: Callable[
+            [
+                int,
+                CtypesPointer[ctypes.c_float],
+                int,
+                ctypes.c_void_p,
+                int,
+                ctypes.c_void_p,
+                int,
+                int,
+            ],
+            None,
+        ]
+        vec_dot_type: int
+        nrows: int
+
     _fields_ = [
         ("type_name", ctypes.c_char_p),
         ("blck_size", ctypes.c_int),
@@ -8904,6 +9039,20 @@ ggml_backend_t_ctypes: TypeAlias = ctypes.c_void_p
 #     size_t offset;
 # };
 class ggml_tallocr(ctypes.Structure):
+    """Tensor allocator
+
+    Attributes:
+        buffer: ggml_backend_buffer_t
+        base: ctypes.c_void_p
+        alignment: ctypes.c_size_t
+        offset: ctypes.c_size_t"""
+
+    if TYPE_CHECKING:
+        buffer: ggml_backend_buffer_t
+        base: ctypes.c_void_p
+        alignment: int
+        offset: int
+
     _fields_ = [
         ("buffer", ggml_backend_buffer_t_ctypes),
         ("base", ctypes.c_void_p),
@@ -9532,7 +9681,7 @@ def ggml_backend_graph_plan_free(
 )
 def ggml_backend_graph_plan_compute(
     backend: Union[ggml_backend_t, int], plan: ggml_backend_graph_plan_t, /
-) -> ctypes.c_int:
+) -> int:
     ...
 
 # GGML_API enum ggml_status ggml_backend_graph_compute      (ggml_backend_t backend, struct ggml_cgraph * cgraph);
@@ -9543,7 +9692,7 @@ def ggml_backend_graph_plan_compute(
 )
 def ggml_backend_graph_compute(
     backend: Union[ggml_backend_t, int], cgraph: ggml_cgraph_p, /
-) -> ctypes.c_int:
+) -> int:
     ...
 
 # GGML_API enum ggml_status ggml_backend_graph_compute_async(ggml_backend_t backend, struct ggml_cgraph * cgraph);
@@ -9554,7 +9703,7 @@ def ggml_backend_graph_compute(
 )
 def ggml_backend_graph_compute_async(
     backend: Union[ggml_backend_t, int], cgraph: ggml_cgraph_p, /
-) -> ctypes.c_int:
+) -> int:
     ...
 
 
@@ -9567,7 +9716,7 @@ def ggml_backend_graph_compute_async(
 def ggml_backend_supports_op(
     backend: Union[ggml_backend_t, int],
     op: ggml_tensor_p,
-) -> Union[ctypes.c_bool, bool]:
+) -> bool:
     ...
 
 
@@ -9580,7 +9729,7 @@ def ggml_backend_supports_op(
 def ggml_backend_offload_op(
     backend: Union[ggml_backend_t, int],
     op: ggml_tensor_p,
-) -> Union[ctypes.c_bool, bool]:
+) -> bool:
     ...
 
 
@@ -10090,6 +10239,20 @@ def ggml_backend_sched_set_eval_callback(
 #     struct ggml_cgraph * graph;
 # };
 class ggml_backend_graph_copy(ctypes.Structure):
+    """Structure for ggml_backend_graph_copy.
+    
+    Attributes:
+        buffer: ggml_backend_buffer_t
+        ctx_allocated: ggml_context_p
+        ctx_unallocated: ggml_context_p
+        graph: ctypes.POINTER(ggml_cgraph)"""
+
+    if TYPE_CHECKING:
+        buffer: ggml_backend_buffer_t
+        ctx_allocated: ggml_context_p
+        ctx_unallocated: ggml_context_p
+        graph: CtypesPointer[ggml_cgraph]
+
     _fields_ = [
         ("buffer", ggml_backend_buffer_t_ctypes),
         ("ctx_allocated", ggml_context_p_ctypes),

{ggml_python-0.0.33 → ggml_python-0.0.35}/tests/test_ggml_metal.py

@@ -15,7 +15,6 @@ run_if_ggml_metal_available = pytest.mark.skipif(
     reason="METAL not available",
 )
 
-@pytest.mark.skip(reason="ggml-metal.metal missing ggml-common.h at runtime")
 @run_if_ggml_metal_available
 def test_metal():
     n_tensors = 1 + 2 # input (x) and weights (a, b)