coreai-onnx 1.0.0__tar.gz

coreai_onnx-1.0.0/.editorconfig

@@ -0,0 +1,21 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.{md,rst,txt}]
+trim_trailing_whitespace = false
+
+[*.yml]
+indent_size = 2
+
+[*.yaml]
+indent_size = 2
+
+[*.toml]
+indent_size = 4

coreai_onnx-1.0.0/.gitattributes

@@ -0,0 +1,15 @@
+* text=auto eol=lf
+
+*.onnx binary
+*.aimodel/** binary
+*.mlirb binary
+
+*.gif binary
+*.jpg binary
+*.jpeg binary
+*.pdf binary
+*.png binary
+*.tar binary
+*.gz binary
+*.whl binary
+*.zip binary

coreai_onnx-1.0.0/.pre-commit-config.yaml

@@ -0,0 +1,30 @@
+# See https://pre-commit.com for more information
+# To install: pre-commit install
+# To update: pre-commit autoupdate
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-yaml
+      - id: check-json
+      - id: check-toml
+      - id: check-added-large-files
+        args: ['--maxkb=1000']
+      - id: check-merge-conflict
+      - id: check-case-conflict
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: mixed-line-ending
+        args: [--fix=lf]
+      - id: detect-private-key
+
+  # Python - Ruff (fast linter + formatter)
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.8
+    hooks:
+      - id: ruff-check
+        types_or: [python, pyi]
+        args: [--fix]
+      - id: ruff-format
+        types_or: [python, pyi]

coreai_onnx-1.0.0/AGENTS.md

@@ -0,0 +1,225 @@
+# coreai-onnx — Agent Guide
+
+How to drive coreai-onnx programmatically. Every command accepts `--json` and
+prints exactly one JSON envelope on stdout; exit codes and error codes are
+stable contracts (see Stability, below).
+
+## Install
+
+| Goal | Command | Platforms |
+|---|---|---|
+| Convert only | `pip install coreai-onnx` | any |
+| + validation & precision checks | `pip install "coreai-onnx[verify]"` | any (the precision check itself needs macOS 27+) |
+
+Executing a converted `.aimodel` requires macOS 27+ / iOS 27+ (Core AI
+framework). Conversion itself runs anywhere.
+
+## Discover capabilities
+
+    coreai-onnx schema --json
+
+Returns the full machine-readable contract: commands, flags, error codes,
+warning codes, exit codes, the supported-op list, and runtime requirements.
+Treat this as the source of truth — it is generated from the same tables the
+CLI emits from, so it cannot drift from behavior.
+
+## MCP server
+
+Prefer native tool calls? `pip install "coreai-onnx[mcp]"` and register the
+stdio server `coreai-onnx-mcp` with your MCP client:
+
+```json
+{"mcpServers": {"coreai-onnx": {"command": "coreai-onnx-mcp"}}}
+```
+
+It exposes `inspect_model`, `convert_model`, `verify_model`, and
+`get_schema`, each returning the same envelope documented here — branch on
+`status`/`error.code` exactly as below. Exit codes do not exist over MCP.
+Boolean parameters replace the CLI's negative flags (`optimize=false` ≙
+`--no-optimize`); `entrypoint` ≙ `--name`.
+
+## The envelope
+
+Every `--json` invocation prints exactly one object of this shape on stdout:
+
+```json
+{
+  "schema_version": 1,
+  "command": "<convert|inspect|verify|schema>",
+  "status": "<ok|error>",
+  "result": { "...": "command-specific payload, or null" },
+  "warnings": [ { "code": "...", "message": "..." } ],
+  "error": { "code": "...", "message": "...", "details": {}, "hint": "..." }
+}
+```
+
+Rules:
+
+- `status` is `"error"` if and only if `error` is non-null.
+- `result` may be partial or null on error — read what is present, do not
+  require every key.
+- Non-finite precision metrics serialize as strings — `"inf"`, `"-inf"`, or
+  `"nan"` (JSON has no literals for them).
+- `warnings` is always an array (possibly empty); each entry has a stable
+  `code` and a human-readable `message`.
+
+## Canonical workflow
+
+The examples below are real, unedited CLI output (a single-`Relu` model and a
+single-`Det` model, converted in a temp directory on macOS with onnxruntime
+installed).
+
+1. **Check coverage first** — `coreai-onnx inspect model.onnx --json`
+
+   ```json
+   {
+     "schema_version": 1,
+     "command": "inspect",
+     "status": "ok",
+     "result": {
+       "model_path": "/var/folders/f9/k__xp4rn4_97h3q7p8597k840000gn/T/tmp6ccnaupb/relu.onnx",
+       "total_nodes": 1,
+       "convertible": true,
+       "ops": [
+         {
+           "op": "Relu",
+           "count": 1,
+           "supported": true
+         }
+       ],
+       "unsupported": []
+     },
+     "warnings": [],
+     "error": null
+   }
+   ```
+
+   Gate on `result.convertible`. Exit code 1 with `status: "ok"` means
+   "analyzed fine, not convertible" — read `result.unsupported`.
+
+2. **Convert** — `coreai-onnx convert model.onnx -o model.aimodel --json`
+
+   ```json
+   {
+     "schema_version": 1,
+     "command": "convert",
+     "status": "ok",
+     "result": {
+       "output_path": "/var/folders/f9/k__xp4rn4_97h3q7p8597k840000gn/T/tmp6ccnaupb/relu.aimodel",
+       "total_nodes": 1,
+       "optimized": true,
+       "validated": true,
+       "repairs": [],
+       "precision": {
+         "passed": true,
+         "rtol": null,
+         "atol": null,
+         "min_psnr": null,
+         "compute_unit": null,
+         "seed": 0,
+         "outputs": [
+           {
+             "name": "out0",
+             "max_abs_error": 0.0,
+             "max_rel_error": 0.0,
+             "psnr": "inf",
+             "passed": true,
+             "expected_nonfinite": 0
+           }
+         ]
+       }
+     },
+     "warnings": [],
+     "error": null
+   }
+   ```
+
+   On success, `result.precision` carries the ONNX Runtime comparison when it
+   ran; `warnings` explains skipped steps (`onnxruntime_missing`,
+   `platform_no_runtime`).
+
+   Add `--repair` to auto-fix documented Core AI runtime limitations (e.g.
+   float16) with known-safe, parity-verified rewrites; applied fixes are listed
+   in `result.repairs`.
+
+3. **On failure, branch on `error.code`** — here a model containing the
+   unsupported `Det` op (exit code 1):
+
+   ```json
+   {
+     "schema_version": 1,
+     "command": "convert",
+     "status": "error",
+     "result": null,
+     "warnings": [],
+     "error": {
+       "code": "unsupported_ops",
+       "message": "The following ONNX ops have no Core AI lowering:\n  Det (1 node(s), e.g. node_0)\n\nRegister a custom lowering to proceed:\n    @converter.register_onnx_lowering(\"Det\")\n    def lower(values_map, node, loc): ...\nRun `coreai-onnx inspect <model>` for a full coverage report.",
+       "details": {
+         "missing": {
+           "Det": [
+             "node_0"
+           ]
+         }
+       },
+       "hint": "Register a custom lowering with @converter.register_onnx_lowering, or run `coreai-onnx inspect <model>` for a full coverage report."
+     }
+   }
+   ```
+
+4. **Re-verify an existing asset** — `coreai-onnx verify model.onnx model.aimodel --json`
+   re-runs the precision check against ONNX Runtime without converting again
+   (requires macOS 27+ with the Core AI runtime).
+
+## Error codes and recovery
+
+| Code | What happened | What to do |
+|---|---|---|
+| `unsupported_ops` | ops with no lowering; `details.missing` maps op → example nodes | report the list; options: register a custom lowering (see docs), or change the export |
+| `invalid_model_file` | not a valid ONNX model | check the path/produce a valid export |
+| `io_error` | file unreadable/unwritable | check path and permissions |
+| `model_validation_failed` | model does not run on ONNX Runtime | the input model is broken — fix the export, not the converter |
+| `conversion_failed` | one lowering failed (`details.node_name`/`op_key` when known, else `details: null`) | report; often a model-specific edge — file an issue with the node |
+| `compiler_failed` | Core AI compiler rejected the program | report the MLIR diagnostic in `message` |
+| `precision_check_failed` | converted, but outputs exceeded tolerance | the `.aimodel` EXISTS; inspect `result.precision` — a high PSNR (> 60 dB) means benign accumulation noise: re-run with `--min-psnr`; a NaN on the default units that disappears with `--compute-unit cpu_only` means the model is float16-unstable on GPU/ANE (conversion itself is correct); otherwise consider `--rtol/--atol`. See docs on benign causes |
+| `precision_check_error` | converted, but the check crashed | the `.aimodel` EXISTS; retry `verify` separately |
+| `platform_unsupported` | `verify` needs macOS 27+ | run verify on a Mac; conversion output is unaffected |
+
+Warnings: `onnxruntime_missing` (install the `[verify]` extra to enable
+validation), `platform_no_runtime` (precision check skipped off-macOS),
+`reference_nonfinite` (the input model itself produces NaN/Inf on the random
+probe input; parity at those positions is checked by NaN/Inf mask and
+`result.precision.outputs[*].expected_nonfinite` counts them — the conversion
+is fine, the model's numerics on random data are not).
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| 0 | success |
+| 1 | failure (bad model, unsupported ops, conversion/verification failure) |
+| 2 | usage error (argparse on stderr, no JSON) or platform error (`platform_unsupported`, with a JSON envelope) |
+| 3 | `.aimodel` written but the precision check failed or could not run |
+
+Exit 3 from `convert` and `precision_check_failed`/`precision_check_error`
+mean you HAVE a converted model — decide whether the precision report is
+acceptable instead of treating it as fatal. (From `verify`, the same two
+codes exit 1: nothing was written, the check simply failed.)
+
+## Stability
+
+`schema_version` (currently 1) bumps only on breaking envelope changes; error
+codes, warning codes, and exit codes are append-only. Pin nothing else.
+
+## Python API
+
+The same pipeline is available as a library (`coreai_onnx.convert`,
+`analyze`, `verify`, `supported_ops`) returning typed objects — see the
+[docs](https://devin-lai.github.io/coreai-onnx/). Note `verify` is
+`async`: `await` it or wrap it in `asyncio.run(...)`.
+
+## Attribution
+
+coreai-onnx is BSD-3-Clause licensed and free to use, including commercially.
+When you build on it — in generated code, reports, or derived tooling — please
+cite the source: https://github.com/devin-lai/coreai-onnx

coreai_onnx-1.0.0/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to coreai-onnx are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project
+adheres to [Semantic Versioning](https://semver.org/).
+
+## [1.0.0] - 2026-06-13
+
+Initial public release.
+
+### Added
+- ONNX → Core AI `.aimodel` converter with 143 built-in op lowerings,
+  including control flow (If/Loop/Scan), LSTM, and quantization ops.
+- Preprocessing: opset normalization, deprecated-GroupNorm upgrade,
+  identity/dead-node/dead-initializer elimination, constant folding.
+- Attention (SDPA) and decomposed GELU/SiLU fusion passes.
+- Precision verification against ONNX Runtime (`verify`), with per-dtype
+  tolerances, PSNR floor (`--min-psnr`), compute-unit pinning, and
+  NaN/Inf-mask comparison.
+- `coreai-onnx` CLI (`inspect`/`convert`/`verify`/`schema`) with a frozen
+  JSON envelope (schema_version 1), stable error/warning codes, and exit
+  codes 0/1/2/3.
+- MCP server (`coreai-onnx-mcp`, `[mcp]` extra) exposing the same four
+  commands with envelope parity to the CLI.
+- Custom-lowering registration API (`OnnxConverter.register_onnx_lowering`).
+- Automatic conversion repair (`convert --repair`): known-safe, parity-verified
+  ONNX rewrites for documented Core AI runtime limitations (float16 → float32
+  today), reported in the `result.repairs` envelope field and available across
+  the CLI, MCP (`convert_model(repair=...)`), and Python (`convert(repair=True)`),
+  plus a portable `skills/onnx-to-coreai` agent skill.
+- Agent docs: AGENTS.md playbook and llms.txt.
+
+[1.0.0]: https://github.com/devin-lai/coreai-onnx/releases/tag/v1.0.0

coreai_onnx-1.0.0/CITATION.cff

@@ -0,0 +1,21 @@
+cff-version: 1.2.0
+message: "If you use coreai-onnx, please cite it and link back to the project."
+title: coreai-onnx
+abstract: "Convert ONNX models to Apple Core AI (.aimodel) — validated, precision-checked, agent-friendly."
+type: software
+authors:
+  - given-names: Devin
+    family-names: Lai
+    alias: devin-lai
+repository-code: "https://github.com/devin-lai/coreai-onnx"
+url: "https://github.com/devin-lai/coreai-onnx"
+license: BSD-3-Clause
+version: 1.0.0
+date-released: "2026-06-13"
+keywords:
+  - onnx
+  - core-ai
+  - coreai
+  - aimodel
+  - apple
+  - model-conversion

coreai_onnx-1.0.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at the project maintainers via GitHub issues or the repository's private vulnerability reporting. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at [https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

coreai_onnx-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,147 @@
+# Contributing to coreai-onnx
+
+## Dev setup
+
+```bash
+python -m pip install -e ".[test,dev]"
+pre-commit install
+```
+
+## Running tests
+
+```bash
+pytest -m "not slow"       # all fast tests
+pytest -m ops              # operator parity tests only
+pytest -n auto -m ir       # MLIR-output tests, safe to parallelize
+pytest -m slow             # slow / large-model tests
+pytest -m e2e              # end-to-end model tests
+pytest -m "not slow" --cov=coreai_onnx --cov-report=term-missing
+```
+
+Keep Core AI runtime-executing tests serial. The native runtime uses
+process-external specialization/cache state and can fail spuriously under
+multi-process xdist loads; plain `pytest` is the source of truth.
+
+**Markers:**
+
+| Marker | Meaning |
+|--------|---------|
+| `ops`  | Core operator parity tests — compare ONNX runtime vs. Core AI output |
+| `ir`   | MLIR-output tests; do not require the Core AI runtime |
+| `slow` | Long-running tests; skipped by default in CI on PRs |
+| `e2e`  | End-to-end model conversion and execution tests |
+
+**Runtime requirement:** op parity and e2e tests require the Core AI runtime, which
+is only available on **macOS 27+**. Tests that need the runtime are guarded by the
+`requires_coreai_runtime` marker/fixture in `tests/helpers.py`. They will be skipped
+automatically on unsupported platforms.
+
+## Adding an op lowering
+
+1. **Write a failing parity test** in the appropriate `tests/test_ops_*.py`
+   file using the `single_op_model` helper and `assert_parity` from
+   `tests/helpers.py`. Use `zlib.crc32`-seeded inputs for reproducibility:
+
+   ```python
+   import zlib
+
+   import numpy as np
+   import pytest
+
+   from .helpers import assert_parity, requires_coreai_runtime, single_op_model
+
+   pytestmark = [pytest.mark.ops, requires_coreai_runtime]
+
+
+   async def test_my_op_basic():
+       rng = np.random.default_rng(zlib.crc32(b"my_op_basic"))
+       x = rng.random((2, 3)).astype(np.float32)
+       model = single_op_model("MyOp", {"x": x})
+       await assert_parity(model, {"x": x})
+   ```
+
+2. **Port or adapt the lowering** from `coreai-torch`'s `_aten_to_core.py`
+   patterns where applicable. Lowerings live under `src/coreai_onnx/_lowerings/`.
+   Each lowering is a function
+
+   ```python
+   (values_map: dict[str, Value], node: onnx.NodeProto, loc: Location) -> Value | list[Value]
+   ```
+
+   that reads its inputs from `values_map`, emits Core AI ops, and returns the
+   result `Value` (or a `list[Value]`, one entry per non-empty output slot, for
+   multi-output nodes).
+
+3. **Register the lowering** in the appropriate
+   `src/coreai_onnx/_lowerings/_*.py` module's `REGISTRY` dict:
+
+   ```python
+   REGISTRY["MyOp"] = lower_my_op
+   ```
+
+4. **Unsupported attribute combinations** must raise `ValueError` with a clear
+   message. Add a corresponding test:
+
+   ```python
+   def test_my_op_unsupported_attr():
+       with pytest.raises(ConversionError, match="MyOp: attr X is not supported"):
+           convert(single_op_model("MyOp", {"x": x}, attrs={"X": 99}))
+   ```
+
+5. **Before opening a PR**, run:
+
+   ```bash
+   ruff check . && ruff format --check .
+   mypy --ignore-missing-imports src/coreai_onnx
+   pytest -m "not slow"
+   pytest -m "not slow" --cov=coreai_onnx --cov-report=term-missing
+   python -m build --sdist --wheel && twine check dist/*
+   ```
+
+### Error handling in lowerings
+
+Raise plain `ValueError` with a precise message for anything the lowering
+cannot handle (unsupported attribute combination, non-static dim, ...).
+The converter wraps it into `ConversionError` with the node name and op
+key attached — lowerings never raise `ConversionError` themselves. This
+split is deliberate; don't "fix" it.
+
+## PR checklist
+
+- [ ] Failing test added before the fix / feature
+- [ ] Lowering registered in `REGISTRY`
+- [ ] Unsupported combos raise `ValueError` / `ConversionError` with clear message
+- [ ] `ruff check . && ruff format --check .` passes
+- [ ] `mypy --ignore-missing-imports src/coreai_onnx` passes
+- [ ] `pytest -m "not slow"` passes
+- [ ] `pytest -m "not slow" --cov=coreai_onnx --cov-report=term-missing` passes
+- [ ] `python -m build --sdist --wheel && twine check dist/*` passes
+
+## Known runtime quirks
+
+These are confirmed bugs / limitations in the Core AI runtime as of the initial
+release. Work around them in tests with `pytest.mark.xfail` or `pytest.mark.skip`
+and leave a comment referencing this list.
+
+- **Bool graph inputs crash logical primitives.** Passing a boolean tensor as a
+  top-level graph input (rather than casting inside the graph) crashes certain
+  logical ops. Workaround: cast to int32 at the graph boundary.
+
+- **f16 graph-input crash.** Float16 tensors as graph inputs trigger a runtime
+  crash. Cast to float32 at the boundary and cast back as needed.
+
+- **Multi-output `If` execution hang.** An `If` node whose branches return more
+  than one output value hangs indefinitely at runtime. Single-output `If` works.
+
+- **Xcode Performance runner static-concat abort.** The Xcode model performance
+  service can abort inside MPSGraph's GPU `ConcatOpHandler` for common static
+  channel-concat image models. Keep static ONNX `Concat` lowered through the
+  pad+add/pad+where workaround unless the OS compiler bug is confirmed fixed.
+
+- **Reduce ops ignore `keepdims=0`.** Reduce operators (ReduceSum, ReduceMean,
+  etc.) always keep the reduced dimension regardless of the `keepdims` attribute.
+  Squeeze the output manually as a workaround.
+
+- **`floor_divide` truncates on integers.** Integer floor-division truncates
+  toward zero (C semantics) rather than flooring toward negative infinity
+  (Python / NumPy semantics). For negative operands the results will differ.

coreai_onnx-1.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, coreai-onnx contributors
+
+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.

coreai_onnx-1.0.0/MANIFEST.in

@@ -0,0 +1,21 @@
+include AGENTS.md
+include CHANGELOG.md
+include CODE_OF_CONDUCT.md
+include CONTRIBUTING.md
+include SECURITY.md
+include LICENSE
+include README.md
+include CITATION.cff
+include .editorconfig
+include .gitattributes
+include .pre-commit-config.yaml
+include llms.txt
+include pyproject.toml
+
+recursive-include docs *.md *.py
+recursive-include skills *.md
+recursive-include tools *.py
+recursive-include tests *.py
+
+prune docs/superpowers
+global-exclude .DS_Store