{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-spacy","slug":"pypi-spacy","name":"spacy","type":"framework","url":"https://spacy.io","page_url":"https://unfragile.ai/pypi-spacy","categories":["frameworks-sdks"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-spacy__cap_0","uri":"capability://data.processing.analysis.cython.optimized.tokenization.with.language.specific.rule.engines","name":"cython-optimized tokenization with language-specific rule engines","description":"Breaks raw text into tokens using a Cython-compiled tokenizer (spacy/tokenizer.pyx) that applies language-specific exception rules and morphological boundaries. The tokenizer maintains a rule registry per language and uses finite-state matching to handle contractions, punctuation, and special cases (e.g., 'don't' → ['do', \"n't\"]). Tokens are stored as lightweight views into a Doc's underlying TokenC struct array, enabling zero-copy access to token attributes.","intents":["I need to split text into linguistically meaningful tokens respecting language-specific rules","I want fast tokenization that doesn't allocate memory for each token individually","I need to handle language-specific edge cases like German compound words or French contractions"],"best_for":["Production NLP pipelines requiring sub-millisecond tokenization","Multi-language applications processing 70+ languages","Memory-constrained environments (embedded systems, batch processing)"],"limitations":["Tokenizer rules are language-specific and must be pre-configured; custom rules require rebuilding the language model","No real-time rule updates — changes require model retraining or manual Language object reconfiguration","Cython compilation adds build complexity; pure Python fallback not available for all languages"],"requires":["Python 3.8+","spaCy 3.0+","Language model loaded via spacy.load() or Language() instantiation"],"input_types":["raw text (str)"],"output_types":["Doc object containing Token views with attributes (text, lemma, pos, tag, dep, ent_type)"],"categories":["data-processing-analysis","nlp-tokenization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_1","uri":"capability://data.processing.analysis.neural.dependency.parsing.with.transition.based.architecture","name":"neural dependency parsing with transition-based architecture","description":"Implements a transition-based dependency parser (spacy/pipeline/parser.pyx) that uses a neural network to predict syntactic head-dependent relationships. The parser maintains a shift-reduce state machine, processing tokens left-to-right and predicting transitions (shift, left-arc, right-arc) via a feed-forward or transformer-based neural model. Parsed dependencies are stored in the Doc's head and dep attributes, enabling downstream tasks like relation extraction and semantic role labeling.","intents":["I need to extract syntactic relationships (subject-verb-object) from sentences","I want to identify which words modify which other words in a sentence","I need dependency trees for downstream NLP tasks like information extraction or question answering"],"best_for":["Applications requiring syntactic analysis (relation extraction, semantic parsing, question answering)","Teams building domain-specific NLP pipelines with custom training data","Production systems where dependency accuracy is critical (legal document analysis, scientific text mining)"],"limitations":["Transition-based parsing is greedy and cannot recover from early mistakes; beam search not enabled by default","Accuracy degrades on out-of-domain text; requires fine-tuning on target domain for best results","Parsing speed is O(n) but with high constant factor; batch processing recommended for large corpora","No support for non-projective dependencies (crossing arcs) in default models"],"requires":["Python 3.8+","spaCy 3.0+ with a trained model (e.g., en_core_web_sm)","Neural model weights (downloaded via spacy download)"],"input_types":["Doc object with tokenization and POS tags"],"output_types":["Doc with head and dep attributes per token; dependency tree structure"],"categories":["data-processing-analysis","nlp-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_10","uri":"capability://data.processing.analysis.language.specific.tokenization.and.morphology.rules.with.extensible.data","name":"language-specific tokenization and morphology rules with extensible data","description":"Maintains language-specific data (tokenization rules, morphological features, stop words, lemmatization rules) in JSON files (website/meta/languages.json) that are loaded at runtime. Each language has a Language subclass (e.g., English, German, French) that defines language-specific tokenization exceptions and morphological rules. Users can add custom languages by creating a new Language subclass and registering it with @Language.factory. The system supports 70+ languages with unified API despite diverse linguistic properties.","intents":["I need to process text in languages other than English","I want to add custom tokenization rules for a new language","I need language-specific morphological analysis (e.g., German compound splitting)"],"best_for":["Multi-language NLP systems","Organizations processing diverse languages","Low-resource language communities building NLP tools"],"limitations":["Language support is limited to 70+ pre-configured languages; adding new languages requires code changes","Morphological rules are language-specific and must be manually defined; no automatic rule discovery","Tokenization rules are static; no dynamic rule updates without model retraining","Some languages have limited pre-trained models; accuracy varies significantly by language"],"requires":["Python 3.8+","spaCy 3.0+","Language model for target language (if using pre-trained models)"],"input_types":["Language code (e.g., 'en', 'de', 'fr'); optional custom Language subclass"],"output_types":["Language object with language-specific tokenizer and morphology rules"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_11","uri":"capability://automation.workflow.serialization.and.model.persistence.with.binary.format","name":"serialization and model persistence with binary format","description":"Serializes trained models to disk in a binary format that preserves all components, configuration, and weights. Models are saved as directories containing component files (e.g., model.pkl for neural weights), config.cfg, and metadata.json. Deserialization loads the model back into memory with all components ready for inference. The system supports incremental model updates (e.g., adding new entities to NER without retraining) via component-level serialization.","intents":["I need to save a trained model for later use","I want to deploy a model to production without retraining","I need to version control models and track changes over time"],"best_for":["Production systems requiring model persistence","Teams managing multiple model versions","Distributed systems where models are loaded on-demand"],"limitations":["Binary format is spaCy-specific; models cannot be easily ported to other frameworks","Model size can be large (100MB+); storage and transfer overhead","No built-in model compression; quantization requires external tools","Version compatibility issues if spaCy version changes; models may not load with newer spaCy versions"],"requires":["Python 3.8+","spaCy 3.0+","Disk space for model files (typically 50-500MB per model)"],"input_types":["Trained Language object with components"],"output_types":["Model directory with binary files, config.cfg, and metadata"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_12","uri":"capability://tool.use.integration.attribute.extension.system.for.custom.token.and.document.metadata","name":"attribute extension system for custom token and document metadata","description":"Allows users to attach custom attributes to Token, Doc, and Span objects via the extension system (Token.set_extension, Doc.set_extension, Span.set_extension). Extensions can be properties (computed on-the-fly), attributes (stored in memory), or methods. Extensions are registered globally and available on all instances of the target class. This enables adding domain-specific metadata (e.g., sentiment scores, custom NER labels) without modifying spaCy's core classes.","intents":["I need to attach custom metadata to tokens or documents","I want to add computed properties (e.g., sentiment score) to tokens without modifying spaCy","I need to store domain-specific annotations alongside linguistic annotations"],"best_for":["Custom NLP pipelines with domain-specific annotations","Research projects adding experimental features to spaCy","Teams building multi-stage NLP systems with custom metadata"],"limitations":["Extensions are global; no per-instance configuration","Property-based extensions are computed on every access; no caching","No type checking for extension values; users must ensure type consistency","Extensions are not serialized by default; custom serialization code required"],"requires":["Python 3.8+","spaCy 3.0+","Understanding of spaCy's extension API"],"input_types":["Token, Doc, or Span objects; extension definitions (property, attribute, or method)"],"output_types":["Extended Token/Doc/Span objects with custom attributes accessible via dot notation"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_13","uri":"capability://automation.workflow.batch.processing.with.doc.arrays.for.efficient.multi.document.analysis","name":"batch processing with doc arrays for efficient multi-document analysis","description":"Provides batch processing via the nlp.pipe() method that processes multiple documents efficiently by batching them through the pipeline. Internally, spaCy uses DocBin format to store multiple Doc objects in a single binary file, enabling efficient serialization and deserialization. The system supports streaming processing where documents are yielded as they're processed, enabling memory-efficient handling of large corpora.","intents":["I need to process large document collections efficiently","I want to stream documents through the pipeline without loading all into memory","I need to serialize/deserialize multiple documents efficiently"],"best_for":["Large-scale NLP projects processing millions of documents","Memory-constrained environments (embedded systems, cloud functions)","Batch processing pipelines (ETL, data preparation)"],"limitations":["Batch processing is sequential; no automatic parallelization across documents","DocBin format is spaCy-specific; not compatible with other frameworks","Memory usage still grows with batch size; very large batches can cause OOM errors","No built-in distributed processing; scaling requires external orchestration (e.g., Spark, Dask)"],"requires":["Python 3.8+","spaCy 3.0+","For large batches: sufficient RAM or streaming processing"],"input_types":["Iterable of text strings; optional DocBin files"],"output_types":["Iterator of Doc objects; optional DocBin files"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_2","uri":"capability://data.processing.analysis.named.entity.recognition.with.neural.sequence.labeling.and.rule.based.matching","name":"named entity recognition with neural sequence labeling and rule-based matching","description":"Combines two NER approaches: (1) neural sequence labeling via a BiLSTM or transformer model that predicts BIO tags (Begin, Inside, Outside) for each token, and (2) rule-based matching using PhraseMatcher and Matcher for pattern-based entity extraction. Neural predictions are stored in the Doc's ents attribute; rule-based matches can be added via EntityRuler pipeline component. Both approaches integrate into a unified Doc.ents interface, allowing hybrid NER systems.","intents":["I need to extract named entities (people, organizations, locations) from text","I want to combine neural NER with domain-specific rule-based patterns for better coverage","I need to add custom entity types not covered by pre-trained models"],"best_for":["Production systems requiring high-precision entity extraction (financial documents, medical records)","Domain-specific applications where rule-based patterns are more reliable than neural models","Teams building multi-stage NER pipelines (neural + rule-based + post-processing)"],"limitations":["Neural NER accuracy is limited by training data; out-of-domain entities often misclassified","Rule-based matching requires manual pattern engineering; scales poorly with entity type count","No built-in entity disambiguation; multiple entities with same text are not linked to canonical forms","Nested entities not supported; only flat entity spans are extracted"],"requires":["Python 3.8+","spaCy 3.0+ with trained model (e.g., en_core_web_sm)","For rule-based matching: Matcher or PhraseMatcher patterns defined in code"],"input_types":["Doc object with tokenization and POS tags"],"output_types":["Doc.ents (tuple of Span objects); each Span has label_ and text attributes"],"categories":["data-processing-analysis","nlp-ner"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_3","uri":"capability://data.processing.analysis.morphological.analysis.and.part.of.speech.tagging.with.statistical.models","name":"morphological analysis and part-of-speech tagging with statistical models","description":"Assigns part-of-speech (POS) tags and morphological features (tense, mood, case, gender, number) to each token using a statistical tagger trained on annotated corpora. The tagger uses a feed-forward neural network or transformer to predict tags based on word embeddings and context. Morphological features are stored in the Token.morph attribute as a MorphAnalysis object, enabling fine-grained linguistic analysis. The system supports 70+ languages with language-specific tagsets (e.g., Universal Dependencies).","intents":["I need to identify the grammatical role of each word (noun, verb, adjective, etc.)","I want to extract morphological features like verb tense or noun case for linguistic analysis","I need language-specific POS tags for downstream tasks like lemmatization or syntax analysis"],"best_for":["Linguistic research requiring detailed morphological annotation","Multi-language NLP systems processing diverse morphologically-rich languages","Applications requiring lemmatization (which depends on accurate POS tags)"],"limitations":["Accuracy varies by language; morphologically-rich languages (Finnish, Turkish) have lower accuracy than English","Tagset is language-specific; no unified tag schema across all 70+ languages","Morphological features are limited to those in training data; rare or unseen morphological combinations may be missed","No support for ambiguous morphology; one tag per token (no n-best alternatives)"],"requires":["Python 3.8+","spaCy 3.0+ with trained model","Language model must include POS tagger component"],"input_types":["Doc object with tokenization"],"output_types":["Token.pos_ (universal POS tag), Token.tag_ (language-specific tag), Token.morph (MorphAnalysis object with feature dict)"],"categories":["data-processing-analysis","nlp-tagging"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_4","uri":"capability://data.processing.analysis.entity.linking.with.knowledge.base.integration","name":"entity linking with knowledge base integration","description":"Links named entities to entries in a knowledge base (KB) using a learned entity linker that scores candidate entities based on context and entity similarity. The linker uses a neural model to compute entity embeddings and context embeddings, then ranks KB candidates by similarity. Linked entities are stored in the Doc.ents with kb_id attributes. The KB is a custom data structure (KnowledgeBase class) that stores entity vectors and aliases, enabling fast candidate retrieval.","intents":["I need to link entity mentions to a knowledge base (e.g., Wikipedia, Wikidata)","I want to disambiguate entities with multiple possible referents (e.g., 'Apple' → company vs fruit)","I need to enrich entities with structured knowledge (definitions, properties, relationships)"],"best_for":["Knowledge graph construction and entity resolution","Question answering systems requiring entity grounding","Information extraction pipelines needing semantic enrichment"],"limitations":["Requires pre-built knowledge base with entity embeddings; no automatic KB construction","Accuracy depends on KB coverage; entities not in KB cannot be linked","Training entity linker requires annotated data with gold KB IDs; limited training examples available","No built-in support for cross-lingual entity linking (e.g., linking English text to non-English KB)"],"requires":["Python 3.8+","spaCy 3.0+ with entity linker component","Pre-built KnowledgeBase with entity vectors (must be created separately or downloaded)","Named entities must be extracted first (via NER component)"],"input_types":["Doc object with extracted entities (Doc.ents)"],"output_types":["Entity with kb_id attribute; optional entity vector from KB"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_5","uri":"capability://automation.workflow.configurable.pipeline.composition.with.component.registration","name":"configurable pipeline composition with component registration","description":"Allows users to compose custom NLP pipelines by registering and chaining pipeline components (tokenizer, tagger, parser, NER, etc.) via a factory pattern. Each component is a callable that takes a Doc and returns a modified Doc. The Language class maintains a pipeline list and executes components sequentially, with each component's output feeding into the next. Components can be enabled/disabled, and the pipeline can be serialized/deserialized with configuration files (config.cfg in INI format).","intents":["I want to build a custom NLP pipeline with only the components I need","I need to add custom components (e.g., custom NER, sentiment analysis) to the standard pipeline","I want to enable/disable pipeline components at runtime without rebuilding the model"],"best_for":["Teams building domain-specific NLP systems with custom components","Production systems requiring flexible pipeline configuration without code changes","Researchers experimenting with different component combinations"],"limitations":["Pipeline execution is sequential; no built-in parallelization or batching across components","Component dependencies are implicit; no validation that downstream components receive expected Doc attributes","Configuration files (config.cfg) are INI-based and limited in expressiveness; complex logic requires Python code","Custom components must follow spaCy's Doc interface; integrating external libraries requires wrapper code"],"requires":["Python 3.8+","spaCy 3.0+","For custom components: understanding of spaCy's Doc, Token, Span interfaces"],"input_types":["Component callables (functions or classes with __call__ method)"],"output_types":["Language object with configured pipeline; serialized config.cfg file"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_6","uri":"capability://data.processing.analysis.rule.based.pattern.matching.with.matcher.and.phrasematcher","name":"rule-based pattern matching with matcher and phrasematcher","description":"Provides two pattern-matching engines: (1) Matcher for token-level patterns using attribute-based rules (e.g., 'find tokens where POS=VERB followed by NOUN'), and (2) PhraseMatcher for fast phrase matching using a trie-based algorithm. Both engines return Span objects with start/end positions and match IDs. Patterns are defined as lists of token dictionaries or phrase strings, compiled into finite-state automata for efficient matching. Matches can be used for entity extraction, relation extraction, or custom annotations.","intents":["I need to extract specific patterns (e.g., 'PERSON followed by VERB followed by OBJECT') from text","I want to find exact phrase matches efficiently without neural models","I need to identify domain-specific patterns (e.g., medical symptoms, financial terms) using rules"],"best_for":["Rule-based information extraction systems","Domain-specific NLP where patterns are more reliable than neural models","Low-resource languages where training data is scarce"],"limitations":["Patterns must be manually engineered; no automatic pattern discovery","Matcher patterns are limited to token attributes (POS, lemma, text, etc.); no semantic matching","PhraseMatcher requires exact phrase matches; no fuzzy matching or typo tolerance","Pattern complexity grows exponentially with rule count; maintainability issues at scale"],"requires":["Python 3.8+","spaCy 3.0+","Doc object with appropriate attributes (POS tags, lemmas, etc.) for pattern matching"],"input_types":["Doc object; pattern definitions (list of dicts for Matcher, list of strings for PhraseMatcher)"],"output_types":["List of Span objects with match IDs and matched text"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_7","uri":"capability://data.processing.analysis.text.classification.with.neural.models.and.custom.training","name":"text classification with neural models and custom training","description":"Provides a TextCategorizer pipeline component that uses a neural model (feed-forward or transformer-based) to classify documents or sentences into predefined categories. The model learns from annotated training data via backpropagation. Classification scores are stored in the Doc.cats attribute as a dictionary mapping category names to confidence scores (0-1). Supports multi-class and multi-label classification. Users can train custom classifiers on domain-specific data using the training API.","intents":["I need to classify documents into predefined categories (sentiment, topic, intent, etc.)","I want to train a custom text classifier on my own labeled data","I need multi-label classification where documents can belong to multiple categories"],"best_for":["Sentiment analysis, topic classification, intent detection","Teams with labeled training data for custom domains","Production systems requiring fast inference on pre-trained models"],"limitations":["Requires labeled training data; accuracy depends on data quality and quantity","No built-in active learning or data annotation tools; manual labeling required","Multi-label classification uses sigmoid activation; no explicit handling of label dependencies","No explanation/interpretability for predictions; black-box model"],"requires":["Python 3.8+","spaCy 3.0+ with TextCategorizer component","Labeled training data in spaCy's DocBin format"],"input_types":["Doc object; training data (DocBin with doc.cats annotations)"],"output_types":["Doc.cats (dict mapping category names to confidence scores 0-1)"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_8","uri":"capability://data.processing.analysis.word.vectors.and.similarity.computation.with.vector.storage","name":"word vectors and similarity computation with vector storage","description":"Stores pre-trained word vectors (embeddings) in a Vectors object that maps words to dense vectors (typically 300-dim). Vectors are loaded from external sources (e.g., Word2Vec, GloVe, fastText) and integrated into the Vocab. Token similarity is computed via cosine distance between vectors. The Doc and Span classes provide similarity() methods that average token vectors. Vectors are memory-mapped for efficient loading of large models.","intents":["I need to compute semantic similarity between words, sentences, or documents","I want to use pre-trained word embeddings (Word2Vec, GloVe) in my NLP pipeline","I need to find similar words or documents without training custom models"],"best_for":["Semantic search and document similarity tasks","Recommendation systems based on text similarity","Quick prototyping without training custom embeddings"],"limitations":["Pre-trained vectors may not cover domain-specific vocabulary; OOV (out-of-vocabulary) words get zero vectors","Similarity is based on word-level vectors; no contextual embeddings (unlike BERT)","Vector quality depends on training data; generic vectors may not capture domain semantics","Memory overhead for large vector models (300-dim × 1M words ≈ 1.2GB)"],"requires":["Python 3.8+","spaCy 3.0+","Pre-trained vectors (downloaded separately or provided in model)"],"input_types":["Doc or Span objects; optional external vector files (Word2Vec, GloVe format)"],"output_types":["Similarity scores (float 0-1); Token.vector (numpy array)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-spacy__cap_9","uri":"capability://automation.workflow.model.training.and.fine.tuning.with.configuration.driven.workflow","name":"model training and fine-tuning with configuration-driven workflow","description":"Provides a training API and CLI (spacy train) that uses configuration files (config.cfg) to define training hyperparameters, model architecture, and data paths. Training uses a callback-based system where components are updated via backpropagation. The system supports multi-task learning (training multiple components jointly, e.g., NER + POS tagging). Training progress is logged and models are evaluated on validation data. Trained models are serialized to disk with all components and configuration.","intents":["I need to train a custom NLP model on my labeled data","I want to fine-tune a pre-trained model on domain-specific data","I need to train multiple NLP tasks jointly (NER + POS tagging + parsing)"],"best_for":["Teams with labeled training data for custom domains","Production systems requiring domain-specific models","Research projects experimenting with model architectures"],"limitations":["Training requires significant labeled data; small datasets (<1000 examples) often overfit","Configuration files (config.cfg) are complex; hyperparameter tuning requires manual experimentation","No built-in hyperparameter optimization; users must manually adjust learning rate, batch size, etc.","Training is single-GPU; distributed training not supported"],"requires":["Python 3.8+","spaCy 3.0+","Labeled training data in spaCy's DocBin format","config.cfg file with training configuration"],"input_types":["Training data (DocBin with annotations); config.cfg file"],"output_types":["Trained model directory with components, config, and weights"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":26,"verified":false,"data_access_risk":"low","permissions":["Python 3.8+","spaCy 3.0+","Language model loaded via spacy.load() or Language() instantiation","spaCy 3.0+ with a trained model (e.g., en_core_web_sm)","Neural model weights (downloaded via spacy download)","Language model for target language (if using pre-trained models)","Disk space for model files (typically 50-500MB per model)","Understanding of spaCy's extension API","For large batches: sufficient RAM or streaming processing","spaCy 3.0+ with trained model (e.g., en_core_web_sm)"],"failure_modes":["Tokenizer rules are language-specific and must be pre-configured; custom rules require rebuilding the language model","No real-time rule updates — changes require model retraining or manual Language object reconfiguration","Cython compilation adds build complexity; pure Python fallback not available for all languages","Transition-based parsing is greedy and cannot recover from early mistakes; beam search not enabled by default","Accuracy degrades on out-of-domain text; requires fine-tuning on target domain for best results","Parsing speed is O(n) but with high constant factor; batch processing recommended for large corpora","No support for non-projective dependencies (crossing arcs) in default models","Language support is limited to 70+ pre-configured languages; adding new languages requires code changes","Morphological rules are language-specific and must be manually defined; no automatic rule discovery","Tokenization rules are static; no dynamic rule updates without model retraining","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.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-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:25.058Z","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-spacy","compare_url":"https://unfragile.ai/compare?artifact=pypi-spacy"}},"signature":"El+KZzBfBhc9A9GYOM+++Q/6DYFvonyUUILseI8As1+BYwNaFXoV5UejHzJFoEmkG66vA350zEuc9M31+cJqAQ==","signedAt":"2026-06-20T20:47:17.548Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-spacy","artifact":"https://unfragile.ai/pypi-spacy","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-spacy","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"}}