pycoreml 0.1.0__tar.gz

pycoreml-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Jagtesh Chadha
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pycoreml-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pycoreml
+Version: 0.1.0
+Summary: CoreML inference from Python — powered by Swift & ApplePy
+Author: Jagtesh Chadha
+License: BSD-3-Clause
+Project-URL: Repository, https://github.com/jagtesh/pycoreml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PyCoreML
+
+CoreML inference from Python — powered by Swift & [ApplePy](../ApplePy).
+
+Direct access to Apple's CoreML framework with explicit compute unit selection (CPU, GPU, Neural Engine).
+
+> **macOS only** — requires Swift 6.0+ toolchain
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import pycoreml
+
+# Load and describe a model
+info = pycoreml.load_model("/path/to/model.mlmodelc")
+desc = pycoreml.model_description("/path/to/model.mlmodelc")
+
+# Run prediction
+result = pycoreml.predict("/path/to/model.mlmodelc", {"x": 42.0})
+
+# Predict with explicit compute unit (the killer feature)
+result = pycoreml.predict_with_options(
+    "/path/to/model.mlmodelc",
+    {"x": 42.0},
+    "cpuAndNeuralEngine"  # or "cpuOnly", "cpuAndGPU", "all"
+)
+```
+
+## API
+
+| Function | Returns | Description |
+|----------|---------|-------------|
+| `load_model(path)` | `str` | Load model and return description |
+| `model_description(path)` | `dict[str, str]` | Model metadata |
+| `predict(path, inputs)` | `dict[str, float]` | Run inference |
+| `list_compute_units()` | `list[str]` | Available compute units |
+| `predict_with_options(path, inputs, unit)` | `dict[str, float]` | Predict with compute unit control |
+
+## Examples
+
+See [`pycoreml/examples/demo.py`](pycoreml/examples/demo.py) for a full demo.
+
+## License
+
+BSD-3-Clause © Jagtesh Chadha — see [LICENSE](LICENSE).

pycoreml-0.1.0/README.md

@@ -0,0 +1,51 @@
+# PyCoreML
+
+CoreML inference from Python — powered by Swift & [ApplePy](../ApplePy).
+
+Direct access to Apple's CoreML framework with explicit compute unit selection (CPU, GPU, Neural Engine).
+
+> **macOS only** — requires Swift 6.0+ toolchain
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import pycoreml
+
+# Load and describe a model
+info = pycoreml.load_model("/path/to/model.mlmodelc")
+desc = pycoreml.model_description("/path/to/model.mlmodelc")
+
+# Run prediction
+result = pycoreml.predict("/path/to/model.mlmodelc", {"x": 42.0})
+
+# Predict with explicit compute unit (the killer feature)
+result = pycoreml.predict_with_options(
+    "/path/to/model.mlmodelc",
+    {"x": 42.0},
+    "cpuAndNeuralEngine"  # or "cpuOnly", "cpuAndGPU", "all"
+)
+```
+
+## API
+
+| Function | Returns | Description |
+|----------|---------|-------------|
+| `load_model(path)` | `str` | Load model and return description |
+| `model_description(path)` | `dict[str, str]` | Model metadata |
+| `predict(path, inputs)` | `dict[str, float]` | Run inference |
+| `list_compute_units()` | `list[str]` | Available compute units |
+| `predict_with_options(path, inputs, unit)` | `dict[str, float]` | Predict with compute unit control |
+
+## Examples
+
+See [`pycoreml/examples/demo.py`](pycoreml/examples/demo.py) for a full demo.
+
+## License
+
+BSD-3-Clause © Jagtesh Chadha — see [LICENSE](LICENSE).

pycoreml-0.1.0/pycoreml/__init__.py

