rapid-textrank 0.0.1__cp314-cp314-macosx_10_12_x86_64.whl

rapid_textrank/__init__.py

@@ -0,0 +1,53 @@
+"""
+rapid_textrank - High-performance TextRank implementation
+
+A fast TextRank implementation in Rust with Python bindings,
+providing keyword extraction and text summarization.
+"""
+
+from rapid_textrank._rust import (
+    __version__,
+    Phrase,
+    TextRankResult,
+    TextRankConfig,
+    BaseTextRank,
+    PositionRank,
+    BiasedTextRank,
+    extract_from_json,
+    extract_batch_from_json,
+)
+
+__all__ = [
+    "__version__",
+    "Phrase",
+    "TextRankResult",
+    "TextRankConfig",
+    "BaseTextRank",
+    "PositionRank",
+    "BiasedTextRank",
+    "extract_from_json",
+    "extract_batch_from_json",
+]
+
+
+def extract_keywords(text: str, top_n: int = 10, language: str = "en") -> list:
+    """
+    Extract keywords from text using TextRank.
+
+    Args:
+        text: The input text to extract keywords from
+        top_n: Number of top keywords to return
+        language: Language code for stopword filtering
+
+    Returns:
+        List of Phrase objects with text, score, and rank
+
+    Example:
+        >>> from rapid_textrank import extract_keywords
+        >>> phrases = extract_keywords("Machine learning is a subset of AI.")
+        >>> for phrase in phrases:
+        ...     print(f"{phrase.text}: {phrase.score:.4f}")
+    """
+    extractor = BaseTextRank(top_n=top_n, language=language)
+    result = extractor.extract_keywords(text)
+    return list(result.phrases)

rapid_textrank/spacy_component.py

