{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-trl","slug":"pypi-trl","name":"trl","type":"framework","url":"https://pypi.org/project/trl/","page_url":"https://unfragile.ai/pypi-trl","categories":["model-training"],"tags":["transformers","huggingface","language","modeling","post-training","rlhf","sft","dpo","grpo"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-trl__cap_0","uri":"capability://code.generation.editing.supervised.fine.tuning.with.causal.lm.objective","name":"supervised-fine-tuning-with-causal-lm-objective","description":"Implements supervised fine-tuning (SFT) for causal language models using a standard next-token prediction loss across instruction-response pairs. The trainer wraps Hugging Face Transformers' Trainer class, automatically handling data formatting, tokenization, and gradient accumulation across distributed setups. It supports both full-model and parameter-efficient fine-tuning (LoRA/QLoRA) through integration with the peft library, enabling memory-efficient training on consumer hardware.","intents":["Fine-tune a base LLM on instruction-following datasets to improve task performance","Train a model on domain-specific text data while keeping computational costs manageable","Adapt a pre-trained model to follow specific output formats or style guidelines"],"best_for":["ML engineers building custom instruction-tuned models","Teams with limited GPU memory wanting to fine-tune large models","Researchers prototyping new instruction datasets"],"limitations":["No built-in curriculum learning or hard example mining — requires manual data ordering","Gradient checkpointing overhead adds ~15-20% training time but reduces memory by 50%","No native support for multi-task learning or task-specific loss weighting","Tokenization happens at dataset load time, not dynamically — requires pre-processing for variable-length sequences"],"requires":["Python 3.8+","PyTorch 1.13+","transformers library 4.30+","datasets library for data loading","peft library if using LoRA/QLoRA"],"input_types":["JSON/CSV datasets with 'text' or 'instruction'/'response' columns","Hugging Face Dataset objects","Pre-tokenized arrow format"],"output_types":["Fine-tuned model weights (safetensors or PyTorch format)","Training logs with loss curves and evaluation metrics","LoRA adapter weights if using parameter-efficient training"],"categories":["code-generation-editing","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_1","uri":"capability://planning.reasoning.reinforcement.learning.from.human.feedback.rlhf.training","name":"reinforcement-learning-from-human-feedback-rlhf-training","description":"Implements the RLHF pipeline (reward modeling + policy optimization) using a two-stage approach: first trains a reward model on human preference pairs (chosen vs rejected responses), then uses PPO (Proximal Policy Optimization) to optimize the language model policy against the learned reward signal. The implementation includes KL divergence penalties to prevent policy drift from the base model and supports both online (generate-then-score) and offline (pre-computed scores) training modes.","intents":["Align a language model with human preferences by training on comparison data","Implement a full RLHF pipeline from preference data to aligned model","Optimize model outputs for human-defined quality metrics without explicit labels"],"best_for":["Teams with human preference annotation pipelines or existing comparison datasets","Researchers studying alignment and preference learning","Production systems requiring iterative model improvement with human feedback"],"limitations":["PPO training is sample-inefficient — requires 10-100x more tokens than SFT for convergence","Reward model overfitting common on small preference datasets (<10k pairs) without careful regularization","Online PPO requires generating completions during training, adding 3-5x computational overhead vs offline methods","KL penalty coefficient is manually tuned; no adaptive scheduling built-in","Requires careful hyperparameter tuning (learning rate, batch size, PPO epochs) — poor defaults lead to policy collapse"],"requires":["Python 3.8+","PyTorch 1.13+ with CUDA support (CPU training impractical)","transformers 4.30+","trl's PPOTrainer class","Pre-trained reward model or ability to train one","Preference dataset with (prompt, chosen_response, rejected_response) tuples"],"input_types":["Preference pairs: (prompt, chosen, rejected) in JSON/CSV","Pre-computed reward scores for offline training","Prompts for online generation-based training"],"output_types":["RLHF-aligned model weights","Training curves showing reward improvement and KL divergence","Reward model checkpoint (if training from scratch)"],"categories":["planning-reasoning","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_10","uri":"capability://data.processing.analysis.dataset.formatting.and.preprocessing.utilities","name":"dataset-formatting-and-preprocessing-utilities","description":"Provides utilities to format and preprocess datasets for different training objectives (SFT, RLHF, DPO, etc.). Includes data collators that handle variable-length sequences, automatic padding/truncation, and format conversion (e.g., instruction-response to prompt-completion). Supports streaming datasets for memory-efficient processing of large corpora and automatic train/validation splitting.","intents":["Convert raw datasets into formats compatible with trl trainers","Handle variable-length sequences and padding without manual preprocessing","Stream large datasets without loading entire corpus into memory"],"best_for":["ML engineers preparing datasets for training","Teams working with large or streaming datasets","Researchers experimenting with different dataset formats"],"limitations":["Data collators assume left-padding for causal LMs; right-padding requires custom implementation","No built-in handling of multi-lingual datasets or language-specific preprocessing","Streaming datasets require careful handling of epoch boundaries in distributed training","Automatic padding can waste computation on short sequences — no dynamic batching","No deduplication or quality filtering — requires external tools"],"requires":["Python 3.8+","datasets library 2.0+","transformers 4.30+"],"input_types":["Raw datasets (JSON, CSV, Parquet, Hugging Face Dataset format)","Format specification (instruction-response, prompt-completion, etc.)"],"output_types":["Formatted datasets compatible with trl trainers","Data collators for batching","Train/validation splits"],"categories":["data-processing-analysis","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_11","uri":"capability://data.processing.analysis.model.merging.and.adapter.composition","name":"model-merging-and-adapter-composition","description":"Provides utilities to merge LoRA adapters into base models and compose multiple adapters for multi-task inference. Supports weighted merging (combining multiple adapters with different weights), sequential composition (stacking adapters), and adapter pruning (removing low-importance parameters). Handles numerical stability during merging and supports saving merged models in standard formats.","intents":["Merge trained LoRA adapters into base models for deployment","Combine multiple task-specific adapters for multi-task inference","Reduce inference latency by eliminating adapter overhead"],"best_for":["Teams deploying LoRA-trained models to production","Projects requiring multi-task models without separate model instances","Researchers studying adapter composition and transfer learning"],"limitations":["Merging requires full base model in memory — not feasible for very large models (>70B parameters)","Weighted adapter merging is heuristic-based; optimal weights require manual tuning","Sequential composition can lead to numerical instability if adapters are not compatible","No automatic conflict detection when composing adapters trained on different tasks","Merged models lose the ability to swap adapters — requires retraining for new tasks"],"requires":["Python 3.8+","PyTorch 1.13+","peft library 0.4+","Base model and LoRA adapter weights"],"input_types":["Base model","One or more LoRA adapters","Optional: weights for weighted merging"],"output_types":["Merged model (base + adapter combined)","Merged model in standard formats (safetensors, PyTorch)"],"categories":["data-processing-analysis","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_12","uri":"capability://automation.workflow.training.monitoring.and.logging.integration","name":"training-monitoring-and-logging-integration","description":"Integrates with popular logging platforms (Weights & Biases, TensorBoard, Hugging Face Hub) to track training metrics, model checkpoints, and hyperparameters. Automatically logs loss curves, evaluation metrics, learning rate schedules, and gradient statistics. Supports custom metric logging and integration with external monitoring systems via callbacks.","intents":["Monitor training progress in real-time across distributed setups","Log and compare hyperparameters and results across multiple training runs","Automatically save and version model checkpoints to cloud storage"],"best_for":["Teams running multiple training experiments","Researchers comparing model variants systematically","Production systems requiring training audit trails"],"limitations":["Logging overhead adds 1-2% training time for cloud platforms","Large models generate huge logs; filtering/sampling required for manageable storage","No built-in cost tracking — requires manual calculation of compute expenses","Callback system is synchronous; slow callbacks can block training","Limited support for custom metrics beyond standard loss/accuracy"],"requires":["Python 3.8+","Optional: wandb, tensorboard, or huggingface_hub libraries"],"input_types":["Training metrics (loss, accuracy, etc.)","Model checkpoints","Hyperparameters"],"output_types":["Training dashboards (W&B, TensorBoard)","Model checkpoints in cloud storage","Training logs and metadata"],"categories":["automation-workflow","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_2","uri":"capability://planning.reasoning.direct.preference.optimization.dpo.training","name":"direct-preference-optimization-dpo-training","description":"Implements Direct Preference Optimization (DPO), a single-stage alternative to RLHF that directly optimizes the language model on preference pairs without training a separate reward model. DPO uses a contrastive loss that maximizes the likelihood ratio between preferred and dispreferred responses, implicitly learning a reward function. The implementation includes support for IPO (Identity Preference Optimization) and other preference optimization variants, with built-in handling of prompt-level weighting and batch-level preference balancing.","intents":["Train an aligned model directly from preference data without the complexity of reward modeling","Reduce training complexity and computational cost compared to RLHF by eliminating the reward model stage","Experiment with preference optimization variants (DPO, IPO, KTO) on the same codebase"],"best_for":["Teams wanting simpler alignment pipelines than RLHF","Researchers exploring preference optimization methods","Projects with limited compute budgets (DPO requires ~50% less compute than RLHF)"],"limitations":["Assumes preference pairs are well-calibrated; noisy or inconsistent preferences degrade performance significantly","No built-in handling of multi-way comparisons (e.g., ranking 3+ responses) — requires pairwise decomposition","Beta hyperparameter (temperature of implicit reward) requires tuning; default values may not work across domains","Implicit reward function is not directly interpretable — harder to debug than explicit reward models","Requires balanced preference datasets; severe imbalance toward chosen responses causes training instability"],"requires":["Python 3.8+","PyTorch 1.13+","transformers 4.30+","Preference dataset with (prompt, chosen, rejected) format","Base model (typically instruction-tuned LLM)"],"input_types":["Preference pairs: (prompt, chosen_response, rejected_response)","Optional: per-example weights for importance sampling"],"output_types":["DPO-optimized model weights","Training metrics: preference accuracy, implicit reward estimates","Loss curves showing convergence"],"categories":["planning-reasoning","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_3","uri":"capability://planning.reasoning.generative.reward.optimization.grpo.training","name":"generative-reward-optimization-grpo-training","description":"Implements Generative Reward Preference Optimization (GRPO), which combines reward modeling with policy optimization in a single end-to-end differentiable process. GRPO trains a model to generate both responses and reward scores simultaneously, using the generated rewards to optimize the policy via policy gradient methods. This approach reduces the two-stage complexity of RLHF while maintaining explicit reward signals, using a shared or separate reward head on the language model.","intents":["Train a model that generates both outputs and self-assessed quality scores in one unified process","Implement alignment with explicit reward signals without separate reward model training","Reduce training pipeline complexity while maintaining interpretable reward computation"],"best_for":["Teams exploring unified reward+policy training architectures","Researchers studying self-rewarding models and intrinsic alignment","Projects wanting explicit rewards without the overhead of separate reward model training"],"limitations":["Self-generated rewards can be biased toward the model's own outputs — requires careful regularization","Training instability if reward head and policy head are not properly balanced","Requires careful initialization of reward head to avoid reward collapse (all high scores)","Less mature than RLHF/DPO — fewer published best practices and hyperparameter guidelines","Computational overhead similar to online RLHF due to generation during training"],"requires":["Python 3.8+","PyTorch 1.13+","transformers 4.30+","Modified model architecture with reward head (or trl's built-in reward head wrapper)","Preference or quality annotation data"],"input_types":["Prompts for generation-based training","Optional: pre-computed reference rewards for regularization"],"output_types":["Model with integrated reward head","Generated responses with self-assessed rewards","Training curves showing policy and reward convergence"],"categories":["planning-reasoning","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_4","uri":"capability://data.processing.analysis.batch.reward.scoring.and.preference.ranking","name":"batch-reward-scoring-and-preference-ranking","description":"Provides utilities to score model outputs using a trained reward model and rank responses by quality without requiring full RLHF training. Supports batch processing of completions through a reward model, with configurable scoring strategies (e.g., per-token vs full-sequence rewards). Includes utilities for converting scores to preference pairs and filtering low-quality examples, enabling offline dataset creation for DPO or other preference-based methods.","intents":["Score a batch of model completions using a reward model to create preference datasets","Rank multiple responses to the same prompt by predicted quality","Convert reward scores into preference pairs for downstream training"],"best_for":["Teams creating preference datasets from existing model outputs","Researchers building iterative alignment pipelines","Projects using reward models for filtering or ranking without full RLHF"],"limitations":["Reward model quality directly impacts downstream training — garbage scores produce garbage preferences","No built-in uncertainty quantification — hard to identify low-confidence scores","Batch processing assumes reward model fits in memory; very large models require gradient checkpointing or model parallelism","Preference pair creation from scores requires manual threshold tuning","No deduplication or diversity sampling — can create redundant preference pairs"],"requires":["Python 3.8+","PyTorch 1.13+","Trained reward model (compatible with transformers)","Batch of prompts and completions to score"],"input_types":["Prompts (list of strings)","Completions (list of strings or list of lists for multiple responses per prompt)","Optional: reference scores for calibration"],"output_types":["Reward scores (float tensors)","Ranked completions (sorted by score)","Preference pairs (chosen, rejected tuples)","Filtering masks (boolean tensors for quality thresholding)"],"categories":["data-processing-analysis","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_5","uri":"capability://automation.workflow.multi.gpu.and.distributed.training.orchestration","name":"multi-gpu-and-distributed-training-orchestration","description":"Abstracts distributed training across multiple GPUs and nodes using Hugging Face Accelerate library, automatically handling data parallelism, gradient synchronization, and mixed-precision training. Supports both single-machine multi-GPU (DataParallel, DistributedDataParallel) and multi-node setups with automatic device placement and loss scaling. Includes built-in support for gradient accumulation to simulate larger effective batch sizes on memory-constrained hardware.","intents":["Train large models across multiple GPUs without manual distributed training code","Scale training from single GPU to multi-node clusters with minimal configuration changes","Reduce memory footprint through gradient accumulation and mixed-precision training"],"best_for":["Teams training models larger than single-GPU memory","ML engineers scaling from development to production training","Researchers experimenting with different hardware configurations"],"limitations":["Synchronization overhead scales with number of GPUs — diminishing returns beyond 8 GPUs on single node","Mixed-precision training requires careful loss scaling to avoid gradient underflow","Gradient accumulation increases training time proportionally to accumulation steps","No automatic load balancing — uneven batch sizes across GPUs can cause hangs","Requires NCCL or Gloo backend setup; misconfiguration leads to cryptic distributed training errors"],"requires":["Python 3.8+","PyTorch 1.13+","accelerate library 0.20+","CUDA 11.0+ for multi-GPU","NCCL 2.0+ for multi-node"],"input_types":["PyTorch DataLoader objects","Batch size (automatically divided across GPUs)"],"output_types":["Synchronized model weights across all processes","Aggregated loss and metrics"],"categories":["automation-workflow","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_6","uri":"capability://code.generation.editing.parameter.efficient.fine.tuning.with.lora.and.qlora","name":"parameter-efficient-fine-tuning-with-lora-and-qlora","description":"Integrates peft library to enable Low-Rank Adaptation (LoRA) and Quantized LoRA (QLoRA) fine-tuning, which trains only small adapter matrices instead of full model weights. LoRA adds trainable rank-r decompositions to weight matrices, reducing parameters by 99%+. QLoRA further quantizes the base model to 4-bit precision, enabling fine-tuning of 70B+ parameter models on consumer GPUs. Automatically handles adapter merging, saving, and loading.","intents":["Fine-tune large models on consumer hardware (single GPU with <24GB VRAM)","Reduce storage and deployment costs by training only adapter weights","Maintain multiple task-specific adapters without duplicating base model weights"],"best_for":["Individual developers and small teams with limited GPU budgets","Production systems requiring multiple task-specific model variants","Researchers experimenting with large models without institutional compute"],"limitations":["LoRA rank and alpha hyperparameters require tuning; suboptimal choices reduce model capacity","QLoRA quantization adds ~10-15% training time overhead due to dequantization during forward pass","Adapter inference adds ~5-10% latency compared to merged weights","Merging adapters into base model requires full model in memory — not feasible for very large models","No built-in support for adapter composition (combining multiple adapters) — requires manual routing"],"requires":["Python 3.8+","PyTorch 1.13+","peft library 0.4+","transformers 4.30+","bitsandbytes 0.39+ for QLoRA quantization"],"input_types":["Pre-trained model (any transformers-compatible architecture)","LoRA config specifying rank, alpha, target modules"],"output_types":["LoRA adapter weights (typically 1-5% of base model size)","Merged model (base + adapter combined)","Adapter config (JSON specifying architecture)"],"categories":["code-generation-editing","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_7","uri":"capability://data.processing.analysis.model.evaluation.and.generation.utilities","name":"model-evaluation-and-generation-utilities","description":"Provides utilities for generating completions from trained models and evaluating them against reference outputs or metrics. Includes batch generation with configurable decoding strategies (greedy, beam search, sampling), automatic tokenization and detokenization, and integration with common evaluation metrics (BLEU, ROUGE, exact match). Supports both offline evaluation on fixed datasets and online evaluation during training with periodic checkpointing.","intents":["Generate model outputs for evaluation without writing custom generation loops","Evaluate model quality using standard metrics during and after training","Compare model outputs against reference answers or human judgments"],"best_for":["ML engineers building evaluation pipelines","Researchers comparing model variants systematically","Teams integrating model evaluation into CI/CD workflows"],"limitations":["Automatic metrics (BLEU, ROUGE) correlate poorly with human judgment for open-ended tasks","Generation with beam search is slow — 5-10x slower than greedy decoding","No built-in support for task-specific metrics (e.g., code execution for code generation)","Evaluation metrics are computed on CPU after generation, adding latency","No confidence intervals or significance testing — requires manual statistical analysis"],"requires":["Python 3.8+","PyTorch 1.13+","transformers 4.30+","Optional: datasets library for metric computation"],"input_types":["Prompts (list of strings)","Optional: reference outputs for metric computation","Generation config (max_length, temperature, top_p, etc.)"],"output_types":["Generated completions (list of strings)","Evaluation metrics (dict with BLEU, ROUGE, exact match scores)","Generation metadata (tokens, probabilities, beam scores)"],"categories":["data-processing-analysis","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_8","uri":"capability://automation.workflow.memory.efficient.training.with.gradient.checkpointing","name":"memory-efficient-training-with-gradient-checkpointing","description":"Implements gradient checkpointing (activation checkpointing) to reduce peak memory usage during training by recomputing activations during backpropagation instead of storing them. Automatically applies checkpointing to transformer blocks, reducing memory by 50-70% at the cost of ~15-20% training time overhead. Supports selective checkpointing (only checkpoint expensive layers) and integration with quantization for extreme memory efficiency.","intents":["Train larger models or larger batch sizes on memory-constrained GPUs","Reduce out-of-memory errors when fine-tuning large models","Enable training of models that would otherwise require multi-GPU setups"],"best_for":["Developers training on consumer GPUs (RTX 3090, A100, etc.)","Teams with limited GPU budgets wanting to maximize model size","Researchers exploring memory-compute tradeoffs"],"limitations":["Gradient checkpointing adds 15-20% training time overhead due to recomputation","Selective checkpointing requires manual layer selection — no automatic heuristics","Incompatible with some custom CUDA kernels (e.g., flash attention) without additional integration","Memory savings plateau after ~50% reduction — further savings require quantization or model parallelism","Debugging is harder because intermediate activations are not stored"],"requires":["Python 3.8+","PyTorch 1.13+","transformers 4.30+ with gradient_checkpointing support"],"input_types":["Model with gradient_checkpointing_enable() method"],"output_types":["Trained model with same weights as non-checkpointed training","Reduced peak memory usage (50-70% reduction)"],"categories":["automation-workflow","model-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-trl__cap_9","uri":"capability://code.generation.editing.custom.loss.functions.and.training.objectives","name":"custom-loss-functions-and-training-objectives","description":"Provides extensible framework for implementing custom loss functions and training objectives beyond standard SFT/RLHF/DPO. Includes base classes for custom trainers that override loss computation, allowing researchers to implement novel alignment methods (e.g., contrastive learning, multi-task learning, curriculum learning). Supports per-example loss weighting, task-specific loss scaling, and loss combination strategies.","intents":["Implement novel training objectives not covered by built-in trainers","Combine multiple loss functions (e.g., SFT + auxiliary task loss)","Apply per-example weighting or importance sampling to training data"],"best_for":["Researchers developing new alignment methods","Teams with domain-specific training objectives","Projects requiring multi-task or curriculum learning"],"limitations":["Custom loss implementation requires understanding of trl's trainer architecture","No built-in validation that custom losses are numerically stable","Debugging custom losses is harder due to distributed training complexity","Performance optimization (e.g., fused kernels) requires manual implementation","Limited documentation and examples for custom loss implementation"],"requires":["Python 3.8+","PyTorch 1.13+","transformers 4.30+","Understanding of trl's Trainer base classes"],"input_types":["Batch of tokenized examples","Optional: per-example weights or metadata"],"output_types":["Loss tensor (scalar or per-example)","Optional: auxiliary metrics for logging"],"categories":["code-generation-editing","model-training"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":28,"verified":false,"data_access_risk":"low","permissions":["Python 3.8+","PyTorch 1.13+","transformers library 4.30+","datasets library for data loading","peft library if using LoRA/QLoRA","PyTorch 1.13+ with CUDA support (CPU training impractical)","transformers 4.30+","trl's PPOTrainer class","Pre-trained reward model or ability to train one","Preference dataset with (prompt, chosen_response, rejected_response) tuples"],"failure_modes":["No built-in curriculum learning or hard example mining — requires manual data ordering","Gradient checkpointing overhead adds ~15-20% training time but reduces memory by 50%","No native support for multi-task learning or task-specific loss weighting","Tokenization happens at dataset load time, not dynamically — requires pre-processing for variable-length sequences","PPO training is sample-inefficient — requires 10-100x more tokens than SFT for convergence","Reward model overfitting common on small preference datasets (<10k pairs) without careful regularization","Online PPO requires generating completions during training, adding 3-5x computational overhead vs offline methods","KL penalty coefficient is manually tuned; no adaptive scheduling built-in","Requires careful hyperparameter tuning (learning rate, batch size, PPO epochs) — poor defaults lead to policy collapse","Data collators assume left-padding for causal LMs; right-padding requires custom implementation","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.5000000000000001,"match_graph":0.25,"freshness":0.5,"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-05-24T12:16:25.061Z","last_scraped_at":"2026-05-03T15:20:15.343Z","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-trl","compare_url":"https://unfragile.ai/compare?artifact=pypi-trl"}},"signature":"lp8a1aAW+Kkr05z+3sy9pyF+9PcGQA+Mj5WoCgMrrdxFPcEudXF6T3/T3dcONf75ukEGDEscj025JEYuT2XiAw==","signedAt":"2026-06-20T22:45:49.453Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-trl","artifact":"https://unfragile.ai/pypi-trl","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-trl","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"}}