{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-onnx","slug":"pypi-onnx","name":"onnx","type":"repo","url":"https://pypi.org/project/onnx/","page_url":"https://unfragile.ai/pypi-onnx","categories":["model-training"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-onnx__cap_0","uri":"capability://data.processing.analysis.protocol.buffer.based.neural.network.model.serialization.with.versioned.operator.schemas","name":"protocol buffer-based neural network model serialization with versioned operator schemas","description":"ONNX serializes neural network models to a standardized binary format using Protocol Buffers (protobuf), with a versioned operator schema system that enables forward/backward compatibility across framework versions. The architecture uses onnx.proto definitions that map to in-memory IR (Intermediate Representation) objects, allowing models trained in PyTorch, TensorFlow, or other frameworks to be persisted and loaded with operator semantics preserved through operator versioning and domain-based namespacing.","intents":["I need to save a trained neural network model in a framework-agnostic format that can be loaded by any ONNX-compatible runtime","I want to ensure my model remains compatible as ONNX operator definitions evolve across versions","I need to serialize models with external data references for large weight tensors without embedding them in the protobuf"],"best_for":["ML engineers deploying models across heterogeneous inference runtimes (ONNX Runtime, TensorRT, CoreML, etc.)","Teams maintaining model versioning and compatibility across framework upgrades","Production systems requiring deterministic model serialization and deserialization"],"limitations":["Protobuf serialization adds overhead compared to framework-native formats; large models require external data handling via external_data_helper.py","Operator versioning requires explicit schema registration; custom operators need manual domain definition","No built-in compression; models with billions of parameters require external data splitting strategies"],"requires":["Python 3.8+","protobuf library (bundled with onnx package)","NumPy for tensor conversion"],"input_types":["PyTorch models (via torch.onnx.export)","TensorFlow models (via tf2onnx converter)","Framework-agnostic model definitions via ONNX helper API"],"output_types":["Binary .onnx files (protobuf format)","External data files (.pb_data) for large tensors","In-memory ModelProto objects"],"categories":["data-processing-analysis","model-serialization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_1","uri":"capability://data.processing.analysis.type.and.shape.inference.engine.with.partial.evaluation.and.data.propagation","name":"type and shape inference engine with partial evaluation and data propagation","description":"ONNX implements a type and shape inference system that traverses the computation graph, propagating tensor shapes and data types through operators using operator schema definitions. The inference engine uses partial evaluation to compute constant folding and data propagation rules defined in operator schemas (via type_inference_function and shape_inference_function), enabling static analysis of model outputs without executing the model. This is implemented in C++ (onnx/defs/data_type_utils.cc) with Python bindings for accessibility.","intents":["I need to validate that my model's tensor shapes are consistent across all layers before deployment","I want to determine output tensor shapes and types without running inference on actual data","I need to detect shape mismatches and type incompatibilities early in the model development cycle"],"best_for":["Model developers validating graph structure before deployment","Compiler and optimization framework developers needing static shape information","Runtime implementers requiring pre-execution shape information for memory allocation"],"limitations":["Cannot infer shapes for dynamic control flow (If, Loop operators) without concrete input shapes","Partial evaluation is limited to constant tensors; symbolic shapes require external shape information","Custom operators without registered shape inference functions will fail shape propagation"],"requires":["Python 3.8+","ONNX model with valid operator schema definitions","Input shape information for dynamic dimensions (via ValueInfoProto)"],"input_types":["ModelProto objects with graph definitions","ValueInfoProto for input tensor metadata"],"output_types":["Inferred ValueInfoProto for all graph outputs","Shape and type information for intermediate tensors","Error messages for shape/type mismatches"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_10","uri":"capability://code.generation.editing.function.body.composition.and.operator.abstraction.with.custom.operator.definitions","name":"function body composition and operator abstraction with custom operator definitions","description":"ONNX supports function bodies (FunctionProto) that enable defining custom operators as compositions of primitive ONNX operators. Functions are stored in the model's opset_import and can be referenced like built-in operators. This enables operator abstraction, code reuse, and domain-specific operator definitions without requiring C++ kernel implementations. Function bodies are expanded during model execution or compilation, enabling optimization of composed operators.","intents":["I want to define a custom operator as a composition of primitive ONNX operators","I need to create domain-specific operators for my application without implementing C++ kernels","I want to abstract complex operator patterns into reusable function definitions"],"best_for":["Domain-specific framework developers extending ONNX with custom operators","Researchers prototyping novel operator compositions","Model optimization tools creating fused operators"],"limitations":["Function bodies are expanded at runtime or compile time; no performance benefit over expanded graphs","Debugging function bodies is more complex than debugging primitive operators","Type inference for functions requires explicit type constraint definitions"],"requires":["Python 3.8+","ONNX package","Understanding of ONNX operator composition"],"input_types":["Operator definitions (inputs, outputs, attributes)","Primitive ONNX operators for function body"],"output_types":["FunctionProto objects","Models with custom operator definitions"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_11","uri":"capability://automation.workflow.cmake.based.build.system.with.platform.specific.configuration.and.protobuf.code.generation","name":"cmake-based build system with platform-specific configuration and protobuf code generation","description":"ONNX uses CMake for cross-platform building with automatic protobuf code generation (onnx/gen_proto.py), Python extension building via setuptools, and platform-specific configuration for Windows, Linux, and macOS. The build system generates C++ bindings for Python (onnx_cpp2py_export), compiles operator schema definitions, and produces platform-specific wheels with abi3 compatibility for Python 3.12+. Build configuration is managed through CMakeLists.txt with external dependency management for protobuf and googletest.","intents":["I need to build ONNX from source for my platform with custom protobuf versions","I want to extend ONNX with custom C++ operators and integrate them into the build","I need to generate Python wheels with abi3 compatibility for multiple Python versions"],"best_for":["ONNX contributors and maintainers building from source","Platform-specific deployment scenarios requiring custom builds","Developers extending ONNX with C++ operators"],"limitations":["CMake build requires C++ compiler and build tools; not suitable for pure Python environments","Protobuf code generation is tightly coupled to build system; custom protobuf versions may cause compatibility issues","abi3 wheels are only available for Python 3.12+; earlier versions require version-specific wheels"],"requires":["CMake 3.13+","C++ compiler (GCC, Clang, MSVC)","Python 3.8+ with development headers","Protobuf 3.20+ (bundled or system-installed)"],"input_types":["CMakeLists.txt configuration",".proto files for code generation"],"output_types":["Compiled C++ libraries","Python extension modules (.so, .pyd)","Platform-specific wheels (.whl)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_12","uri":"capability://automation.workflow.ci.cd.pipeline.with.automated.testing.linting.and.release.orchestration","name":"ci/cd pipeline with automated testing, linting, and release orchestration","description":"ONNX implements comprehensive CI/CD workflows (.github/workflows/main.yml) that run automated tests across multiple Python versions and platforms, perform code quality checks (linting, type checking), and orchestrate releases to PyPI. The pipeline includes backend test execution, security scanning, and compliance automation. Release orchestration handles version bumping, changelog generation, and wheel building for multiple platforms.","intents":["I need to ensure my ONNX changes pass all tests before merging","I want to automate the release process for new ONNX versions","I need to verify code quality and security compliance in CI/CD"],"best_for":["ONNX maintainers and contributors managing releases","Teams using ONNX in CI/CD pipelines for model validation","Organizations requiring automated security and compliance checks"],"limitations":["CI/CD pipeline is GitHub Actions-specific; not portable to other CI systems","Test execution time increases with new operators; may become bottleneck for large PRs","Release process requires manual approval steps; cannot be fully automated"],"requires":["GitHub repository with Actions enabled","PyPI credentials for automated publishing","Test infrastructure for multiple platforms"],"input_types":["Git commits and pull requests","Version tags for releases"],"output_types":["Test results and coverage reports","Code quality reports","Published wheels on PyPI"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_13","uri":"capability://data.processing.analysis.reference.implementation.for.operator.execution.and.model.inference","name":"reference implementation for operator execution and model inference","description":"ONNX provides a reference implementation (onnx/reference/ops/) that executes ONNX models using NumPy-based operator kernels, enabling model inference without external runtimes. The reference implementation is used for testing, validation, and as a fallback for operators not optimized in production runtimes. It supports all standard ONNX operators and provides numerical accuracy baseline for comparing against optimized implementations.","intents":["I need to run ONNX model inference for testing without installing a production runtime","I want to validate my model's numerical outputs against a reference implementation","I need to debug operator behavior by comparing against the reference implementation"],"best_for":["Model developers testing inference without production runtime dependencies","Testing frameworks validating model outputs","Researchers comparing optimized implementations against reference"],"limitations":["Reference implementation is not optimized for performance; significantly slower than production runtimes","NumPy-based kernels may have different numerical precision than optimized implementations","No GPU support; all computation is CPU-based"],"requires":["Python 3.8+","ONNX package with reference implementation","NumPy 1.16+"],"input_types":["ONNX ModelProto objects","Input data as NumPy arrays or dictionaries"],"output_types":["Output tensors as NumPy arrays","Intermediate activation values"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_2","uri":"capability://memory.knowledge.operator.schema.registry.with.versioned.operator.definitions.and.domain.namespacing","name":"operator schema registry with versioned operator definitions and domain namespacing","description":"ONNX maintains a global operator schema registry (onnx/defs/operator_sets.h) that stores versioned definitions for 200+ operators across multiple domains (ai.onnx, ai.onnx.ml, ai.onnx.training, com.microsoft, etc.). Each operator definition includes input/output signatures, type constraints, attributes, and inference functions. The registry supports operator versioning (opset versions 1-21+) allowing operators to evolve while maintaining backward compatibility; deprecated operators are marked but remain available for legacy models.","intents":["I need to look up the exact input/output requirements and type constraints for a specific ONNX operator","I want to understand which operator versions are available and what changed between versions","I need to register a custom operator with type constraints and shape inference rules for my domain"],"best_for":["ONNX runtime implementers building operator kernels","Model converters (PyTorch → ONNX, TensorFlow → ONNX) needing operator compatibility checks","Framework developers extending ONNX with domain-specific operators"],"limitations":["Custom operators require C++ schema registration; no pure-Python operator definition API","Operator versioning is immutable once released; breaking changes require new opset versions","Schema introspection is limited to registered operators; no dynamic operator discovery"],"requires":["Python 3.8+","ONNX package with C++ extensions compiled","Knowledge of operator schema format (OpSchema, TypeConstraintParam, etc.)"],"input_types":["Operator names (strings)","Opset version numbers","Domain identifiers (e.g., 'ai.onnx')"],"output_types":["OpSchema objects with input/output specifications","Type constraint information","Attribute definitions and defaults","Operator documentation strings"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_3","uri":"capability://code.generation.editing.graph.composition.and.manipulation.api.with.node.insertion.edge.rewiring.and.subgraph.extraction","name":"graph composition and manipulation api with node insertion, edge rewiring, and subgraph extraction","description":"ONNX provides a Python API (onnx/helper.py, onnx/compose.py) for programmatic graph construction and manipulation, enabling developers to create models by instantiating NodeProto objects, connecting them via ValueInfoProto edges, and composing them into GraphProto structures. The API supports node insertion, edge rewiring, subgraph extraction, and graph merging operations. Internally, graphs are represented as directed acyclic graphs (DAGs) where nodes are operators and edges are named tensor values; the composition API abstracts protobuf manipulation.","intents":["I want to programmatically build an ONNX model from scratch without using a framework converter","I need to modify an existing ONNX graph by inserting new nodes or rewiring connections","I want to extract a subgraph from a larger model for analysis or optimization"],"best_for":["Model compiler developers building graph transformation passes","Researchers prototyping novel architectures without framework dependencies","Tools developers building ONNX model editors and visualizers"],"limitations":["No automatic shape inference during graph construction; developers must manually specify tensor shapes","Graph validation is deferred until explicit checker.check_model() call; invalid graphs can be constructed","No built-in graph optimization; composition API is low-level and requires manual optimization passes"],"requires":["Python 3.8+","ONNX package","Understanding of ONNX graph structure (nodes, edges, attributes)"],"input_types":["NodeProto definitions","ValueInfoProto tensor metadata","Attribute dictionaries","Existing GraphProto objects"],"output_types":["GraphProto objects","Modified ModelProto with updated graphs","Extracted subgraph definitions"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_4","uri":"capability://safety.moderation.model.validation.and.consistency.checking.with.operator.schema.enforcement","name":"model validation and consistency checking with operator schema enforcement","description":"ONNX implements a comprehensive model checker (onnx/checker.py, onnx/onnx_cpp2py_export/checker.pyi) that validates model structure, operator compatibility, and graph consistency. The checker verifies that all operators are registered in the schema registry, input/output types match operator constraints, tensor shapes are consistent across connections, and graph structure is acyclic. Validation is performed via C++ implementation with Python bindings, enabling fast checking of large models.","intents":["I need to validate that my ONNX model is well-formed before deploying it to production","I want to detect type mismatches and shape inconsistencies in my model graph","I need to ensure my model uses only operators supported by a specific ONNX runtime"],"best_for":["Model developers catching errors before deployment","CI/CD pipelines validating model artifacts","Runtime implementers verifying model compatibility"],"limitations":["Checker only validates static properties; cannot detect runtime errors or numerical issues","Custom operators without registered schemas will fail validation unless explicitly whitelisted","No semantic validation (e.g., detecting logically incorrect but syntactically valid graphs)"],"requires":["Python 3.8+","ONNX package with C++ extensions","Valid ModelProto object"],"input_types":["ModelProto objects","Optional: opset_version to validate against specific ONNX version"],"output_types":["Boolean (valid/invalid)","Error messages describing validation failures"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_5","uri":"capability://data.processing.analysis.numpy.based.tensor.conversion.and.initialization.with.automatic.type.mapping","name":"numpy-based tensor conversion and initialization with automatic type mapping","description":"ONNX provides numpy_helper.py for bidirectional conversion between NumPy arrays and ONNX TensorProto objects, with automatic dtype mapping between NumPy and ONNX data types (float32, int64, bool, etc.). The helper functions enable embedding NumPy arrays as model initializers (constant tensors) and extracting tensor data from models for inspection or testing. This is essential for model construction workflows where weights are typically represented as NumPy arrays.","intents":["I need to convert NumPy weight arrays into ONNX TensorProto format for model initialization","I want to extract tensor data from an ONNX model and convert it back to NumPy for inspection","I need to ensure correct dtype mapping between NumPy and ONNX when building models programmatically"],"best_for":["Model builders converting framework weights (PyTorch, TensorFlow) to ONNX","Data scientists inspecting model weights and activations","Testing frameworks validating model outputs against NumPy reference implementations"],"limitations":["Conversion overhead for large tensors; no streaming or lazy loading of tensor data","Limited dtype support compared to NumPy (e.g., no complex numbers, limited string support)","No automatic quantization or compression during conversion"],"requires":["Python 3.8+","NumPy 1.16+","ONNX package"],"input_types":["NumPy arrays (any dtype supported by ONNX)","TensorProto objects"],"output_types":["TensorProto objects with embedded or referenced data","NumPy arrays with inferred dtype"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_6","uri":"capability://code.generation.editing.textual.syntax.parser.and.printer.for.onnx.model.representation","name":"textual syntax parser and printer for onnx model representation","description":"ONNX includes a textual syntax parser and printer that converts between binary ModelProto format and human-readable text representation, enabling model inspection and debugging. The parser (implemented in C++) converts text syntax into protobuf structures, while the printer converts ModelProto objects back to text. This is useful for model visualization, version control in text format, and manual model editing.","intents":["I want to view an ONNX model in human-readable text format for debugging","I need to manually edit an ONNX model's graph structure using a text editor","I want to version control ONNX models in text format instead of binary"],"best_for":["Model developers debugging graph structure issues","Researchers analyzing model architectures","Version control workflows preferring text-based diffs"],"limitations":["Text format is verbose for large models; not practical for models with millions of parameters","Parsing text syntax is slower than loading binary format","No syntax highlighting or IDE support for ONNX text format"],"requires":["Python 3.8+","ONNX package with C++ extensions"],"input_types":["ONNX text syntax strings","ModelProto objects"],"output_types":["ModelProto objects","Human-readable text representation"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_7","uri":"capability://automation.workflow.backend.test.framework.with.reference.implementation.and.test.case.generation","name":"backend test framework with reference implementation and test case generation","description":"ONNX provides a comprehensive backend test framework (onnx/backend/test/) that enables testing of ONNX runtime implementations against a reference specification. The framework includes test case generation utilities that create operator-level test cases with input/output data, a reference implementation for validating operator behavior, and infrastructure for running tests across different backends. Test cases are generated from operator definitions and stored as serialized ONNX models with associated input/output data.","intents":["I need to implement an ONNX runtime and validate it against the reference specification","I want to generate comprehensive test cases for a new ONNX operator","I need to verify that my operator implementation matches the ONNX specification"],"best_for":["ONNX runtime implementers (TensorRT, ONNX Runtime, CoreML, etc.)","Operator developers validating new operator implementations","Continuous integration systems testing model compatibility"],"limitations":["Test case generation is limited to registered operators; custom operators require manual test creation","Reference implementation may not cover all edge cases or numerical precision requirements","Test coverage varies by operator; some operators have minimal test cases"],"requires":["Python 3.8+","ONNX package with reference implementation","Test data generation utilities"],"input_types":["Operator definitions","Test case specifications (input shapes, attributes, data types)"],"output_types":["Serialized ONNX test models","Input/output data files (.pb format)","Test case metadata (expected outputs, tolerances)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_8","uri":"capability://data.processing.analysis.external.data.handling.for.models.exceeding.protobuf.size.limits","name":"external data handling for models exceeding protobuf size limits","description":"ONNX implements external_data_helper.py to handle models larger than protobuf's 2GB serialization limit by splitting tensor data into separate files. Large tensors are stored as external data references (ExternalDataProto) while the model structure remains in the main .onnx file. This enables serialization of multi-gigabyte models while maintaining the ONNX format specification. The helper provides transparent loading and saving of models with external data.","intents":["I need to save a large model (>2GB) that exceeds protobuf's serialization limit","I want to load a model with external data references and access tensor values","I need to convert between inline and external tensor representations"],"best_for":["ML engineers working with large language models and vision transformers","Production systems deploying multi-gigabyte models","Model distribution systems requiring efficient storage and transfer"],"limitations":["External data files must be managed separately from the main .onnx file; no automatic bundling","Loading models with external data is slower than inline tensors due to file I/O","No built-in compression or deduplication of external data files"],"requires":["Python 3.8+","ONNX package","Sufficient disk space for external data files"],"input_types":["ModelProto objects with large tensors",".onnx files with ExternalDataProto references"],"output_types":["ModelProto with external data references","Separate .pb_data files containing tensor data"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-onnx__cap_9","uri":"capability://memory.knowledge.operator.versioning.and.opset.management.with.backward.compatibility.tracking","name":"operator versioning and opset management with backward compatibility tracking","description":"ONNX implements a versioning system where operators evolve through opset versions (currently opset 1-21+), with each version representing a snapshot of operator definitions. The system tracks operator changes (signature changes, attribute additions, deprecations) across versions, enabling models to specify which opset version they target. This allows new operator versions to be introduced without breaking existing models. Opset versions are managed globally (ai.onnx domain) and per-domain (ai.onnx.ml, com.microsoft, etc.).","intents":["I need to understand which opset version my model targets and what operators are available","I want to upgrade my model to use newer operator versions with improved semantics","I need to ensure my model remains compatible with older ONNX runtimes"],"best_for":["Model developers managing model versioning and compatibility","Framework converters (PyTorch → ONNX) targeting specific opset versions","Runtime implementers supporting multiple opset versions"],"limitations":["Opset versions are immutable once released; breaking changes require new opset versions","Upgrading models to newer opsets may require operator replacement or graph restructuring","No automatic opset upgrade tool; developers must manually update models"],"requires":["Python 3.8+","ONNX package","Knowledge of operator changes across opset versions"],"input_types":["ModelProto objects with opset_import specifications","Operator names and versions"],"output_types":["Opset version information","Operator compatibility information","Migration guidance for opset upgrades"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":26,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","protobuf library (bundled with onnx package)","NumPy for tensor conversion","ONNX model with valid operator schema definitions","Input shape information for dynamic dimensions (via ValueInfoProto)","ONNX package","Understanding of ONNX operator composition","CMake 3.13+","C++ compiler (GCC, Clang, MSVC)","Python 3.8+ with development headers"],"failure_modes":["Protobuf serialization adds overhead compared to framework-native formats; large models require external data handling via external_data_helper.py","Operator versioning requires explicit schema registration; custom operators need manual domain definition","No built-in compression; models with billions of parameters require external data splitting strategies","Cannot infer shapes for dynamic control flow (If, Loop operators) without concrete input shapes","Partial evaluation is limited to constant tensors; symbolic shapes require external shape information","Custom operators without registered shape inference functions will fail shape propagation","Function bodies are expanded at runtime or compile time; no performance benefit over expanded graphs","Debugging function bodies is more complex than debugging primitive operators","Type inference for functions requires explicit type constraint definitions","CMake build requires C++ compiler and build tools; not suitable for pure Python environments","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.9,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:16.568Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-onnx","compare_url":"https://unfragile.ai/compare?artifact=pypi-onnx"}},"signature":"udWxrFZWx+2bZU8cebIc4JndVbXwILSYPv/P4zXsUOg9Q2FLV5ezo2AftJ/nybL+r5D6rv/xEbK1YEU8G6t8Ag==","signedAt":"2026-06-15T21:38:53.340Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-onnx","artifact":"https://unfragile.ai/pypi-onnx","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-onnx","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}