npu-easy 0.1.0__tar.gz

npu_easy-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: npu-easy
+Version: 0.1.0
+Summary: A zero-dependency wrapper for easy NPU usage in Python on Windows.
+Author: Antigravity
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Description-Content-Type: text/markdown
+Provides-Extra: intel
+Requires-Dist: onnxruntime-openvino; extra == "intel"
+Provides-Extra: amd
+Requires-Dist: onnxruntime-directml; extra == "amd"
+Provides-Extra: qualcomm
+Requires-Dist: onnxruntime; extra == "qualcomm"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: provides-extra
+Dynamic: summary
+
+## Installation
+
+```bash
+pip install .
+```
+
+`npu-easy` has **zero hard dependencies**. It will install quickly without downloading large packages. 
+
+### Usage Acceleration
+To actually use NPU acceleration, you should install the appropriate ONNX Runtime version for your hardware:
+
+- **Intel**: `pip install onnxruntime-openvino`
+- **AMD/Generic Windows**: `pip install onnxruntime-directml`
+- **Qualcomm**: Install `onnxruntime` and the QNN SDK.
+
+## Quick Start
+
+### Basic NPU Usage
+```python
+from npu_easy import NPUModel
+import numpy as np
+
+# Automatically selects NPU if found
+model = NPUModel("path/to/model.onnx")
+results = model.run(np.random.randn(1, 10).astype(np.float32))
+```
+
+### Bonus: Multi-Hardware Bonus Feature
+Run on NPU, GPU, and CPU all at once!
+```python
+from npu_easy import MultiRunner
+
+multi = MultiRunner("path/to/model.onnx")
+# Runs on all backends in parallel threads
+all_results = multi.run_all(input_data)
+```
+
+### Multi-Threading
+Set the number of internal threads for the engine:
+```python
+model = NPUModel("path/to/model.onnx", intra_op_num_threads=4)
+```
+
+## Hardware Support
+- **Intel**: via OpenVINO Execution Provider.
+- **AMD/NVIDIA/Integrated**: via DirectML Execution Provider.
+- **Qualcomm**: via QNN Execution Provider.

npu_easy-0.1.0/README.md

@@ -0,0 +1,47 @@
+## Installation
+
+```bash
+pip install .
+```
+
+`npu-easy` has **zero hard dependencies**. It will install quickly without downloading large packages. 
+
+### Usage Acceleration
+To actually use NPU acceleration, you should install the appropriate ONNX Runtime version for your hardware:
+
+- **Intel**: `pip install onnxruntime-openvino`
+- **AMD/Generic Windows**: `pip install onnxruntime-directml`
+- **Qualcomm**: Install `onnxruntime` and the QNN SDK.
+
+## Quick Start
+
+### Basic NPU Usage
+```python
+from npu_easy import NPUModel
+import numpy as np
+
+# Automatically selects NPU if found
+model = NPUModel("path/to/model.onnx")
+results = model.run(np.random.randn(1, 10).astype(np.float32))
+```
+
+### Bonus: Multi-Hardware Bonus Feature
+Run on NPU, GPU, and CPU all at once!
+```python
+from npu_easy import MultiRunner
+
+multi = MultiRunner("path/to/model.onnx")
+# Runs on all backends in parallel threads
+all_results = multi.run_all(input_data)
+```
+
+### Multi-Threading
+Set the number of internal threads for the engine:
+```python
+model = NPUModel("path/to/model.onnx", intra_op_num_threads=4)
+```
+
+## Hardware Support
+- **Intel**: via OpenVINO Execution Provider.
+- **AMD/NVIDIA/Integrated**: via DirectML Execution Provider.
+- **Qualcomm**: via QNN Execution Provider.

npu_easy-0.1.0/npu_easy/__init__.py

@@ -0,0 +1,4 @@
+from .model import NPUModel, MultiRunner
+from .utils import get_available_npu_providers, get_best_provider, check_hardware
+
+__version__ = "0.2.0"

npu_easy-0.1.0/npu_easy/model.py

