onnxruntime-gpu-extended-auto 1.23.2__tar.gz

onnxruntime_gpu_extended_auto-1.23.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeff Hykin
+
+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.

onnxruntime_gpu_extended_auto-1.23.2/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

onnxruntime_gpu_extended_auto-1.23.2/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: onnxruntime-gpu-extended-auto
+Version: 1.23.2
+Summary: Installs the onnxruntime-gpu-extended build matching this machine's CUDA and cuDNN versions
+Home-page: https://github.com/jeff-hykin/onnxruntime-gpu-extended-auto
+License: MIT
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onnxruntime-gpu-extended==1.23.2.12.9
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# onnxruntime-gpu-extended-auto
+
+```
+pip install onnxruntime-gpu-extended-auto
+```
+
+That is the whole thing. It looks at which CUDA and cuDNN are installed on the
+machine you are running `pip` on, then pulls the matching
+[onnxruntime-gpu-extended](https://pypi.org/project/onnxruntime-gpu-extended/)
+build.
+
+## Why this exists
+
+A wheel filename can say "Python 3.12, aarch64, glibc 2.34". It cannot say
+"cuDNN 8" or "cuDNN 9". Both JetPack 6.0 and JetPack 6.2 produce the exact same
+tag, `cp312-cp312-manylinux_2_34_aarch64`, so PyPI has no way to hand each one a
+different file. An onnxruntime built against cuDNN 8 will not load on cuDNN 9,
+and vice versa.
+
+This package resolves that at install time instead.
+
+Published versions are `<onnxruntime version>.<cuda major>.<cudnn major>`, so the
+ABI that the filename cannot express lives in the version number instead.
+
+| Detected | Installs |
+|---|---|
+| CUDA 12 / cuDNN 8 (JetPack 6.0, L4T r36.3) | `onnxruntime-gpu-extended==1.22.2.12.8` |
+| CUDA 12 / cuDNN 9 (JetPack 6.1 / 6.2, L4T r36.4) | `onnxruntime-gpu-extended==1.23.2.12.9` |
+| anything not aarch64 | `onnxruntime-gpu` |
+
+Check what you have with `head -1 /etc/nv_tegra_release`.
+
+Jetson is the only platform upstream never shipped CUDA wheels for, so on x86_64
+this hands you the normal `onnxruntime-gpu` and gets out of the way. It is safe
+to depend on from a project that runs on both.
+
+## Install it on the device
+
+Detection reads the machine running `pip`. Building a lockfile or a container
+image on one JetPack and deploying to another will bake in the wrong choice.
+
+pip caches the wheel it builds from this package, keyed on the source archive
+rather than on the machine. After upgrading JetPack on a box, reinstall with
+`--no-cache-dir` so detection runs again.
+
+To pick explicitly instead of detecting:
+
+```
+ORT_GPU_EXTENDED_VARIANT='onnxruntime-gpu-extended==1.23.2.12.9' pip install onnxruntime-gpu-extended-auto
+```
+
+The same variable is how this package's own source archive gets built off-device,
+since detection otherwise refuses to run on an aarch64 machine without CUDA.
+
+## Verify
+
+```python
+import onnxruntime
+print(onnxruntime.get_available_providers())
+```
+
+`get_available_providers()` lists what was compiled in, not what loads. To prove
+CUDA actually works, build a session and ask it:
+
+```python
+session = onnxruntime.InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])
+print(session.get_providers())
+```

onnxruntime_gpu_extended_auto-1.23.2/README.md

@@ -0,0 +1,68 @@
+# onnxruntime-gpu-extended-auto
+
+```
+pip install onnxruntime-gpu-extended-auto
+```
+
+That is the whole thing. It looks at which CUDA and cuDNN are installed on the
+machine you are running `pip` on, then pulls the matching
+[onnxruntime-gpu-extended](https://pypi.org/project/onnxruntime-gpu-extended/)
+build.
+
+## Why this exists
+
+A wheel filename can say "Python 3.12, aarch64, glibc 2.34". It cannot say
+"cuDNN 8" or "cuDNN 9". Both JetPack 6.0 and JetPack 6.2 produce the exact same
+tag, `cp312-cp312-manylinux_2_34_aarch64`, so PyPI has no way to hand each one a
+different file. An onnxruntime built against cuDNN 8 will not load on cuDNN 9,
+and vice versa.
+
+This package resolves that at install time instead.
+
+Published versions are `<onnxruntime version>.<cuda major>.<cudnn major>`, so the
+ABI that the filename cannot express lives in the version number instead.
+
+| Detected | Installs |
+|---|---|
+| CUDA 12 / cuDNN 8 (JetPack 6.0, L4T r36.3) | `onnxruntime-gpu-extended==1.22.2.12.8` |
+| CUDA 12 / cuDNN 9 (JetPack 6.1 / 6.2, L4T r36.4) | `onnxruntime-gpu-extended==1.23.2.12.9` |
+| anything not aarch64 | `onnxruntime-gpu` |
+
+Check what you have with `head -1 /etc/nv_tegra_release`.
+
+Jetson is the only platform upstream never shipped CUDA wheels for, so on x86_64
+this hands you the normal `onnxruntime-gpu` and gets out of the way. It is safe
+to depend on from a project that runs on both.
+
+## Install it on the device
+
+Detection reads the machine running `pip`. Building a lockfile or a container
+image on one JetPack and deploying to another will bake in the wrong choice.
+
+pip caches the wheel it builds from this package, keyed on the source archive
+rather than on the machine. After upgrading JetPack on a box, reinstall with
+`--no-cache-dir` so detection runs again.
+
+To pick explicitly instead of detecting:
+
+```
+ORT_GPU_EXTENDED_VARIANT='onnxruntime-gpu-extended==1.23.2.12.9' pip install onnxruntime-gpu-extended-auto
+```
+
+The same variable is how this package's own source archive gets built off-device,
+since detection otherwise refuses to run on an aarch64 machine without CUDA.
+
+## Verify
+
+```python
+import onnxruntime
+print(onnxruntime.get_available_providers())
+```
+
+`get_available_providers()` lists what was compiled in, not what loads. To prove
+CUDA actually works, build a session and ask it:
+
+```python
+session = onnxruntime.InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])
+print(session.get_providers())
+```

onnxruntime_gpu_extended_auto-1.23.2/onnxruntime_gpu_extended_auto.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: onnxruntime-gpu-extended-auto
+Version: 1.23.2
+Summary: Installs the onnxruntime-gpu-extended build matching this machine's CUDA and cuDNN versions
+Home-page: https://github.com/jeff-hykin/onnxruntime-gpu-extended-auto
+License: MIT
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onnxruntime-gpu-extended==1.23.2.12.9
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# onnxruntime-gpu-extended-auto
+
+```
+pip install onnxruntime-gpu-extended-auto
+```
+
+That is the whole thing. It looks at which CUDA and cuDNN are installed on the
+machine you are running `pip` on, then pulls the matching
+[onnxruntime-gpu-extended](https://pypi.org/project/onnxruntime-gpu-extended/)
+build.
+
+## Why this exists
+
+A wheel filename can say "Python 3.12, aarch64, glibc 2.34". It cannot say
+"cuDNN 8" or "cuDNN 9". Both JetPack 6.0 and JetPack 6.2 produce the exact same
+tag, `cp312-cp312-manylinux_2_34_aarch64`, so PyPI has no way to hand each one a
+different file. An onnxruntime built against cuDNN 8 will not load on cuDNN 9,
+and vice versa.
+
+This package resolves that at install time instead.
+
+Published versions are `<onnxruntime version>.<cuda major>.<cudnn major>`, so the
+ABI that the filename cannot express lives in the version number instead.
+
+| Detected | Installs |
+|---|---|
+| CUDA 12 / cuDNN 8 (JetPack 6.0, L4T r36.3) | `onnxruntime-gpu-extended==1.22.2.12.8` |
+| CUDA 12 / cuDNN 9 (JetPack 6.1 / 6.2, L4T r36.4) | `onnxruntime-gpu-extended==1.23.2.12.9` |
+| anything not aarch64 | `onnxruntime-gpu` |
+
+Check what you have with `head -1 /etc/nv_tegra_release`.
+
+Jetson is the only platform upstream never shipped CUDA wheels for, so on x86_64
+this hands you the normal `onnxruntime-gpu` and gets out of the way. It is safe
+to depend on from a project that runs on both.
+
+## Install it on the device
+
+Detection reads the machine running `pip`. Building a lockfile or a container
+image on one JetPack and deploying to another will bake in the wrong choice.
+
+pip caches the wheel it builds from this package, keyed on the source archive
+rather than on the machine. After upgrading JetPack on a box, reinstall with
+`--no-cache-dir` so detection runs again.
+
+To pick explicitly instead of detecting:
+
+```
+ORT_GPU_EXTENDED_VARIANT='onnxruntime-gpu-extended==1.23.2.12.9' pip install onnxruntime-gpu-extended-auto
+```
+
+The same variable is how this package's own source archive gets built off-device,
+since detection otherwise refuses to run on an aarch64 machine without CUDA.
+
+## Verify
+
+```python
+import onnxruntime
+print(onnxruntime.get_available_providers())
+```
+
+`get_available_providers()` lists what was compiled in, not what loads. To prove
+CUDA actually works, build a session and ask it:
+
+```python
+session = onnxruntime.InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])
+print(session.get_providers())
+```

onnxruntime_gpu_extended_auto-1.23.2/onnxruntime_gpu_extended_auto.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+onnxruntime_gpu_extended_auto.egg-info/PKG-INFO
+onnxruntime_gpu_extended_auto.egg-info/SOURCES.txt
+onnxruntime_gpu_extended_auto.egg-info/dependency_links.txt
+onnxruntime_gpu_extended_auto.egg-info/requires.txt
+onnxruntime_gpu_extended_auto.egg-info/top_level.txt

onnxruntime_gpu_extended_auto-1.23.2/onnxruntime_gpu_extended_auto.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

onnxruntime_gpu_extended_auto-1.23.2/onnxruntime_gpu_extended_auto.egg-info/requires.txt

@@ -0,0 +1 @@
+onnxruntime-gpu-extended==1.23.2.12.9

onnxruntime_gpu_extended_auto-1.23.2/onnxruntime_gpu_extended_auto.egg-info/top_level.txt

@@ -0,0 +1 @@
+

onnxruntime_gpu_extended_auto-1.23.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

onnxruntime_gpu_extended_auto-1.23.2/setup.py

@@ -0,0 +1,136 @@
+"""Metadata-only package that resolves to the onnxruntime-gpu-extended build
+matching the CUDA/cuDNN majors present on the machine running pip."""
+
+import glob
+import os
+import platform
+import re
+import subprocess
+import sys
+
+from setuptools import setup
+
+DISPATCHER_VERSION = "1.23.2"
+DISTRIBUTION = "onnxruntime-gpu-extended"
+
+# Jetson is the only platform upstream never shipped CUDA wheels for.
+UPSTREAM_DISTRIBUTION = "onnxruntime-gpu"
+
+# Published wheel versions are <ort_version>.<cuda_major>.<cudnn_major>, so the
+# ABI lives in the version rather than in the project name.
+# (cuda_major, cudnn_major) -> version
+VARIANTS = {
+    (12, 8): "1.22.2.12.8",
+    (12, 9): "1.23.2.12.9",
+}
+
+LIBRARY_DIRECTORIES = [
+    "/usr/lib/aarch64-linux-gnu",
+    "/usr/lib/x86_64-linux-gnu",
+    "/usr/local/cuda/lib64",
+    "/usr/local/cuda/targets/aarch64-linux/lib",
+    "/usr/local/cuda/targets/x86_64-linux/lib",
+    "/usr/lib64",
+    "/usr/lib",
+]
+
+
+def soname_majors(library_stem):
+    """Every N for which libFOO.so.N is visible to the dynamic linker."""
+    pattern = re.compile(re.escape(library_stem) + r"\.so\.(\d+)")
+    majors = set()
+
+    try:
+        ldconfig_output = subprocess.run(
+            ["/sbin/ldconfig", "-p"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        ).stdout
+        majors.update(int(match) for match in pattern.findall(ldconfig_output))
+    except (OSError, subprocess.SubprocessError):
+        pass
+
+    search_directories = list(LIBRARY_DIRECTORIES)
+    search_directories += [
+        directory
+        for directory in os.environ.get("LD_LIBRARY_PATH", "").split(":")
+        if directory
+    ]
+    for directory in search_directories:
+        for path in glob.glob(os.path.join(directory, library_stem + ".so.*")):
+            match = pattern.search(os.path.basename(path))
+            if match:
+                majors.add(int(match.group(1)))
+
+    return majors
+
+
+def detect_requirement():
+    override = os.environ.get("ORT_GPU_EXTENDED_VARIANT")
+    if override:
+        return override, "ORT_GPU_EXTENDED_VARIANT"
+
+    # Only Jetson lacks upstream CUDA wheels; everywhere else upstream is correct.
+    machine = platform.machine()
+    if machine not in ("aarch64", "arm64"):
+        return UPSTREAM_DISTRIBUTION, "non-aarch64 machine (%s)" % machine
+
+    cuda_majors = soname_majors("libcudart")
+    cudnn_majors = soname_majors("libcudnn")
+    if not cuda_majors or not cudnn_majors:
+        raise SystemExit(
+            "onnxruntime-gpu-extended-auto: could not find CUDA and cuDNN on this "
+            "machine.\n"
+            "  libcudart.so.N found: %s\n"
+            "  libcudnn.so.N found:  %s\n"
+            "This package must be installed on the target device (a Jetson with "
+            "JetPack installed), not cross-built.\n"
+            "To bypass detection, set ORT_GPU_EXTENDED_VARIANT to a pip "
+            "requirement, e.g.\n"
+            "  ORT_GPU_EXTENDED_VARIANT='onnxruntime-gpu-extended==1.23.2'"
+            % (sorted(cuda_majors) or "none", sorted(cudnn_majors) or "none")
+        )
+
+    # A box carrying several cuDNN majors can run the build for the newest one.
+    key = (max(cuda_majors), max(cudnn_majors))
+    if key not in VARIANTS:
+        raise SystemExit(
+            "onnxruntime-gpu-extended-auto: no build published for CUDA %d / "
+            "cuDNN %d.\nPublished combinations: %s\n"
+            "Please open an issue at "
+            "https://github.com/jeff-hykin/onnxruntime-gpu-extended-auto/issues"
+            % (key[0], key[1], ", ".join("CUDA %d / cuDNN %d" % k for k in sorted(VARIANTS)))
+        )
+
+    return "%s==%s" % (DISTRIBUTION, VARIANTS[key]), "CUDA %d / cuDNN %d" % key
+
+
+requirement, detection_source = detect_requirement()
+sys.stderr.write(
+    "onnxruntime-gpu-extended-auto: detected %s -> installing %s\n"
+    % (detection_source, requirement)
+)
+
+setup(
+    name="onnxruntime-gpu-extended-auto",
+    version=DISPATCHER_VERSION,
+    description=(
+        "Installs the onnxruntime-gpu-extended build matching this machine's "
+        "CUDA and cuDNN versions"
+    ),
+    long_description=open(
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), "README.md")
+    ).read(),
+    long_description_content_type="text/markdown",
+    license="MIT",
+    url="https://github.com/jeff-hykin/onnxruntime-gpu-extended-auto",
+    python_requires=">=3.10",
+    install_requires=[requirement],
+    py_modules=[],
+    classifiers=[
+        "Operating System :: POSIX :: Linux",
+        "Environment :: GPU :: NVIDIA CUDA",
+        "Topic :: Scientific/Engineering",
+    ],
+)