Add qnn backend to pip package

Summary:
When generating the wheel packages
- download the qnn sdk such that we can build the qnn backend
- remove the downloaded sdk files so it won't be part of wheel packages

Inside the qnn packages, it includes the AoT part and the the qnn backend.so files (the build from executorch/backends/qualcomm)

For users:
```
# This step will install qnn backend
pip install executorch-0.8.0a0+e5f94da-cp310-cp310-linux_x86_64.whl


# The qnn sdk will be downloaded when users first , if the QNN_SDK_ROOT is not set. This step will only run once 
from executorch.backend.qualcomm import any module
```

Rollback Plan:

Differential Revision: D80992066

Author: cccclai

backends/qualcomm/__init__.py

@@ -0,0 +1,15 @@
+import os
+import pathlib
+from scripts.download_qnn_sdk import _download_qnn_sdk
+
+# -----------------------------------------------------------------------------
+# Main SDK setup
+# -----------------------------------------------------------------------------
+qnn_root = os.environ.get("QNN_SDK_ROOT")
+if qnn_root:
+    SDK_DIR = pathlib.Path(qnn_root)
+else:
+    if not SDK_DIR.exists():
+        print("Qualcomm SDK not found. Downloading...")
+        _download_qnn_sdk()
+    os.environ["QNN_SDK_ROOT"] = str(SDK_DIR)

backends/qualcomm/scripts/build.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # Copyright (c) Qualcomm Innovation Center, Inc.
 # All rights reserved
 #

backends/qualcomm/scripts/download_sdk.py

@@ -0,0 +1,130 @@
+import pathlib
+import platform
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+
+
+
+def is_linux_x86() -> bool:
+    """
+    Check if the current system is Linux running on an x86 architecture.
+
+    Returns:
+        bool: True if the system is Linux and the architecture is one of
+              x86_64, i386, or i686. False otherwise.
+    """
+    return sys.platform.startswith("linux") and platform.machine() in {
+        "x86_64",
+        "i386",
+        "i686",
+    }
+
+SDK_DIR = pathlib.Path(__file__).parent / "sdk"
+
+def _download_qnn_sdk() -> pathlib.Path:
+    """
+    Download and extract the Qualcomm SDK from the given URL into target_dir.
+
+    Args:
+        url (str): The URL of the archive (.zip, .tar.gz, or .tgz).
+        prefix_to_strip (str): Top-level directory inside the archive to strip
+                               from extracted file paths.
+        target_dir (pathlib.Path): Directory to extract the SDK into.
+
+    Notes:
+        - Only runs on Linux x86 platforms. Skips otherwise.
+        - Creates the target_dir if it does not exist.
+    """
+    # Default path where the Qualcomm SDK will be installed (under the script directory).
+
+    # URL to download the Qualcomm AI Runtime SDK archive.
+    qairt_url = (
+        "https://softwarecenter.qualcomm.com/api/download/software/sdks/"
+        "Qualcomm_AI_Runtime_Community/All/2.34.0.250424/v2.34.0.250424.zip"
+    )
+
+    # Top-level directory inside the SDK archive to extract.
+    qairt_content_dir = "qairt/2.34.0.250424"
+
+    if not is_linux_x86():
+        print("Skipping Qualcomm SDK (only supported on Linux x86).")
+        return
+
+    SDK_DIR.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        archive_path = pathlib.Path(tmpdir) / pathlib.Path(qairt_url).name
+
+        print(f"Downloading Qualcomm SDK from {qairt_url}...")
+        urllib.request.urlretrieve(qairt_url, archive_path)
+
+        if qairt_url.endswith(".zip"):
+            _extract_zip(archive_path,  qairt_content_dir, SDK_DIR)
+        elif qairt_url.endswith((".tar.gz", ".tgz")):
+            _extract_tar(archive_path,  qairt_content_dir, SDK_DIR)
+        else:
+            raise ValueError(f"Unsupported archive format: {qairt_url}")
+
+        print(f"Qualcomm SDK extracted to {SDK_DIR}")
+
+    return SDK_DIR
+
+    
+
+
+def _extract_zip(archive_path: pathlib.Path, prefix: str, target_dir: pathlib.Path):
+    """
+    Extract files from a zip archive into target_dir, stripping a prefix.
+
+    Args:
+        archive_path (pathlib.Path): Path to the .zip archive.
+        prefix (str): Prefix folder inside the archive to strip.
+        target_dir (pathlib.Path): Destination directory.
+    """
+    with zipfile.ZipFile(archive_path, "r") as zf:
+        for member in zf.infolist():
+            if not member.filename.startswith(prefix + "/"):
+                continue
+            relpath = pathlib.Path(member.filename).relative_to(prefix)
+            if not relpath.parts or relpath.parts[0] == "..":
+                continue
+            out_path = target_dir / relpath
+            if member.is_dir():
+                out_path.mkdir(parents=True, exist_ok=True)
+            else:
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+                with zf.open(member) as src, open(out_path, "wb") as dst:
+                    dst.write(src.read())
+
+
+def _extract_tar(archive_path: pathlib.Path, prefix: str, target_dir: pathlib.Path):
+    """
+    Extract files from a tar.gz archive into target_dir, stripping a prefix.
+
+    Args:
+        archive_path (pathlib.Path): Path to the .tar.gz or .tgz archive.
+        prefix (str): Prefix folder inside the archive to strip.
+        target_dir (pathlib.Path): Destination directory.
+    """
+    with tarfile.open(archive_path, "r:gz") as tf:
+        for m in tf.getmembers():
+            if not m.name.startswith(prefix + "/"):
+                continue
+            relpath = pathlib.Path(m.name).relative_to(prefix)
+            if not relpath.parts or relpath.parts[0] == "..":
+                continue
+
+            out_path = target_dir / relpath
+            if m.isdir():
+                out_path.mkdir(parents=True, exist_ok=True)
+            else:
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+                src = tf.extractfile(m)
+                if src is None:
+                    # Skip non-regular files (links, devices, etc.)
+                    continue
+                with src, open(out_path, "wb") as dst:
+                    dst.write(src.read())