@@ -0,0 +1,96 @@
+import os
+from .utils import get_best_provider, get_all_hardware_providers
+
+class NPUModel:
+    def __init__(self, model_path, provider=None, provider_options=None, intra_op_num_threads=None):
+        """
+        Initializes the NPUModel with lazy imports and optional threading.
+        """
+        try:
+            global ort
+            import onnxruntime as ort
+        except ImportError:
+            raise ImportError(
+                "onnxruntime is required for NPU inference. "
+                "Please install it using: pip install onnxruntime-directml (or onnxruntime-openvino)"
+            )
+
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found: {model_path}")
+            
+        self.provider = provider or get_best_provider()
+        
+        sess_options = ort.SessionOptions()
+        if intra_op_num_threads:
+            sess_options.intra_op_num_threads = intra_op_num_threads
+
+        if provider_options is None:
+            provider_options = {}
+            if self.provider == 'OpenVINOExecutionProvider':
+                provider_options = {'device_type': 'NPU'}
+            elif self.provider == 'QNNExecutionProvider':
+                provider_options = {'backend_path': 'QnnHtp.dll'} 
+
+        print(f"Initializing NPUModel with provider: {self.provider}")
+        
+        try:
+            self.session = ort.InferenceSession(
+                model_path, 
+                sess_options=sess_options,
+                providers=[self.provider],
+                provider_options=[provider_options] if provider_options else None
+            )
+        except Exception as e:
+            print(f"Failed to initialize with {self.provider}. Falling back to CPU.")
+            self.provider = 'CPUExecutionProvider'
+            self.session = ort.InferenceSession(model_path, sess_options=sess_options, providers=['CPUExecutionProvider'])
+
+        self.input_names = [i.name for i in self.session.get_inputs()]
+        self.output_names = [o.name for o in self.session.get_outputs()]
+
+    def run(self, input_data):
+        """
+        Runs inference on the selected hardware.
+        """
+        input_feed = self._prepare_input(input_data)
+        return self.session.run(self.output_names, input_feed)
+
+    def _prepare_input(self, input_data):
+        if hasattr(input_data, '__array__'):
+            if len(self.input_names) != 1:
+                raise ValueError("Model has multiple inputs, but a single array was provided.")
+            return {self.input_names[0]: input_data}
+        return input_data
+
+    def get_info(self):
+        """Returns metadata."""
+        import onnxruntime as ort
+        return {
+            "provider": self.provider,
+            "inputs": self.input_names,
+            "outputs": self.output_names,
+            "available_providers": ort.get_available_providers()
+        }
+
+class MultiRunner:
+    """Bonus: Runs models on NPU, GPU, and CPU simultaneously using threading."""
+    def __init__(self, model_path):
+        from concurrent.futures import ThreadPoolExecutor
+        hw_map = get_all_hardware_providers()
+        self.models = {}
+        
+        for hw_type, providers in hw_map.items():
+            if providers:
+                print(f"Initializing {hw_type} runner with {providers[0]}")
+                self.models[hw_type] = NPUModel(model_path, provider=providers[0])
+
+    def run_all(self, input_data):
+        """Runs the model on all initialized hardware in parallel."""
+        from concurrent.futures import ThreadPoolExecutor
+        results = {}
+        with ThreadPoolExecutor(max_workers=len(self.models)) as executor:
+            future_to_hw = {executor.submit(m.run, input_data): hw for hw, m in self.models.items()}
+            for future in future_to_hw:
+                hw = future_to_hw[future]
+                results[hw] = future.result()
+        return results

npu_easy-0.1.0/npu_easy/utils.py

@@ -0,0 +1,68 @@
+import subprocess
+import os
+
+def check_hardware():
+    """Checks for NPU and GPU hardware using Windows built-in tools."""
+    found = {"NPU": [], "GPU": []}
+    npu_keywords = ['neural', 'npu', 'compute accelerator', 'movidius', 'intel ai boost', 'hexagon']
+    gpu_keywords = ['nvidia', 'geforce', 'radeon', 'intel(r) iris', 'intel(r) graphics', 'arc(tm)']
+    
+    try:
+        ps_cmd = 'powershell -Command "Get-PnpDevice | Select-Object FriendlyName | Out-String"'
+        output = subprocess.check_output(ps_cmd, shell=True, stderr=subprocess.DEVNULL).decode('utf-8', errors='ignore')
+        for line in output.splitlines():
+            line = line.strip().lower()
+            if any(k in line for k in npu_keywords):
+                found["NPU"].append(line)
+            elif any(k in line for k in gpu_keywords):
+                found["GPU"].append(line)
+    except Exception:
+        pass
+            
+    found["NPU"] = sorted(list(set(found["NPU"])))
+    found["GPU"] = sorted(list(set(found["GPU"])))
+    return found
+
+def get_all_hardware_providers():
+    """Returns a map of available hardware to their best ONNX providers."""
+    try:
+        import onnxruntime as ort
+        available = ort.get_available_providers()
+        
+        mapping = {
+            "NPU": [p for p in ['QNNExecutionProvider', 'OpenVINOExecutionProvider'] if p in available],
+            "GPU": [p for p in ['CUDAExecutionProvider', 'ROCMExecutionProvider', 'DmlExecutionProvider'] if p in available],
+            "CPU": ['CPUExecutionProvider']
+        }
+        return mapping
+    except ImportError:
+        return {}
+
+def get_available_npu_providers():
+    """Returns available NPU providers. Tries onnxruntime if installed, otherwise uses hardware detection."""
+    try:
+        import onnxruntime as ort
+        available = ort.get_available_providers()
+        
+        npu_priority = [
+            'QNNExecutionProvider',
+            'OpenVINOExecutionProvider',
+            'DmlExecutionProvider',
+        ]
+        return [p for p in npu_priority if p in available]
+    except ImportError:
+        # If onnxruntime is not installed, we can still report what hardware we found
+        hardware = check_npu_hardware()
+        if hardware:
+            return [f"Detected Hardware: {h}" for h in hardware]
+        return []
+
+def get_best_provider():
+    """Returns the best provider name. Defaults to CPU if nothing else is found."""
+    npu_providers = get_available_npu_providers()
+    if npu_providers and not npu_providers[0].startswith("Detected"):
+        return npu_providers[0]
+    
+    # Check if DirectML is likely available (standard on modern Windows)
+    # but we can't be sure without ORT.
+    return 'CPUExecutionProvider'

