{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-flax","slug":"pypi-flax","name":"flax","type":"framework","url":"https://pypi.org/project/flax/","page_url":"https://unfragile.ai/pypi-flax","categories":["model-training"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-flax__cap_0","uri":"capability://code.generation.editing.jax.native.neural.network.module.composition.with.functional.state.management","name":"jax-native neural network module composition with functional state management","description":"Flax provides a module system built on JAX's functional programming paradigm, allowing developers to define neural networks as composable classes that separate model definition from parameter state. Modules use a two-phase initialization pattern: first defining architecture through class inheritance, then materializing parameters through explicit initialization calls that return immutable pytrees. This design enables automatic differentiation through JAX's jit, grad, and vmap transformations without stateful mutation.","intents":["Define reusable neural network components that compose cleanly without hidden state","Build models that work seamlessly with JAX's functional transformations (jit compilation, automatic differentiation, vectorization)","Create parameter-sharing architectures where state is explicitly managed as data structures"],"best_for":["researchers building custom architectures requiring fine-grained control over computation graphs","teams migrating from PyTorch/TensorFlow to JAX who need familiar OOP abstractions","developers optimizing for compiled performance and functional purity"],"limitations":["Requires understanding of JAX's functional paradigm and pytree structures — steeper learning curve than stateful frameworks","No automatic gradient checkpointing built-in; memory optimization requires manual implementation","Parameter initialization requires explicit shape inference or pre-specification, adding boilerplate vs eager frameworks"],"requires":["JAX 0.3.0+","Python 3.7+","NumPy for array operations"],"input_types":["Python class definitions inheriting from flax.linen.Module","JAX arrays (jnp.ndarray)"],"output_types":["Flax Module instances","FrozenDict parameter collections (pytrees)","JAX arrays"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_1","uri":"capability://code.generation.editing.automatic.parameter.initialization.with.shape.inference","name":"automatic parameter initialization with shape inference","description":"Flax implements lazy parameter initialization where module shapes are inferred at first forward pass rather than requiring explicit shape specification upfront. The framework traces through the model with dummy input arrays to discover parameter dimensions, then materializes the full parameter tree in a single initialization call. This eliminates manual shape calculation and supports dynamic architectures where layer sizes depend on input dimensions.","intents":["Initialize model parameters without manually specifying every layer's input/output dimensions","Support architectures where layer sizes are data-dependent or computed from input shapes","Reduce boilerplate when building models with variable-length sequences or dynamic batch sizes"],"best_for":["practitioners building sequence models (transformers, RNNs) with variable input shapes","researchers prototyping novel architectures with computed layer dimensions","teams wanting faster iteration without shape debugging"],"limitations":["Shape inference requires a forward pass with concrete input — cannot initialize without example data","Complex conditional architectures may require manual shape specification for branches not exercised during initialization","Initialization overhead adds latency on first forward pass (typically 100-500ms depending on model size)"],"requires":["JAX 0.3.0+","Sample input array matching expected shape signature","Random number generator key (jax.random.PRNGKey)"],"input_types":["JAX arrays (jnp.ndarray) as example inputs","JAX random key"],"output_types":["FrozenDict containing initialized parameters","Model state dictionary"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_10","uri":"capability://automation.workflow.model.checkpointing.and.gradient.accumulation.for.memory.efficient.training","name":"model checkpointing and gradient accumulation for memory-efficient training","description":"Flax provides utilities for gradient checkpointing (also called activation checkpointing) that trade computation for memory by recomputing activations during backpropagation instead of storing them. This enables training larger models on memory-constrained devices. The framework also supports gradient accumulation where gradients are computed over multiple batches before updating parameters, enabling larger effective batch sizes without proportional memory increases.","intents":["Train large models on memory-constrained devices (e.g., single GPU) by trading computation for memory","Accumulate gradients over multiple batches to simulate larger batch sizes without memory overhead","Optimize memory usage in deep models where activation storage dominates memory consumption"],"best_for":["practitioners training large models (transformers, vision models) on limited GPU/TPU memory","teams optimizing training efficiency through gradient accumulation for stable large-batch training","researchers experimenting with memory-computation tradeoffs in deep architectures"],"limitations":["Gradient checkpointing adds 20-30% training time overhead due to recomputation","Gradient accumulation requires manual gradient scaling and state management across accumulation steps","Checkpointing is incompatible with some JAX transformations (e.g., higher-order derivatives)"],"requires":["Flax 0.5.0+","JAX 0.3.0+","Understanding of backpropagation and gradient computation"],"input_types":["Model function (callable)","Parameters (pytree)","Input batch (JAX arrays)","Accumulation steps (int)"],"output_types":["Accumulated gradients (pytree)","Loss scalars (jnp.ndarray)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_11","uri":"capability://automation.workflow.mixed.precision.training.with.automatic.loss.scaling","name":"mixed precision training with automatic loss scaling","description":"Flax integrates with JAX's mixed precision capabilities to enable training with lower-precision computations (float16, bfloat16) while maintaining numerical stability through loss scaling. Loss scaling prevents gradient underflow by multiplying losses before backpropagation, then unscaling gradients before parameter updates. The framework provides utilities for automatic loss scaling that dynamically adjusts the scale factor based on gradient overflow detection.","intents":["Train models faster and with lower memory usage by using lower-precision arithmetic (float16, bfloat16)","Maintain numerical stability in mixed precision training through automatic loss scaling","Reduce training time and memory footprint for large models without sacrificing convergence"],"best_for":["practitioners training large models on GPUs/TPUs that support lower-precision arithmetic","teams optimizing training speed and memory usage for production models","researchers experimenting with precision-accuracy tradeoffs in deep learning"],"limitations":["Lower-precision arithmetic can lead to convergence issues in some models — requires careful tuning","Loss scaling adds complexity to training loops — requires understanding of numerical stability","Not all operations benefit equally from lower precision — memory savings depend on model architecture"],"requires":["Flax 0.5.0+","JAX 0.3.0+","Hardware support for lower-precision arithmetic (most modern GPUs/TPUs)"],"input_types":["Model parameters (pytree)","Loss function (callable)","Loss scale factor (float)","Batch data (JAX arrays)"],"output_types":["Scaled loss (jnp.ndarray)","Unscaled gradients (pytree)","Updated loss scale (float)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_12","uri":"capability://automation.workflow.distributed.training.orchestration.with.pmap.and.pjit","name":"distributed training orchestration with pmap and pjit","description":"Flax provides patterns and utilities for distributed training across multiple devices (GPUs, TPUs) using JAX's pmap (parallel map) and pjit (parallel jit) primitives. These enable data parallelism (splitting batches across devices) and model parallelism (splitting parameters across devices) without requiring manual communication code. The framework includes examples and utilities for common distributed patterns (data parallelism, pipeline parallelism) that work seamlessly with Flax's functional training loops.","intents":["Scale training across multiple GPUs/TPUs without manual communication code or synchronization logic","Implement data parallelism by automatically splitting batches across devices and synchronizing gradients","Experiment with model parallelism and pipeline parallelism for very large models"],"best_for":["teams training large models that require multiple devices for reasonable training time","researchers experimenting with distributed training strategies and communication patterns","practitioners optimizing training throughput on multi-GPU/TPU clusters"],"limitations":["pmap and pjit require understanding of JAX's distributed semantics and device placement","Communication overhead (gradient synchronization) can dominate for small models or high-latency networks","Debugging distributed training is complex — requires understanding of device placement and communication patterns"],"requires":["Flax 0.5.0+","JAX 0.3.0+","Multiple devices (GPUs or TPUs) or multi-machine setup","Understanding of distributed training concepts (data parallelism, gradient synchronization)"],"input_types":["Model parameters (pytree, replicated across devices)","Batch data (pytree, sharded across devices)","Training function (callable)"],"output_types":["Updated parameters (pytree, replicated across devices)","Aggregated metrics (scalars)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_2","uri":"capability://automation.workflow.composable.training.loop.abstraction.with.loss.metric.tracking","name":"composable training loop abstraction with loss/metric tracking","description":"Flax provides training utilities that wrap JAX's grad and jit transformations into reusable patterns, handling parameter updates, loss computation, and metric aggregation without requiring manual gradient tape management. The framework uses a TrainState abstraction that bundles parameters, optimizer state, and step count into a single pytree, enabling clean functional updates through optimizer.apply_gradients() calls. Metrics are computed as pure functions and aggregated across batches through pytree operations.","intents":["Build training loops that compose cleanly with JAX transformations without manual gradient management","Track multiple metrics (loss, accuracy, etc.) across batches and epochs with minimal boilerplate","Swap optimizers and loss functions without rewriting training logic"],"best_for":["teams building production training pipelines that need reproducibility and composability","researchers experimenting with custom optimizers and loss functions","practitioners wanting cleaner training code than raw JAX grad/jit"],"limitations":["TrainState abstraction adds indirection — debugging requires understanding pytree structure and optimizer state layout","Metric computation must be implemented as pure functions — stateful metric classes (like PyTorch's) not supported","No built-in distributed training utilities — requires manual pmap/pjit orchestration for multi-GPU/TPU"],"requires":["Flax 0.4.0+","JAX optimizer (optax library recommended)","Loss function as JAX-compatible callable"],"input_types":["Model parameters (FrozenDict pytree)","Optimizer state (pytree)","Batch data (JAX arrays)","Loss function (callable)"],"output_types":["Updated TrainState","Loss scalars (jnp.ndarray)","Metric dictionaries"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_3","uri":"capability://code.generation.editing.attention.and.transformer.layer.implementations.with.numerical.stability","name":"attention and transformer layer implementations with numerical stability","description":"Flax provides production-ready implementations of multi-head attention, transformer blocks, and positional encodings optimized for numerical stability and JAX compatibility. Attention uses log-space softmax computation to prevent overflow, supports arbitrary query/key/value projections, and integrates with JAX's vmap for efficient batch processing. Transformer blocks compose attention, feed-forward networks, and layer normalization with configurable residual connections and dropout patterns.","intents":["Build transformer models without implementing attention from scratch or debugging numerical instabilities","Compose attention layers with custom projection schemes (multi-query, grouped-query attention variants)","Leverage pre-optimized implementations that work efficiently with JAX's compilation and vectorization"],"best_for":["NLP researchers and practitioners building language models, translation systems, or sequence classification","teams implementing attention variants (sparse attention, linear attention) on top of stable base implementations","developers optimizing transformer inference on accelerators (TPU, GPU) via JAX compilation"],"limitations":["Attention implementations assume dense attention patterns — sparse attention variants require custom implementation","No built-in support for efficient KV-cache management during inference — requires manual state threading","Positional encoding options are limited (rotary, absolute) — relative position biases require custom implementation"],"requires":["Flax 0.5.0+","JAX 0.3.0+","Understanding of transformer architecture and attention mechanisms"],"input_types":["Query, key, value JAX arrays","Attention mask arrays (optional)","Dropout rate (float)"],"output_types":["Attention output arrays (jnp.ndarray)","Attention weights (optional, for visualization)"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_4","uri":"capability://automation.workflow.serialization.and.checkpoint.management.with.pytree.aware.persistence","name":"serialization and checkpoint management with pytree-aware persistence","description":"Flax provides checkpoint utilities that serialize model parameters and optimizer state as pytrees to disk, supporting multiple formats (pickle, msgpack, SafeTensors) with automatic compression and versioning. The framework includes utilities for partial checkpointing (saving only parameters, only optimizer state, or both), resuming training from checkpoints with state reconstruction, and loading pre-trained weights into models with different architectures through flexible key matching.","intents":["Save and restore model parameters and training state without manual serialization logic","Resume interrupted training runs with full optimizer state reconstruction","Load pre-trained weights into models with slightly different architectures (e.g., different batch sizes, sequence lengths)"],"best_for":["teams training large models that require checkpoint recovery and resumption","practitioners fine-tuning pre-trained models with architecture modifications","researchers sharing trained weights across different codebase versions"],"limitations":["Pytree structure must match between save and load — architecture changes require manual key remapping","No built-in distributed checkpoint sharding — large models require custom pmap/pjit integration","Checkpoint versioning is manual — no automatic migration between Flax versions"],"requires":["Flax 0.4.0+","Disk space for checkpoint files (typically 4x model parameter size with optimizer state)","Optional: msgpack or SafeTensors libraries for format support"],"input_types":["Model parameters (FrozenDict pytree)","Optimizer state (pytree)","Checkpoint path (string)"],"output_types":["Checkpoint files (pickle/msgpack/safetensors format)","Restored parameters and optimizer state (pytrees)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_5","uri":"capability://code.generation.editing.batch.normalization.and.layer.normalization.with.training.inference.mode.switching","name":"batch normalization and layer normalization with training/inference mode switching","description":"Flax implements batch and layer normalization layers that correctly handle training vs. inference modes through explicit state management. During training, batch statistics are computed and accumulated into a running statistics buffer; during inference, accumulated statistics are used. The framework uses a mutable state pattern where normalization layers return both outputs and updated statistics, which are merged back into the model state after each forward pass.","intents":["Apply normalization layers that behave correctly during training (using batch statistics) and inference (using accumulated statistics)","Track running statistics across batches without manual state threading","Compose normalization with other stateful operations (dropout, batch effects) in a functional framework"],"best_for":["practitioners building vision models (CNNs) and other architectures requiring batch normalization","teams needing correct train/eval behavior without manual mode switching bugs","researchers experimenting with normalization variants (group norm, instance norm)"],"limitations":["Mutable state pattern adds complexity — requires understanding of Flax's variable collection system","Batch statistics computation requires sufficient batch size — small batches lead to noisy estimates","Running statistics accumulation requires manual state updates after each batch — no automatic accumulation"],"requires":["Flax 0.4.0+","JAX 0.3.0+","Understanding of batch normalization semantics and train/eval modes"],"input_types":["Input arrays (jnp.ndarray)","Training flag (bool)","Momentum for running statistics (float)"],"output_types":["Normalized output arrays (jnp.ndarray)","Updated running statistics (pytree)"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_6","uri":"capability://code.generation.editing.dropout.and.stochastic.regularization.with.rng.key.threading","name":"dropout and stochastic regularization with rng key threading","description":"Flax implements dropout and other stochastic layers using JAX's functional random number generation, where RNG keys are threaded through the model as explicit parameters rather than using global random state. During training, dropout masks are generated from the RNG key; during inference, dropout is disabled. The framework provides utilities for splitting RNG keys across batches and layers, ensuring reproducibility and correct behavior with jit compilation.","intents":["Apply dropout and other stochastic regularization that works correctly with JAX's functional paradigm","Ensure reproducible training by explicitly managing random seeds through RNG key threading","Disable stochastic operations during inference without mode switching bugs"],"best_for":["practitioners building models with dropout and other stochastic regularization","teams requiring reproducible training and inference behavior","researchers experimenting with custom stochastic layers (stochastic depth, mixup, etc.)"],"limitations":["RNG key threading adds boilerplate — requires passing keys through every forward pass","Key splitting overhead adds latency (typically <1ms per split) — noticeable in high-frequency operations","Debugging RNG-dependent behavior requires understanding JAX's random API and key management"],"requires":["Flax 0.4.0+","JAX 0.3.0+","JAX random key (jax.random.PRNGKey)"],"input_types":["Input arrays (jnp.ndarray)","Dropout rate (float, 0-1)","RNG key (jax.random.PRNGKey)","Training flag (bool)"],"output_types":["Output arrays with dropout applied (jnp.ndarray)","Updated RNG key (for next layer)"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_7","uri":"capability://code.generation.editing.embedding.layers.with.weight.sharing.and.vocabulary.management","name":"embedding layers with weight sharing and vocabulary management","description":"Flax provides embedding layers that map discrete token indices to dense vectors, with support for weight sharing between input embeddings and output projection layers (useful in language models). Embeddings are stored as parameter matrices and support arbitrary vocabulary sizes and embedding dimensions. The framework includes utilities for initializing embeddings with specific distributions and for sharing weights across multiple embedding instances.","intents":["Convert discrete tokens to dense vectors for sequence models without manual matrix indexing","Share embedding weights between input and output layers to reduce parameters in language models","Initialize embeddings with specific distributions (uniform, normal) for training stability"],"best_for":["NLP practitioners building language models, machine translation, or sequence classification systems","teams optimizing model size through weight sharing between input and output embeddings","researchers experimenting with embedding initialization schemes"],"limitations":["Embedding lookup is a simple matrix indexing operation — no support for subword tokenization or dynamic vocabularies","Weight sharing requires manual parameter passing between embedding and output layers — not automatic","Large vocabularies lead to large embedding matrices — memory usage scales with vocab_size × embedding_dim"],"requires":["Flax 0.4.0+","JAX 0.3.0+","Token indices as integer arrays (jnp.ndarray)"],"input_types":["Token indices (jnp.ndarray, dtype=int32)","Vocabulary size (int)","Embedding dimension (int)"],"output_types":["Embedded vectors (jnp.ndarray, shape=[batch, seq_len, embedding_dim])","Embedding parameters (pytree)"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_8","uri":"capability://code.generation.editing.recurrent.neural.network.rnn.lstm.gru.cells.with.stateful.sequence.processing","name":"recurrent neural network (rnn/lstm/gru) cells with stateful sequence processing","description":"Flax implements RNN, LSTM, and GRU cells as stateless modules that process one timestep at a time, returning both output and updated hidden state. Sequences are processed by manually iterating over timesteps and threading the hidden state through each step, or using scan operations for efficient batched processing. This design maintains functional purity while supporting arbitrary sequence lengths and enables efficient compilation through JAX's scan primitive.","intents":["Build sequence models using RNNs, LSTMs, or GRUs without implementing cell logic from scratch","Process variable-length sequences efficiently using JAX's scan operation for automatic loop unrolling","Compose RNN cells with other layers (embeddings, attention) in a functional framework"],"best_for":["practitioners building sequence models for time series, speech, or sequential decision-making","teams needing efficient RNN inference on accelerators through JAX compilation","researchers experimenting with RNN variants (bidirectional, multi-layer) without reimplementing cells"],"limitations":["Manual sequence iteration or scan setup adds boilerplate compared to PyTorch's RNN wrappers","No built-in bidirectional RNN — requires manual forward/backward pass composition","Sequence processing through scan requires understanding of JAX's functional loop semantics"],"requires":["Flax 0.4.0+","JAX 0.3.0+","Understanding of RNN/LSTM/GRU semantics and hidden state management"],"input_types":["Input arrays (jnp.ndarray, shape=[batch, seq_len, input_dim])","Initial hidden state (jnp.ndarray)","Optional: cell state for LSTM (jnp.ndarray)"],"output_types":["Output sequences (jnp.ndarray, shape=[batch, seq_len, hidden_dim])","Final hidden state (jnp.ndarray)","Optional: final cell state for LSTM"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-flax__cap_9","uri":"capability://code.generation.editing.convolutional.layer.implementations.with.flexible.padding.and.stride.control","name":"convolutional layer implementations with flexible padding and stride control","description":"Flax provides convolutional layers (Conv1D, Conv2D, Conv3D) that apply learned filters to input arrays with configurable kernel sizes, strides, padding modes, and dilation. Convolutions are implemented as efficient JAX operations that leverage underlying BLAS libraries and support arbitrary input/output channel dimensions. The framework includes utilities for grouped convolutions and depthwise separable convolutions for parameter efficiency.","intents":["Build vision models (CNNs) and other architectures using convolutions without manual filter implementation","Apply convolutions with custom padding, stride, and dilation for specialized architectures (dilated convolutions, atrous convolutions)","Compose convolutions with normalization and activation layers for standard CNN blocks"],"best_for":["computer vision practitioners building image classification, object detection, or segmentation models","teams optimizing model size through grouped and depthwise separable convolutions","researchers experimenting with dilated convolutions and other specialized architectures"],"limitations":["Convolution operations are compute-intensive — inference latency depends on kernel size and input resolution","No built-in support for dynamic kernel sizes or learnable padding — requires custom implementation","Grouped convolutions require careful channel dimension management to avoid errors"],"requires":["Flax 0.4.0+","JAX 0.3.0+","Input arrays with correct spatial dimensions (e.g., [batch, height, width, channels] for Conv2D)"],"input_types":["Input arrays (jnp.ndarray)","Kernel size (int or tuple)","Number of output channels (int)","Stride (int or tuple)","Padding mode (string: 'SAME', 'VALID', or tuple)"],"output_types":["Convolved output arrays (jnp.ndarray)","Convolution parameters (pytree)"],"categories":["code-generation-editing","neural-network-frameworks"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":25,"verified":false,"data_access_risk":"high","permissions":["JAX 0.3.0+","Python 3.7+","NumPy for array operations","Sample input array matching expected shape signature","Random number generator key (jax.random.PRNGKey)","Flax 0.5.0+","Understanding of backpropagation and gradient computation","Hardware support for lower-precision arithmetic (most modern GPUs/TPUs)","Multiple devices (GPUs or TPUs) or multi-machine setup","Understanding of distributed training concepts (data parallelism, gradient synchronization)"],"failure_modes":["Requires understanding of JAX's functional paradigm and pytree structures — steeper learning curve than stateful frameworks","No automatic gradient checkpointing built-in; memory optimization requires manual implementation","Parameter initialization requires explicit shape inference or pre-specification, adding boilerplate vs eager frameworks","Shape inference requires a forward pass with concrete input — cannot initialize without example data","Complex conditional architectures may require manual shape specification for branches not exercised during initialization","Initialization overhead adds latency on first forward pass (typically 100-500ms depending on model size)","Gradient checkpointing adds 20-30% training time overhead due to recomputation","Gradient accumulation requires manual gradient scaling and state management across accumulation steps","Checkpointing is incompatible with some JAX transformations (e.g., higher-order derivatives)","Lower-precision arithmetic can lead to convergence issues in some models — requires careful tuning","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.3,"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.060Z","last_scraped_at":"2026-05-03T15:20:13.888Z","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-flax","compare_url":"https://unfragile.ai/compare?artifact=pypi-flax"}},"signature":"PCmqNCIDjw6Gesg2j2zoxUAHkmeNQeOfkOLF09/NuDymwfiRC4QLceo4kvJthElWunaWPAXMCHjx1OA2dXxgBA==","signedAt":"2026-06-21T11:35:40.806Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-flax","artifact":"https://unfragile.ai/pypi-flax","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-flax","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"}}