@@ -0,0 +1,54 @@
+"""pycoreml — CoreML inference from Python
+
+Powered by Swift & ApplePy. Direct access to Apple's CoreML framework
+with explicit compute unit selection (CPU, GPU, Neural Engine).
+
+Usage:
+    import pycoreml
+    desc = pycoreml.load_model("/path/to/model.mlmodelc")
+    result = pycoreml.predict("/path/to/model.mlmodelc", {"x": 42.0})
+"""
+import importlib
+import os
+import sys
+
+if sys.platform != "darwin":
+    raise ImportError("pycoreml only supports macOS")
+
+
+def _load_native():
+    """Load the compiled Swift extension module."""
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    so_path = os.path.join(pkg_dir, "pycoreml.so")
+
+    if not os.path.exists(so_path):
+        raise ImportError(
+            "Native extension not found. Build it first:\n"
+            "  pip install -e .\n"
+            "  # or: python setup.py build_ext --inplace"
+        )
+
+    spec = importlib.util.spec_from_file_location("pycoreml", so_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_native = _load_native()
+
+# Re-export all public functions
+load_model = _native.load_model
+model_description = _native.model_description
+predict = _native.predict
+list_compute_units = _native.list_compute_units
+predict_with_options = _native.predict_with_options
+
+__all__ = [
+    "load_model",
+    "model_description",
+    "predict",
+    "list_compute_units",
+    "predict_with_options",
+]
+
+__version__ = "0.1.0"

pycoreml-0.1.0/pycoreml/examples/demo.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""PyCoreML — Example Usage
+
+Demonstrates CoreML inference from Python via ApplePy.
+Requires a compiled CoreML model (.mlmodelc) to run predictions.
+"""
+import pycoreml
+
+# ── Available Compute Units ─────────────────────────────────
+
+print("=== Available Compute Units ===\n")
+
+units = pycoreml.list_compute_units()
+for unit in units:
+    print(f"  • {unit}")
+
+# ── Loading a Model ─────────────────────────────────────────
+
+print("\n=== Model Loading ===\n")
+
+# To run this demo, you need a compiled CoreML model.
+# You can create one with coremltools:
+#
+#   import coremltools as ct
+#   import torch
+#
+#   class SimpleModel(torch.nn.Module):
+#       def forward(self, x):
+#           return x * 2 + 1
+#
+#   model = ct.convert(torch.jit.trace(SimpleModel(), torch.tensor([1.0])))
+#   model.save("simple.mlpackage")
+#
+# Then compile it:
+#   xcrun coremlcompiler compile simple.mlpackage .
+
+MODEL_PATH = "simple.mlmodelc"  # Change to your model path
+
+try:
+    # Load and describe model
+    info = pycoreml.load_model(MODEL_PATH)
+    print(info)
+
+    # Get metadata
+    desc = pycoreml.model_description(MODEL_PATH)
+    print(f"\nMetadata: {desc}")
+
+    # ── Running Predictions ─────────────────────────────────
+
+    print("\n=== Predictions ===\n")
+
+    # Basic prediction
+    result = pycoreml.predict(MODEL_PATH, {"x": 42.0})
+    print(f"predict(x=42.0) → {result}")
+
+    # Prediction with explicit compute unit
+    result = pycoreml.predict_with_options(
+        MODEL_PATH,
+        {"x": 42.0},
+        "cpuAndNeuralEngine"
+    )
+    print(f"predict(x=42.0, compute_unit='cpuAndNeuralEngine') → {result}")
+
+    # Compare compute units
+    print("\n=== Compute Unit Comparison ===\n")
+    for unit in ["cpuOnly", "cpuAndGPU", "cpuAndNeuralEngine", "all"]:
+        result = pycoreml.predict_with_options(MODEL_PATH, {"x": 42.0}, unit)
+        print(f"  {unit:25s} → {result}")
+
+except Exception as e:
+    print(f"⚠ Skipping model demo: {e}")
+    print("  (Provide a valid .mlmodelc path to run predictions)")
+
+print("\n🎉 Done!")

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

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pycoreml
+Version: 0.1.0
+Summary: CoreML inference from Python — powered by Swift & ApplePy
+Author: Jagtesh Chadha
+License: BSD-3-Clause
+Project-URL: Repository, https://github.com/jagtesh/pycoreml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PyCoreML
+
+CoreML inference from Python — powered by Swift & [ApplePy](../ApplePy).
+
+Direct access to Apple's CoreML framework with explicit compute unit selection (CPU, GPU, Neural Engine).
+
+> **macOS only** — requires Swift 6.0+ toolchain
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import pycoreml
+
+# Load and describe a model
+info = pycoreml.load_model("/path/to/model.mlmodelc")
+desc = pycoreml.model_description("/path/to/model.mlmodelc")
+
+# Run prediction
+result = pycoreml.predict("/path/to/model.mlmodelc", {"x": 42.0})
+
+# Predict with explicit compute unit (the killer feature)
+result = pycoreml.predict_with_options(
+    "/path/to/model.mlmodelc",
+    {"x": 42.0},
+    "cpuAndNeuralEngine"  # or "cpuOnly", "cpuAndGPU", "all"
+)
+```
+
+## API
+
+| Function | Returns | Description |
+|----------|---------|-------------|
+| `load_model(path)` | `str` | Load model and return description |
+| `model_description(path)` | `dict[str, str]` | Model metadata |
+| `predict(path, inputs)` | `dict[str, float]` | Run inference |
+| `list_compute_units()` | `list[str]` | Available compute units |
+| `predict_with_options(path, inputs, unit)` | `dict[str, float]` | Predict with compute unit control |
+
+## Examples
+
+See [`pycoreml/examples/demo.py`](pycoreml/examples/demo.py) for a full demo.
+
+## License
+
+BSD-3-Clause © Jagtesh Chadha — see [LICENSE](LICENSE).

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

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+pycoreml/__init__.py
+pycoreml.egg-info/PKG-INFO
+pycoreml.egg-info/SOURCES.txt
+pycoreml.egg-info/dependency_links.txt
+pycoreml.egg-info/top_level.txt
+pycoreml/examples/demo.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+pycoreml

pycoreml-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pycoreml"
+version = "0.1.0"
+description = "CoreML inference from Python — powered by Swift & ApplePy"
+readme = "README.md"
+license = {text = "BSD-3-Clause"}
+authors = [{name = "Jagtesh Chadha"}]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Repository = "https://github.com/jagtesh/pycoreml"
+
+[tool.setuptools.packages.find]
+include = ["pycoreml*"]

pycoreml-0.1.0/setup.cfg

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

pycoreml-0.1.0/setup.py

@@ -0,0 +1,46 @@
+"""PyCoreML build — compiles Swift source into a Python-loadable .so"""
+import os
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_ext import build_ext
+
+
+class SwiftBuildExt(build_ext):
+    """Custom build_ext that calls `swift build` to compile the Swift extension."""
+
+    def run(self):
+        if sys.platform != "darwin":
+            raise RuntimeError("pycoreml only supports macOS")
+
+        swift_dir = Path(__file__).parent / "swift"
+        pkg_config_path = sysconfig.get_config_var("LIBPC") or ""
+
+        env = os.environ.copy()
+        env["PKG_CONFIG_PATH"] = pkg_config_path
+
+        print("🔨 Building Swift extension...")
+        subprocess.check_call(
+            ["swift", "build"],
+            cwd=swift_dir,
+            env=env,
+        )
+
+        build_dir = swift_dir / ".build" / "debug"
+        dylib = build_dir / "libPyCoreML.dylib"
+        if not dylib.exists():
+            raise RuntimeError(f"Build succeeded but {dylib} not found")
+
+        dest = Path(__file__).parent / "pycoreml" / "pycoreml.so"
+        print(f"📦 Installing {dylib.name} → {dest}")
+        import shutil
+        shutil.copy2(dylib, dest)
+
+    def get_ext_filename(self, ext_name):
+        return ext_name + ".so"
+
+
+setup(cmdclass={"build_ext": SwiftBuildExt})