npu_easy-0.1.0/npu_easy.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: npu-easy
+Version: 0.1.0
+Summary: A zero-dependency wrapper for easy NPU usage in Python on Windows.
+Author: Antigravity
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Description-Content-Type: text/markdown
+Provides-Extra: intel
+Requires-Dist: onnxruntime-openvino; extra == "intel"
+Provides-Extra: amd
+Requires-Dist: onnxruntime-directml; extra == "amd"
+Provides-Extra: qualcomm
+Requires-Dist: onnxruntime; extra == "qualcomm"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: provides-extra
+Dynamic: summary
+
+## Installation
+
+```bash
+pip install .
+```
+
+`npu-easy` has **zero hard dependencies**. It will install quickly without downloading large packages. 
+
+### Usage Acceleration
+To actually use NPU acceleration, you should install the appropriate ONNX Runtime version for your hardware:
+
+- **Intel**: `pip install onnxruntime-openvino`
+- **AMD/Generic Windows**: `pip install onnxruntime-directml`
+- **Qualcomm**: Install `onnxruntime` and the QNN SDK.
+
+## Quick Start
+
+### Basic NPU Usage
+```python
+from npu_easy import NPUModel
+import numpy as np
+
+# Automatically selects NPU if found
+model = NPUModel("path/to/model.onnx")
+results = model.run(np.random.randn(1, 10).astype(np.float32))
+```
+
+### Bonus: Multi-Hardware Bonus Feature
+Run on NPU, GPU, and CPU all at once!
+```python
+from npu_easy import MultiRunner
+
+multi = MultiRunner("path/to/model.onnx")
+# Runs on all backends in parallel threads
+all_results = multi.run_all(input_data)
+```
+
+### Multi-Threading
+Set the number of internal threads for the engine:
+```python
+model = NPUModel("path/to/model.onnx", intra_op_num_threads=4)
+```
+
+## Hardware Support
+- **Intel**: via OpenVINO Execution Provider.
+- **AMD/NVIDIA/Integrated**: via DirectML Execution Provider.
+- **Qualcomm**: via QNN Execution Provider.

npu_easy-0.1.0/npu_easy.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+npu_easy/__init__.py
+npu_easy/model.py
+npu_easy/utils.py
+npu_easy.egg-info/PKG-INFO
+npu_easy.egg-info/SOURCES.txt
+npu_easy.egg-info/dependency_links.txt
+npu_easy.egg-info/requires.txt
+npu_easy.egg-info/top_level.txt

npu_easy-0.1.0/npu_easy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

npu_easy-0.1.0/npu_easy.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[amd]
+onnxruntime-directml
+
+[intel]
+onnxruntime-openvino
+
+[qualcomm]
+onnxruntime

npu_easy-0.1.0/npu_easy.egg-info/top_level.txt

@@ -0,0 +1 @@
+npu_easy

npu_easy-0.1.0/setup.cfg

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

npu_easy-0.1.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="npu-easy",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[], # Zero hard dependencies
+    extras_require={
+        "intel": ["onnxruntime-openvino"],
+        "amd": ["onnxruntime-directml"],
+        "qualcomm": ["onnxruntime"], # Requires separate QNN SDK setup
+    },
+    author="Antigravity",
+    description="A zero-dependency wrapper for easy NPU usage in Python on Windows.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: Microsoft :: Windows",
+    ],
+)