{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-optimum","slug":"pypi-optimum","name":"optimum","type":"framework","url":"https://github.com/huggingface/optimum","page_url":"https://unfragile.ai/pypi-optimum","categories":["frameworks-sdks"],"tags":["transformers","quantization","pruning","optimization","training","inference","onnx","onnx","runtime","intel","habana","graphcore","neural","compressor","ipu","hpu"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-optimum__cap_0","uri":"capability://code.generation.editing.hardware.agnostic.model.export.to.optimized.formats","name":"hardware-agnostic model export to optimized formats","description":"Converts Hugging Face Transformers, Diffusers, TIMM, and Sentence-Transformers models to hardware-specific optimized formats (ONNX, OpenVINO, TensorRT, etc.) through a unified ExporterConfig framework that abstracts format-specific export logic. The system uses TasksManager to detect model task types, NormalizedConfig to standardize model configurations across architectures, and ExporterConfig subclasses to handle format-specific export parameters, enabling single-API exports across 40+ model architectures to 8+ target formats.","intents":["Export a BERT model to ONNX Runtime format for CPU inference without writing format-specific code","Convert a Stable Diffusion model to OpenVINO for Intel hardware deployment","Batch export multiple model architectures to TensorRT for NVIDIA GPU inference","Maintain export compatibility when upgrading model versions from Hugging Face Hub"],"best_for":["ML engineers optimizing models for production inference on heterogeneous hardware","Teams deploying models across multiple hardware platforms (CPU, GPU, TPU, custom accelerators)","Developers building model serving infrastructure that must support multiple backends"],"limitations":["Export success depends on target format support for specific model architecture — not all architectures supported by all backends","Dummy input generation may fail for models with complex dynamic shapes or custom input requirements","Graph optimization passes may not preserve exact numerical equivalence — requires validation against original model outputs","Export process can be memory-intensive for large models (>10B parameters) on resource-constrained machines"],"requires":["Python 3.8+","Hugging Face Transformers 4.25.0+","Target backend library installed (onnxruntime, openvino-dev, tensorrt, etc.)","Model weights accessible from Hugging Face Hub or local filesystem"],"input_types":["Pretrained model identifiers (string paths to Hugging Face Hub or local directories)","Model configuration objects (PretrainedConfig subclasses)","Optional: custom dummy input specifications for non-standard architectures"],"output_types":["ONNX model files (.onnx) with optional external weight files","OpenVINO IR format (.xml + .bin)","TensorRT engine files (.trt)","TFLite models (.tflite)","Quantized variants with calibration metadata"],"categories":["code-generation-editing","model-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_1","uri":"capability://tool.use.integration.multi.backend.optimized.model.inference.with.automatic.backend.routing","name":"multi-backend optimized model inference with automatic backend routing","description":"Provides a unified inference API (OptimizedModel base class with from_pretrained/save_pretrained) that automatically routes inference to the appropriate hardware backend (ONNX Runtime, OpenVINO, TensorRT, Inferentia, Gaudi, etc.) based on available hardware and model format. The Pipeline factory system wraps backend-specific inference engines with a Transformers-compatible interface, enabling drop-in replacement of standard Transformers pipelines while maintaining identical input/output contracts.","intents":["Load an optimized model and run inference without knowing which backend is available on the target machine","Switch inference backends at runtime based on hardware availability (fallback from GPU to CPU)","Use familiar Transformers pipeline API (pipeline('text-generation', model=...)) with optimized models","Benchmark inference latency/throughput across multiple backends on the same model"],"best_for":["Production inference systems requiring hardware abstraction and automatic backend selection","Teams deploying models across heterogeneous infrastructure (some nodes with GPUs, some CPU-only)","Developers building model serving platforms that must support multiple hardware vendors"],"limitations":["Backend routing logic is deterministic based on hardware detection — no explicit control over backend selection without environment variables","Some backends have limited operator support — inference may fall back to slower CPU execution for unsupported ops","Batch size and sequence length constraints vary by backend — requires per-backend tuning for optimal throughput","Diffusion pipeline support is backend-specific — not all backends support all diffusion model types"],"requires":["Python 3.8+","Hugging Face Transformers 4.25.0+","At least one backend library installed (onnxruntime, openvino, tensorrt, etc.)","Optimized model artifacts in compatible format (ONNX, OpenVINO IR, etc.)"],"input_types":["Model identifiers pointing to optimized model artifacts on Hub or local filesystem","Task type specification (text-generation, text-classification, image-to-text, etc.)","Standard Transformers pipeline inputs (text, images, audio depending on task)"],"output_types":["Pipeline outputs matching Transformers API (sequences, scores, embeddings, etc.)","Backend-specific performance metrics (latency, throughput, memory usage)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_10","uri":"capability://data.processing.analysis.benchmarking.and.performance.evaluation.framework","name":"benchmarking and performance evaluation framework","description":"Provides benchmarking utilities for measuring inference latency, throughput, and memory usage across different backends and optimization strategies. The system orchestrates benchmark runs with configurable batch sizes, sequence lengths, and hardware settings, collecting performance metrics and generating comparison reports.","intents":["Measure latency improvement from quantization: benchmark original vs quantized model","Compare inference performance across backends: ONNX vs OpenVINO vs TensorRT on same model","Find optimal batch size and sequence length for target hardware","Generate performance reports for model optimization decisions"],"best_for":["Performance engineers optimizing models for specific hardware targets","Teams evaluating quantization and export strategies before production deployment","Researchers studying performance characteristics of different optimization techniques"],"limitations":["Benchmark results are hardware-specific — cannot compare across different machines without normalization","Benchmarking requires representative inputs — synthetic inputs may not reflect real inference patterns","Memory measurements are approximate — actual peak memory may differ from reported values","Benchmarking is single-threaded — does not measure concurrent inference performance"],"requires":["Python 3.8+","Target backend libraries installed","Representative input data for benchmarking"],"input_types":["Model identifiers or objects","Benchmark configuration (batch sizes, sequence lengths, num_runs)","Optional: custom input data"],"output_types":["Performance metrics (latency, throughput, memory usage)","Benchmark reports with comparisons across backends/strategies","Raw benchmark data for further analysis"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_11","uri":"capability://image.visual.diffusion.model.optimization.and.export","name":"diffusion model optimization and export","description":"Extends model export and optimization to diffusion models (Stable Diffusion, etc.) by handling multi-component pipelines (text encoder, UNet, VAE decoder) and diffusion-specific optimizations (attention optimization, memory-efficient sampling). The system exports each pipeline component separately and manages component composition for inference.","intents":["Export Stable Diffusion to ONNX Runtime for CPU image generation","Optimize diffusion model inference with attention fusion and memory-efficient sampling","Quantize diffusion model components with different strategies (e.g., 8-bit for text encoder, 4-bit for UNet)","Run diffusion inference on resource-constrained hardware (mobile, edge devices)"],"best_for":["Teams deploying diffusion models for image generation on resource-constrained hardware","Developers optimizing diffusion inference latency for real-time applications","Researchers studying quantization and optimization techniques for diffusion models"],"limitations":["Diffusion model export is more complex than standard models — requires handling multi-component pipelines","Quantization of diffusion models is less studied — may have larger accuracy impact than LLM quantization","Diffusion inference is memory-intensive — optimization benefits may be limited on very constrained hardware","Backend support for diffusion is limited — not all backends support all diffusion model types"],"requires":["Python 3.8+","Hugging Face Diffusers library","Target backend libraries for diffusion support"],"input_types":["Diffusion model identifiers (Stable Diffusion, etc.)","Pipeline component specifications","Optimization configuration (quantization strategy, attention optimization, etc.)"],"output_types":["Optimized diffusion pipeline components (text encoder, UNet, VAE)","Pipeline configuration for component composition","Quantization configs for each component"],"categories":["image-visual","model-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_2","uri":"capability://data.processing.analysis.gptq.quantization.with.calibration.and.per.layer.configuration","name":"gptq quantization with calibration and per-layer configuration","description":"Implements GPTQ (Generative Pre-trained Transformer Quantization) post-training quantization with automatic calibration dataset preparation, per-layer quantization parameter tuning, and group-wise quantization support. The system integrates with Hugging Face datasets for automatic calibration data loading, supports custom calibration datasets, and generates quantization configurations that can be saved and reused across model instances.","intents":["Quantize a 7B-parameter LLM to 4-bit precision for 4x memory reduction with minimal accuracy loss","Apply different quantization parameters to different layers (e.g., keep attention layers at higher precision)","Calibrate quantization on a custom domain-specific dataset rather than generic text","Save quantization configuration and reapply to model updates without recomputing calibration"],"best_for":["ML engineers optimizing large language models for memory-constrained inference (mobile, edge, consumer GPUs)","Teams deploying 7B+ parameter models on hardware with <24GB VRAM","Researchers studying quantization-accuracy tradeoffs across model families"],"limitations":["Quantization is post-training only — cannot be applied during training, limiting fine-tuning after quantization","Calibration dataset quality significantly impacts quantization accuracy — poor calibration data can cause 5-10% accuracy degradation","Group-wise quantization adds per-group overhead — very small group sizes (<32) may reduce speedup benefits","Quantized models are backend-specific — GPTQ-quantized models require GPTQ-aware inference engines (AutoGPTQ, vLLM, etc.)"],"requires":["Python 3.8+","PyTorch 1.13+","Hugging Face Transformers 4.30.0+","AutoGPTQ library for quantization execution","Calibration dataset (can be auto-loaded from Hugging Face datasets or custom)"],"input_types":["Pretrained model identifiers or loaded model objects","Calibration dataset (HuggingFace dataset identifier, local dataset, or custom iterable)","Quantization configuration (bits=4/8, group_size, desc_act, etc.)"],"output_types":["Quantized model weights in GPTQ format","Quantization configuration JSON (scales, zero-points, group mappings)","Calibration statistics for analysis and debugging"],"categories":["data-processing-analysis","model-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_3","uri":"capability://code.generation.editing.graph.level.optimization.via.torch.fx.transformation.composition","name":"graph-level optimization via torch.fx transformation composition","description":"Applies graph-level optimizations to PyTorch models using the Torch.fx symbolic tracing system, enabling operator fusion, dead code elimination, and custom transformation passes. The system composes multiple transformation passes (fusion, constant folding, layout optimization) through a transformation registry, allowing models to be optimized before export or inference without modifying source code.","intents":["Automatically fuse attention patterns (Q*K^T -> softmax -> V) into single operators for 20-30% latency reduction","Remove unused branches and dead code from conditional models before export","Apply layout transformations (NCHW to NHWC) for hardware-specific tensor format optimization","Compose custom optimization passes for domain-specific model patterns"],"best_for":["Performance engineers optimizing model inference latency on specific hardware","Teams building custom optimization passes for proprietary model architectures","Developers optimizing models for edge deployment where every millisecond matters"],"limitations":["Torch.fx symbolic tracing fails on models with data-dependent control flow (dynamic shapes, conditional branches based on tensor values)","Graph optimizations are hardware-agnostic — fusion patterns may not map to actual hardware operators on target device","Transformation composition order matters — incorrect ordering can produce incorrect results or miss optimization opportunities","Optimized graphs may be harder to debug — symbolic tracing obscures original source code structure"],"requires":["Python 3.8+","PyTorch 1.13+","Models must be traceable with Torch.fx (no data-dependent control flow)"],"input_types":["PyTorch model objects (nn.Module subclasses)","Dummy inputs for tracing (required to construct symbolic graph)","Transformation pass specifications (fusion patterns, layout targets, etc.)"],"output_types":["Optimized PyTorch models (nn.Module subclasses)","Transformation logs showing applied optimizations and latency improvements"],"categories":["code-generation-editing","model-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_4","uri":"capability://automation.workflow.unified.cli.for.model.optimization.workflows","name":"unified cli for model optimization workflows","description":"Provides a command-line interface with subcommands for export, quantization, benchmarking, and environment inspection, using a plugin-based command registration system that allows hardware partners to register backend-specific commands. The CLI uses entry-point discovery to dynamically load subcommands from installed subpackages, enabling extensibility without modifying core CLI code.","intents":["Export a model from command line: optimum-cli export onnx --model-name-or-path bert-base-uncased --output-dir ./onnx_model","Quantize a model with GPTQ: optimum-cli quantize gptq --model-name-or-path meta-llama/Llama-2-7b --output-dir ./quantized","Benchmark inference latency across backends: optimum-cli benchmark --model-name-or-path bert-base-uncased --backends onnx openvino","Inspect environment and available backends: optimum-cli env"],"best_for":["ML engineers and data scientists preferring command-line workflows over Python APIs","CI/CD pipelines automating model optimization as part of deployment","Teams building custom optimization workflows that compose multiple Optimum operations"],"limitations":["CLI arguments are less flexible than Python API — complex configurations require YAML/JSON config files","Error messages may be less informative than Python tracebacks — debugging requires verbose logging flags","CLI is synchronous — long-running operations (quantization, export) block terminal without progress indication","Backend-specific CLI commands are only available if corresponding subpackage is installed"],"requires":["Python 3.8+","Optimum package installed with CLI entry point","Target backend libraries installed for specific subcommands"],"input_types":["Command-line arguments (model identifiers, output directories, format specifications)","Optional: YAML/JSON configuration files for complex workflows","Optional: environment variables for backend selection and API keys"],"output_types":["Optimized model artifacts (ONNX, OpenVINO, etc.)","Quantization configurations and statistics","Benchmark reports (latency, throughput, memory usage)","Environment information (installed backends, versions, hardware specs)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_5","uri":"capability://data.processing.analysis.model.agnostic.dummy.input.generation.for.export","name":"model-agnostic dummy input generation for export","description":"Automatically generates valid dummy inputs for model export by inspecting model signatures and task types, supporting dynamic shapes, multiple input types (text, images, audio), and custom input specifications. The system uses TasksManager to determine expected input shapes and types, then constructs dummy tensors that satisfy model input requirements without manual specification.","intents":["Export a vision transformer without manually specifying image tensor dimensions and preprocessing","Generate dummy inputs for multimodal models (text + image) automatically","Handle models with dynamic batch sizes and sequence lengths during export","Override auto-generated inputs for models with non-standard input requirements"],"best_for":["Developers exporting models without deep knowledge of model input specifications","Automation systems that must export diverse model architectures without manual configuration","Teams building model export pipelines that handle 40+ model architectures"],"limitations":["Dummy input generation fails for models with data-dependent input shapes (e.g., models that require specific sequence lengths)","Custom input types (e.g., sparse tensors, nested structures) are not auto-generated — require manual specification","Generated inputs may not reflect realistic data distributions — can miss edge cases in export validation","Dynamic shape handling is limited — models with complex dynamic shape constraints may require manual input specification"],"requires":["Python 3.8+","Hugging Face Transformers 4.25.0+","Model must have registered task type in TasksManager"],"input_types":["Model objects or identifiers","Task type specification (auto-detected or manual)","Optional: custom input specifications for non-standard models"],"output_types":["Dictionary of dummy input tensors matching model signature","Input shape and type specifications for validation"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_6","uri":"capability://data.processing.analysis.calibration.dataset.preparation.and.management","name":"calibration dataset preparation and management","description":"Provides utilities for preparing calibration datasets for quantization, supporting automatic loading from Hugging Face datasets, custom dataset formats, and dataset preprocessing pipelines. The system handles dataset sampling, batching, and preprocessing to ensure calibration data is representative and properly formatted for quantization algorithms.","intents":["Load a standard calibration dataset (e.g., WikiText) automatically for GPTQ quantization","Use a custom domain-specific dataset for calibration (e.g., medical text for domain-specific LLM)","Sample a subset of calibration data for faster quantization on resource-constrained machines","Apply preprocessing (tokenization, normalization) to calibration data automatically"],"best_for":["ML engineers quantizing models for production with domain-specific calibration requirements","Teams optimizing models for specific domains where generic calibration data is insufficient","Researchers studying impact of calibration data quality on quantization accuracy"],"limitations":["Calibration dataset quality is critical — poor calibration data can cause 5-10% accuracy degradation","Large calibration datasets increase quantization time — tradeoff between calibration quality and speed","Dataset preprocessing must match model training preprocessing — mismatches can reduce quantization effectiveness","No automatic validation that calibration data is representative of inference distribution"],"requires":["Python 3.8+","Hugging Face datasets library for automatic dataset loading","Calibration dataset (Hugging Face dataset identifier or local files)"],"input_types":["Dataset identifiers (Hugging Face dataset names or local paths)","Dataset configuration (split, subset, preprocessing options)","Sampling parameters (num_samples, batch_size)"],"output_types":["Prepared calibration dataset (batched, preprocessed, ready for quantization)","Dataset statistics (size, preprocessing applied, sample distribution)"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_7","uri":"capability://data.processing.analysis.normalized.model.configuration.abstraction.across.architectures","name":"normalized model configuration abstraction across architectures","description":"Provides a NormalizedConfig system that abstracts model configuration differences across 40+ architectures (BERT, GPT, Vision Transformer, etc.) into a unified interface, enabling export and optimization code to work with any architecture without architecture-specific conditionals. The system maps architecture-specific config attributes to normalized names, handling naming variations and deprecated config fields.","intents":["Write export code that works for BERT, RoBERTa, and DistilBERT without checking model type","Access model hidden size, num_layers, and vocab_size using consistent attribute names across architectures","Handle config variations (e.g., some models use 'hidden_size', others use 'dim') transparently","Support new architectures without modifying export/optimization code"],"best_for":["Framework developers building architecture-agnostic export and optimization tools","Teams supporting 40+ model architectures without maintaining architecture-specific code paths","Developers building model optimization pipelines that must handle diverse architectures"],"limitations":["NormalizedConfig only covers common attributes — architecture-specific attributes are not normalized","Mapping between architecture-specific and normalized names must be manually maintained — adding new architectures requires config updates","Some architectures have fundamentally different config structures — normalization may lose information","Normalized config is read-only — modifications require accessing underlying architecture-specific config"],"requires":["Python 3.8+","Hugging Face Transformers 4.25.0+"],"input_types":["Model configuration objects (PretrainedConfig subclasses)","Model identifiers (auto-loads config from Hub)"],"output_types":["Normalized configuration objects with unified attribute names","Mapping between normalized and architecture-specific attribute names"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_8","uri":"capability://planning.reasoning.task.based.model.type.detection.and.routing","name":"task-based model type detection and routing","description":"Implements TasksManager that automatically detects model task types (text-classification, text-generation, image-classification, etc.) from model architecture and configuration, enabling task-specific export, quantization, and inference logic. The system maintains a registry of task-to-architecture mappings and uses model introspection to determine the appropriate task type.","intents":["Automatically determine that a model is for text-generation and apply generation-specific optimizations","Route a model to the correct export pipeline based on detected task type","Select appropriate dummy inputs based on task type without manual specification","Apply task-specific quantization strategies (e.g., different calibration for generation vs classification)"],"best_for":["Developers building task-agnostic model optimization pipelines","Teams automating model export workflows that must handle diverse task types","Systems that need to infer model capabilities from architecture alone"],"limitations":["Task detection is based on architecture patterns — custom or fine-tuned models may be misclassified","Multi-task models are not well-supported — system assumes single primary task","Task detection is deterministic — no way to override detected task without manual configuration","New task types require TasksManager updates — cannot be extended by users"],"requires":["Python 3.8+","Hugging Face Transformers 4.25.0+"],"input_types":["Model objects or identifiers","Model configuration objects"],"output_types":["Task type identifier (text-generation, image-classification, etc.)","Task-specific metadata (expected input/output formats, supported backends)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-optimum__cap_9","uri":"capability://memory.knowledge.hub.integrated.model.persistence.and.versioning","name":"hub-integrated model persistence and versioning","description":"Provides save_pretrained/from_pretrained methods that integrate with Hugging Face Hub, enabling optimized models to be saved with metadata, versioned, and shared on Hub alongside original models. The system handles serialization of optimization artifacts (quantization configs, export metadata) and manages file organization for multi-file model formats (ONNX with external weights, OpenVINO IR).","intents":["Save an optimized model to Hub with quantization config and export metadata","Load an optimized model from Hub with automatic backend detection","Version optimized models separately from original models on Hub","Share optimized models with team members or community via Hub"],"best_for":["Teams sharing optimized models within organization or community","ML engineers building model optimization pipelines that integrate with Hub workflows","Developers maintaining multiple optimized versions of the same base model"],"limitations":["Hub integration requires authentication for private models — API tokens must be configured","Large optimized models may exceed Hub file size limits — requires splitting into multiple files","Metadata format is Optimum-specific — optimized models are not directly compatible with standard Transformers Hub tools","Version management is manual — no automatic tracking of optimization history or base model versions"],"requires":["Python 3.8+","Hugging Face Hub account and API token for uploading","Hugging Face transformers library"],"input_types":["Optimized model objects","Output directory or Hub repository identifier","Optional: metadata and commit messages"],"output_types":["Saved model artifacts on local filesystem or Hub","Model card with optimization metadata","Quantization configs and export metadata"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":32,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","Hugging Face Transformers 4.25.0+","Target backend library installed (onnxruntime, openvino-dev, tensorrt, etc.)","Model weights accessible from Hugging Face Hub or local filesystem","At least one backend library installed (onnxruntime, openvino, tensorrt, etc.)","Optimized model artifacts in compatible format (ONNX, OpenVINO IR, etc.)","Target backend libraries installed","Representative input data for benchmarking","Hugging Face Diffusers library","Target backend libraries for diffusion support"],"failure_modes":["Export success depends on target format support for specific model architecture — not all architectures supported by all backends","Dummy input generation may fail for models with complex dynamic shapes or custom input requirements","Graph optimization passes may not preserve exact numerical equivalence — requires validation against original model outputs","Export process can be memory-intensive for large models (>10B parameters) on resource-constrained machines","Backend routing logic is deterministic based on hardware detection — no explicit control over backend selection without environment variables","Some backends have limited operator support — inference may fall back to slower CPU execution for unsupported ops","Batch size and sequence length constraints vary by backend — requires per-backend tuning for optimal throughput","Diffusion pipeline support is backend-specific — not all backends support all diffusion model types","Benchmark results are hardware-specific — cannot compare across different machines without normalization","Benchmarking requires representative inputs — synthetic inputs may not reflect real inference patterns","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:05.295Z","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-optimum","compare_url":"https://unfragile.ai/compare?artifact=pypi-optimum"}},"signature":"xEyV43vpwvqdXVlmnSK0Gh9njU4ATcEFaT2eGKKvwWIbiZCIJxb9ZZULEBoGUawhig5CDvobDuHmIp5zqAM7AQ==","signedAt":"2026-06-21T18:49:15.700Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-optimum","artifact":"https://unfragile.ai/pypi-optimum","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-optimum","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"}}