setup.py

@@ -56,7 +56,14 @@
 # Import this before distutils so that setuptools can intercept the distuils
 # imports.
 import setuptools  # noqa: F401 # usort: skip
+import os
+import platform
 import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
 
 from distutils import log  # type: ignore[import-not-found]
 from distutils.sysconfig import get_python_lib  # type: ignore[import-not-found]
@@ -67,6 +74,7 @@
 from setuptools.command.build import build
 from setuptools.command.build_ext import build_ext
 from setuptools.command.build_py import build_py
+from setuptools.command.install import install
 
 try:
     from tools.cmake.cmake_cache import CMakeCache
@@ -455,6 +463,46 @@ def run(self):
         if self._ran_build:
             return
 
+        try:
+            from backends.qualcomm.scripts.download_sdk import _download_qnn_sdk, SDK_DIR
+            _download_qnn_sdk()
+
+            sdk_path = Path(SDK_DIR).resolve()  # full absolute path
+        except ImportError:
+            sdk_path = None
+
+        if not sdk_path:
+            raise RuntimeError("Qualcomm SDK not found, cannot build backend")
+
+        # Determine paths
+        prj_root = Path(__file__).parent.resolve()
+        build_sh = prj_root / "backends/qualcomm/scripts/build.sh"
+        build_root = prj_root / "build-x86"
+
+        if not build_sh.exists():
+            raise FileNotFoundError(f"{build_sh} not found")
+
+        # Run build.sh with SDK path exported
+        env = dict(**os.environ)
+        print("str(sdk_path): ", str(sdk_path))
+        env["QNN_SDK_ROOT"] = str(sdk_path)
+        subprocess.check_call([str(build_sh)], env=env)
+
+        # Copy the main .so into the wheel package
+        so_src = build_root / "backends/qualcomm/libqnn_executorch_backend.so"
+        so_dst = Path(self.get_ext_fullpath("executorch.backends.qualcomm.qnn_backend"))
+        self.mkpath(so_dst.parent)  # ensure destination exists
+        self.copy_file(str(so_src), str(so_dst))
+        print(f"Copied Qualcomm backend: {so_src} -> {so_dst}")
+
+        # Remove Qualcomm SDK .so so they don’t get packaged
+        if os.path.exists(SDK_DIR):
+            for root, dirs, files in os.walk(SDK_DIR):
+                for f in files:
+                    if f.endswith(".so"):
+                        os.remove(os.path.join(root, f))
+                        print(f"Removed SDK .so from wheel package: {f}")
+
         if self.editable_mode:
             self._ran_build = True
             self.run_command("build")
@@ -733,7 +781,7 @@ def run(self):  # noqa C901
 
         if cmake_cache.is_enabled("EXECUTORCH_BUILD_EXTENSION_MODULE"):
             cmake_build_args += ["--target", "extension_module"]
-
+        
         if cmake_cache.is_enabled("EXECUTORCH_BUILD_EXTENSION_TRAINING"):
             cmake_build_args += ["--target", "_training_lib"]