@@ -0,0 +1,239 @@
+"""
+spaCy pipeline component for rapid_textrank.
+
+This module provides a spaCy pipeline component that uses rapid_textrank
+for keyword extraction. It can be used as a drop-in replacement for
+pytextrank with significantly better performance.
+
+Example:
+    >>> import spacy
+    >>> from rapid_textrank.spacy_component import RustTextRank
+    >>>
+    >>> nlp = spacy.load("en_core_web_sm")
+    >>> nlp.add_pipe("rapid_textrank")
+    >>>
+    >>> doc = nlp("Machine learning is a subset of artificial intelligence.")
+    >>> for phrase in doc._.phrases[:5]:
+    ...     print(f"{phrase.text}: {phrase.score:.4f}")
+"""
+
+from typing import List, Optional, Dict, Any
+import json
+
+try:
+    from spacy.tokens import Doc
+    from spacy.language import Language
+
+    SPACY_AVAILABLE = True
+except ImportError:
+    SPACY_AVAILABLE = False
+    Doc = None
+    Language = None
+
+from rapid_textrank._rust import extract_from_json
+
+
+class Phrase:
+    """
+    A keyphrase extracted by RustTextRank.
+
+    Compatible with pytextrank's Phrase interface.
+    """
+
+    def __init__(self, text: str, lemma: str, score: float, count: int, rank: int):
+        self.text = text
+        self.lemma = lemma
+        self.score = score
+        self.count = count
+        self.rank = rank
+        # For pytextrank compatibility
+        self.chunks = []
+
+    def __repr__(self) -> str:
+        return f"Phrase(text='{self.text}', score={self.score:.4f}, rank={self.rank})"
+
+    def __str__(self) -> str:
+        return self.text
+
+
+class RustTextRankResult:
+    """Result container for TextRank extraction."""
+
+    def __init__(self, phrases: List[Phrase], converged: bool, iterations: int):
+        self.phrases = phrases
+        self.converged = converged
+        self.iterations = iterations
+
+    def __len__(self) -> int:
+        return len(self.phrases)
+
+    def __iter__(self):
+        return iter(self.phrases)
+
+
+if SPACY_AVAILABLE:
+
+    @Language.factory(
+        "rapid_textrank",
+        default_config={
+            "damping": 0.85,
+            "max_iterations": 100,
+            "convergence_threshold": 1e-6,
+            "window_size": 4,
+            "top_n": 10,
+            "min_phrase_length": 1,
+            "max_phrase_length": 4,
+            "score_aggregation": "sum",
+        },
+    )
+    def create_rapid_textrank(
+        nlp: Language,
+        name: str,
+        damping: float,
+        max_iterations: int,
+        convergence_threshold: float,
+        window_size: int,
+        top_n: int,
+        min_phrase_length: int,
+        max_phrase_length: int,
+        score_aggregation: str,
+    ):
+        """Create a RustTextRank pipeline component."""
+        return RustTextRank(
+            nlp=nlp,
+            name=name,
+            damping=damping,
+            max_iterations=max_iterations,
+            convergence_threshold=convergence_threshold,
+            window_size=window_size,
+            top_n=top_n,
+            min_phrase_length=min_phrase_length,
+            max_phrase_length=max_phrase_length,
+            score_aggregation=score_aggregation,
+        )
+
+    class RustTextRank:
+        """
+        spaCy pipeline component for TextRank keyword extraction.
+
+        This component uses the Rust implementation for fast extraction
+        while integrating seamlessly with spaCy's NLP pipeline.
+
+        Example:
+            >>> import spacy
+            >>> nlp = spacy.load("en_core_web_sm")
+            >>> nlp.add_pipe("rapid_textrank")
+            >>> doc = nlp("Machine learning is transforming industries.")
+            >>> for phrase in doc._.phrases:
+            ...     print(phrase.text, phrase.score)
+        """
+
+        def __init__(
+            self,
+            nlp: Language,
+            name: str = "rapid_textrank",
+            damping: float = 0.85,
+            max_iterations: int = 100,
+            convergence_threshold: float = 1e-6,
+            window_size: int = 4,
+            top_n: int = 10,
+            min_phrase_length: int = 1,
+            max_phrase_length: int = 4,
+            score_aggregation: str = "sum",
+        ):
+            self.nlp = nlp
+            self.name = name
+            self.config = {
+                "damping": damping,
+                "max_iterations": max_iterations,
+                "convergence_threshold": convergence_threshold,
+                "window_size": window_size,
+                "top_n": top_n,
+                "min_phrase_length": min_phrase_length,
+                "max_phrase_length": max_phrase_length,
+                "score_aggregation": score_aggregation,
+            }
+
+            # Register custom extensions
+            if not Doc.has_extension("phrases"):
+                Doc.set_extension("phrases", default=[])
+            if not Doc.has_extension("textrank_result"):
+                Doc.set_extension("textrank_result", default=None)
+
+        def __call__(self, doc: Doc) -> Doc:
+            """Process a spaCy Doc and extract keyphrases."""
+            # Convert spaCy tokens to JSON format
+            tokens = []
+            for sent_idx, sent in enumerate(doc.sents):
+                for token in sent:
+                    tokens.append(
+                        {
+                            "text": token.text,
+                            "lemma": token.lemma_,
+                            "pos": token.pos_,
+                            "start": token.idx,
+                            "end": token.idx + len(token.text),
+                            "sentence_idx": sent_idx,
+                            "token_idx": token.i,
+                            "is_stopword": token.is_stop,
+                        }
+                    )
+
+            # Create JSON input
+            json_input = json.dumps({"tokens": tokens, "config": self.config})
+
+            # Extract keyphrases using Rust
+            json_output = extract_from_json(json_input)
+            result = json.loads(json_output)
+
+            # Convert to Phrase objects
+            phrases = [
+                Phrase(
+                    text=p["text"],
+                    lemma=p["lemma"],
+                    score=p["score"],
+                    count=p["count"],
+                    rank=p["rank"],
+                )
+                for p in result["phrases"]
+            ]
+
+            # Store results
+            doc._.phrases = phrases
+            doc._.textrank_result = RustTextRankResult(
+                phrases=phrases,
+                converged=result["converged"],
+                iterations=result["iterations"],
+            )
+
+            return doc
+
+        def to_disk(self, path, **kwargs):
+            """Save component configuration to disk."""
+            import json
+            from pathlib import Path
+
+            config_path = Path(path) / "config.json"
+            with open(config_path, "w") as f:
+                json.dump(self.config, f)
+
+        def from_disk(self, path, **kwargs):
+            """Load component configuration from disk."""
+            import json
+            from pathlib import Path
+
+            config_path = Path(path) / "config.json"
+            with open(config_path, "r") as f:
+                self.config = json.load(f)
+            return self
+
+else:
+    # Fallback when spaCy is not available
+    class RustTextRank:
+        """Placeholder when spaCy is not installed."""
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "spaCy is required for the RustTextRank pipeline component. "
+                "Install it with: pip install spacy"
+            )

rapid_textrank-0.0.1.dist-info/METADATA

@@ -0,0 +1,587 @@
+Metadata-Version: 2.4
+Name: rapid_textrank
+Version: 0.0.1
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-benchmark ; extra == 'dev'
+Requires-Dist: spacy>=3.0 ; extra == 'dev'
+Requires-Dist: spacy>=3.0 ; extra == 'spacy'
+Provides-Extra: dev
+Provides-Extra: spacy
+License-File: LICENSE
+Summary: High-performance TextRank implementation with Python bindings
+Keywords: nlp,textrank,keyword-extraction,summarization,pagerank
+Author: TextRanker Contributors
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Project-URL: Homepage, https://github.com/xang1234/rapid-textrank
+Project-URL: Issues, https://github.com/xang1234/rapid-textrank/issues
+Project-URL: Repository, https://github.com/xang1234/rapid-textrank
+
+# rapid_textrank
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Rust](https://img.shields.io/badge/rust-2021-orange.svg)](https://www.rust-lang.org/)
+
+**High-performance TextRank implementation in Rust with Python bindings.**
+
+Extract keywords and key phrases from text 10-100x faster than pure Python implementations, with support for multiple algorithm variants and 18 languages.
+
+## Features
+
+- **Fast**: 10-100x faster than pure Python implementations
+- **Multiple algorithms**: TextRank, PositionRank, and BiasedTextRank variants
+- **Unicode-aware**: Proper handling of CJK, emoji, and other scripts
+- **Multi-language**: Stopword support for 18 languages
+- **Dual API**: Native Python classes + JSON interface for batch processing
+- **Zero Python overhead**: Computation happens entirely in Rust (no GIL)
+
+## Quick Start
+
+```bash
+pip install rapid_textrank
+```
+
+```python
+from rapid_textrank import extract_keywords
+
+text = """
+Machine learning is a subset of artificial intelligence that enables
+systems to learn and improve from experience. Deep learning, a type of
+machine learning, uses neural networks with many layers.
+"""
+
+keywords = extract_keywords(text, top_n=5, language="en")
+for phrase in keywords:
+    print(f"{phrase.text}: {phrase.score:.4f}")
+```
+
+Output:
+```
+machine learning: 0.2341
+deep learning: 0.1872
+artificial intelligence: 0.1654
+neural networks: 0.1432
+systems: 0.0891
+```
+
+## How TextRank Works
+
+TextRank is a graph-based ranking algorithm for keyword extraction, inspired by Google's PageRank.
+
+### The Algorithm
+
+1. **Build a co-occurrence graph**: Words become nodes. An edge connects two words if they appear within a sliding window (default: 4 words).
+
+2. **Run PageRank**: The algorithm iteratively distributes "importance" through the graph. Words connected to many important words become important themselves.
+
+3. **Extract phrases**: Adjacent high-scoring words are combined into key phrases. Scores are aggregated (sum, mean, or max).
+
+```
+Text: "Machine learning enables systems to learn from data"
+
+Co-occurrence graph (window=2):
+    machine ←→ learning ←→ enables ←→ systems ←→ learn ←→ data
+                              ↓
+                            PageRank
+                              ↓
+    Scores: machine(0.23) learning(0.31) enables(0.12) ...
+                              ↓
+                        Phrase extraction
+                              ↓
+    "machine learning" (0.54), "systems" (0.18), ...
+```
+
+### Further Reading
+
+- [TextRank: Bringing Order into Texts](https://aclanthology.org/W04-3252/) (Mihalcea & Tarau, 2004)
+- [PositionRank: An Unsupervised Approach to Keyphrase Extraction](https://aclanthology.org/P17-1102/) (Florescu & Caragea, 2017)
+- [BiasedTextRank: Unsupervised Graph-Based Content Extraction](https://aclanthology.org/2020.coling-main.144/) (Kazemi et al., 2020)
+
+## Algorithm Variants
+
+| Variant | Best For | Description |
+|---------|----------|-------------|
+| `BaseTextRank` | General text | Standard TextRank implementation |
+| `PositionRank` | Academic papers, news | Favors words appearing early in the document |
+| `BiasedTextRank` | Topic-focused extraction | Biases results toward specified focus terms |
+
+### PositionRank
+
+Weights words by their position—earlier appearances score higher. Useful for documents where key information appears in titles, abstracts, or opening paragraphs.
+
+```python
+from rapid_textrank import PositionRank
+
+extractor = PositionRank(top_n=10)
+result = extractor.extract_keywords("""
+Quantum Computing Advances in 2024
+
+Researchers have made significant breakthroughs in quantum error correction.
+The quantum computing field continues to evolve rapidly...
+""")
+
+# "quantum computing" and "quantum" will rank higher due to early position
+```
+
+### BiasedTextRank
+
+Steers extraction toward specific topics using focus terms. The `bias_weight` parameter controls how strongly results favor the focus terms.
+
+```python
+from rapid_textrank import BiasedTextRank
+
+extractor = BiasedTextRank(
+    focus_terms=["security", "privacy"],
+    bias_weight=5.0,  # Higher = stronger bias
+    top_n=10
+)
+
+result = extractor.extract_keywords("""
+Modern web applications must balance user experience with security.
+Privacy regulations require careful data handling. Performance
+optimizations should not compromise security measures.
+""")
+
+# Results will favor security/privacy-related phrases
+```
+
+## API Reference
+
+### Convenience Function
+
+The simplest way to extract keywords:
+
+```python
+from rapid_textrank import extract_keywords
+
+phrases = extract_keywords(
+    text,           # Input text
+    top_n=10,       # Number of keywords to return
+    language="en"   # Language for stopword filtering
+)
+```
+
+### Class-Based API
+
+For more control, use the extractor classes:
+
+```python
+from rapid_textrank import BaseTextRank, PositionRank, BiasedTextRank
+
+# Standard TextRank
+extractor = BaseTextRank(top_n=10, language="en")
+result = extractor.extract_keywords(text)
+
+# Position-weighted
+extractor = PositionRank(top_n=10, language="en")
+result = extractor.extract_keywords(text)
+
+# Topic-biased
+extractor = BiasedTextRank(
+    focus_terms=["machine", "learning"],
+    bias_weight=5.0,
+    top_n=10,
+    language="en"
+)
+result = extractor.extract_keywords(text)
+
+# You can also pass focus_terms per-call
+result = extractor.extract_keywords(text, focus_terms=["neural", "network"])
+```
+
+### Configuration
+
+Fine-tune the algorithm with `TextRankConfig`:
+
+```python
+from rapid_textrank import TextRankConfig, BaseTextRank
+
+config = TextRankConfig(
+    damping=0.85,              # PageRank damping factor (0-1)
+    max_iterations=100,        # Maximum PageRank iterations
+    convergence_threshold=1e-6,# Convergence threshold
+    window_size=4,             # Co-occurrence window size
+    top_n=10,                  # Number of results
+    min_phrase_length=1,       # Minimum words in a phrase
+    max_phrase_length=4,       # Maximum words in a phrase
+    score_aggregation="sum",   # How to combine word scores: "sum", "mean", "max", "rms"
+    language="en"              # Language for stopwords
+)
+
+extractor = BaseTextRank(config=config)
+```
+
+### Result Objects
+
+```python
+result = extractor.extract_keywords(text)
+
+# TextRankResult attributes
+result.phrases      # List of Phrase objects
+result.converged    # Whether PageRank converged
+result.iterations   # Number of iterations run
+
+# Phrase attributes
+for phrase in result.phrases:
+    phrase.text     # The phrase text (e.g., "machine learning")
+    phrase.lemma    # Lemmatized form
+    phrase.score    # TextRank score
+    phrase.count    # Occurrences in text
+    phrase.rank     # 1-indexed rank
+
+# Convenience method
+tuples = result.as_tuples()  # [(text, score), ...]
+```
+
+### JSON Interface
+
+For processing large documents or integrating with spaCy, use the JSON interface. This accepts pre-tokenized data to avoid re-tokenizing in Rust.
+
+```python
+from rapid_textrank import extract_from_json, extract_batch_from_json
+import json
+
+# Single document
+doc = {
+    "tokens": [
+        {
+            "text": "Machine",
+            "lemma": "machine",
+            "pos": "NOUN",
+            "start": 0,
+            "end": 7,
+            "sentence_idx": 0,
+            "token_idx": 0,
+            "is_stopword": False
+        },
+        # ... more tokens
+    ],
+    "config": {"top_n": 10}
+}
+
+result_json = extract_from_json(json.dumps(doc))
+result = json.loads(result_json)
+
+# Batch processing (parallel in Rust)
+docs = [doc1, doc2, doc3]
+results_json = extract_batch_from_json(json.dumps(docs))
+results = json.loads(results_json)
+```
+
+## Supported Languages
+
+Stopword filtering is available for 18 languages:
+
+| Code | Language | Code | Language | Code | Language |
+|------|----------|------|----------|------|----------|
+| `en` | English | `de` | German | `fr` | French |
+| `es` | Spanish | `it` | Italian | `pt` | Portuguese |
+| `nl` | Dutch | `ru` | Russian | `sv` | Swedish |
+| `no` | Norwegian | `da` | Danish | `fi` | Finnish |
+| `hu` | Hungarian | `tr` | Turkish | `pl` | Polish |
+| `ar` | Arabic | `zh` | Chinese | `ja` | Japanese |
+
+## Performance
+
+rapid_textrank achieves significant speedups through Rust's performance characteristics and careful algorithm implementation.
+
+### Benchmark Script
+
+Run this script to compare performance on your hardware:
+
+```python
+"""
+Benchmark: rapid_textrank vs pytextrank
+
+Prerequisites:
+    pip install rapid_textrank pytextrank spacy
+    python -m spacy download en_core_web_sm
+"""
+
+import time
+import statistics
+
+# Sample texts of varying sizes
+TEXTS = {
+    "small": """
+        Machine learning is a subset of artificial intelligence.
+        Deep learning uses neural networks with many layers.
+    """,
+
+    "medium": """
+        Natural language processing (NLP) is a field of artificial intelligence
+        that focuses on the interaction between computers and humans through
+        natural language. The ultimate goal of NLP is to enable computers to
+        understand, interpret, and generate human language in a valuable way.
+
+        Machine learning approaches have transformed NLP in recent years.
+        Deep learning models, particularly transformers, have achieved
+        state-of-the-art results on many NLP tasks including translation,
+        summarization, and question answering.
+
+        Key applications include sentiment analysis, named entity recognition,
+        machine translation, and text classification. These technologies
+        power virtual assistants, search engines, and content recommendation
+        systems used by millions of people daily.
+    """,
+
+    "large": """
+        Artificial intelligence has evolved dramatically since its inception in
+        the mid-20th century. Early AI systems relied on symbolic reasoning and
+        expert systems, where human knowledge was manually encoded into rules.
+
+        The machine learning revolution changed everything. Instead of explicit
+        programming, systems learn patterns from data. Supervised learning uses
+        labeled examples, unsupervised learning finds hidden structures, and
+        reinforcement learning optimizes through trial and error.
+
+        Deep learning, powered by neural networks with multiple layers, has
+        achieved remarkable success. Convolutional neural networks excel at
+        image recognition. Recurrent neural networks and transformers handle
+        sequential data like text and speech. Generative adversarial networks
+        create realistic synthetic content.
+
+        Natural language processing has been transformed by these advances.
+        Word embeddings capture semantic relationships. Attention mechanisms
+        allow models to focus on relevant context. Large language models
+        demonstrate emergent capabilities in reasoning and generation.
+
+        Computer vision applications include object detection, facial recognition,
+        medical image analysis, and autonomous vehicle perception. These systems
+        process visual information with superhuman accuracy in many domains.
+
+        The ethical implications of AI are significant. Bias in training data
+        can lead to unfair outcomes. Privacy concerns arise from data collection.
+        Job displacement affects workers across industries. Regulation and
+        governance frameworks are being developed worldwide.
+
+        Future directions include neuromorphic computing, quantum machine learning,
+        and artificial general intelligence. Researchers continue to push
+        boundaries while addressing safety and alignment challenges.
+    """ * 3  # ~1000 words
+}
+
+
+def benchmark_rapid_textrank(text: str, runs: int = 10) -> dict:
+    """Benchmark rapid_textrank."""
+    from rapid_textrank import BaseTextRank
+
+    extractor = BaseTextRank(top_n=10, language="en")
+
+    # Warmup
+    extractor.extract_keywords(text)
+
+    times = []
+    for _ in range(runs):
+        start = time.perf_counter()
+        result = extractor.extract_keywords(text)
+        elapsed = time.perf_counter() - start
+        times.append(elapsed * 1000)  # Convert to ms
+
+    return {
+        "min": min(times),
+        "mean": statistics.mean(times),
+        "median": statistics.median(times),
+        "std": statistics.stdev(times) if len(times) > 1 else 0,
+        "phrases": len(result.phrases)
+    }
+
+
+def benchmark_pytextrank(text: str, runs: int = 10) -> dict:
+    """Benchmark pytextrank with spaCy."""
+    import spacy
+    import pytextrank
+
+    nlp = spacy.load("en_core_web_sm")
+    nlp.add_pipe("textrank")
+
+    # Warmup
+    doc = nlp(text)
+
+    times = []
+    for _ in range(runs):
+        start = time.perf_counter()
+        doc = nlp(text)
+        phrases = list(doc._.phrases[:10])
+        elapsed = time.perf_counter() - start
+        times.append(elapsed * 1000)
+
+    return {
+        "min": min(times),
+        "mean": statistics.mean(times),
+        "median": statistics.median(times),
+        "std": statistics.stdev(times) if len(times) > 1 else 0,
+        "phrases": len(phrases)
+    }
+
+
+def main():
+    print("=" * 70)
+    print("TextRank Performance Benchmark")
+    print("=" * 70)
+
+    for size, text in TEXTS.items():
+        word_count = len(text.split())
+        print(f"\n{size.upper()} TEXT (~{word_count} words)")
+        print("-" * 50)
+
+        # Benchmark rapid_textrank
+        rust_results = benchmark_rapid_textrank(text)
+        print(f"rapid_textrank:  {rust_results['mean']:>8.2f} ms (±{rust_results['std']:.2f})")
+
+        # Benchmark pytextrank
+        try:
+            py_results = benchmark_pytextrank(text)
+            print(f"pytextrank:     {py_results['mean']:>8.2f} ms (±{py_results['std']:.2f})")
+
+            speedup = py_results['mean'] / rust_results['mean']
+            print(f"Speedup:        {speedup:>8.1f}x faster")
+        except Exception as e:
+            print(f"pytextrank:     (not available: {e})")
+
+    print("\n" + "=" * 70)
+    print("Note: pytextrank times include spaCy tokenization.")
+    print("For fair comparison with pre-tokenized input, use rapid_textrank's JSON API.")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()
+```
+
+### Why Rust is Fast
+
+The performance advantage comes from several factors:
+
+1. **CSR Graph Format**: The co-occurrence graph uses Compressed Sparse Row format, enabling cache-friendly memory access during PageRank iteration.
+
+2. **String Interning**: Repeated words share a single allocation via `StringPool`, reducing memory usage 10-100x for typical documents.
+
+3. **Parallel Processing**: Rayon provides data parallelism for batch processing without explicit thread management.
+
+4. **Link-Time Optimization (LTO)**: Release builds use full LTO with single codegen unit for maximum inlining.
+
+5. **No GIL**: All computation happens in Rust. Python's Global Interpreter Lock is released during extraction.
+
+6. **FxHash**: Fast non-cryptographic hashing for internal hash maps.
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install rapid_textrank
+```
+
+Import name is `rapid_textrank`.
+
+### With spaCy Support
+
+```bash
+pip install rapid_textrank[spacy]
+```
+
+### From Source
+
+Requirements: Rust 1.70+, Python 3.9+
+
+```bash
+git clone https://github.com/textranker/rapid_textrank
+cd rapid_textrank
+pip install maturin
+maturin develop --release
+```
+
+### Development Setup
+
+```bash
+# Install with dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run Rust tests
+cargo test
+```
+
+## Publishing
+
+Publishing is automated with GitHub Actions using Trusted Publishing (OIDC), so no API tokens are stored.
+
+TestPyPI release (push a tag):
+
+```bash
+git tag -a test-0.1.0 -m "TestPyPI 0.1.0"
+git push origin test-0.1.0
+```
+
+Tag pattern: `test-*`
+
+PyPI release (push a tag):
+
+```bash
+git tag -a v0.1.0 -m "Release 0.1.0"
+git push origin v0.1.0
+```
+
+Tag pattern: `v*`
+
+Wheel builds
+
+GitHub Actions builds wheels for Python 3.9–3.12 on Linux, macOS, and Windows.
+
+Before the first publish, add Trusted Publishers on TestPyPI and PyPI:
+
+- Repo: `xang1234/textranker`
+- Workflows: `.github/workflows/publish-testpypi.yml` and `.github/workflows/publish-pypi.yml`
+- Environments: `testpypi` and `pypi`
+
+You can also trigger either workflow manually via GitHub Actions if needed.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Citation
+
+If you use rapid_textrank in research, please cite the original TextRank paper:
+
+```bibtex
+@inproceedings{mihalcea-tarau-2004-textrank,
+    title = "{T}ext{R}ank: Bringing Order into Text",
+    author = "Mihalcea, Rada and Tarau, Paul",
+    booktitle = "Proceedings of EMNLP 2004",
+    year = "2004",
+    publisher = "Association for Computational Linguistics",
+}
+```
+
+For PositionRank:
+
+```bibtex
+@inproceedings{florescu-caragea-2017-positionrank,
+    title = "{P}osition{R}ank: An Unsupervised Approach to Keyphrase Extraction from Scholarly Documents",
+    author = "Florescu, Corina and Caragea, Cornelia",
+    booktitle = "Proceedings of ACL 2017",
+    year = "2017",
+}
+```
+

rapid_textrank-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+rapid_textrank/__init__.py,sha256=o_pRt43a7RqoeenKu0Gg1EOg3zR88U29u7C5uz228ZM,1373
+rapid_textrank/_rust.cpython-314-darwin.so,sha256=UFhljfGAKMkXLD7xjwU8UP3NLFao7zfS5-mDtu7f32o,1108680
+rapid_textrank/spacy_component.py,sha256=yYOR-2sP9uxg_YhNHPYPjamt2meCGBOM1_mYbjh6pnY,7509
+rapid_textrank-0.0.1.dist-info/METADATA,sha256=N0HQLk2FkzTYVxUGM2_vmpAWnP04HcXFYGIyVvN3jwE,18686
+rapid_textrank-0.0.1.dist-info/WHEEL,sha256=jyP0hJCe-fSX_gEscesIqqW7KerDJw7iyldGx-__w10,107
+rapid_textrank-0.0.1.dist-info/licenses/LICENSE,sha256=yWeokG20y7cdx3UXBPoQgILIFjkz-ODLh3NElIXgGUA,1080
+rapid_textrank-0.0.1.dist-info/RECORD,,

rapid_textrank-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp314-cp314-macosx_10_12_x86_64

rapid_textrank-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TextRanker Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.