corp-extractor 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

{corp_extractor-0.3.0.dist-info → corp_extractor-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corp-extractor
-Version: 0.3.0
+Version: 0.4.0
 Summary: Extract structured statements from text using T5-Gemma 2 and Diverse Beam Search
 Project-URL: Homepage, https://github.com/corp-o-rate/statement-extractor
 Project-URL: Documentation, https://github.com/corp-o-rate/statement-extractor#readme
@@ -24,10 +24,10 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Text Processing :: Linguistic
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0.0
+Requires-Dist: gliner2
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: sentence-transformers>=2.2.0
-Requires-Dist: spacy>=3.5.0
 Requires-Dist: torch>=2.0.0
 Requires-Dist: transformers>=5.0.0rc3
 Provides-Extra: dev
@@ -49,18 +49,19 @@ Extract structured subject-predicate-object statements from unstructured text us
 
 - **Structured Extraction**: Converts unstructured text into subject-predicate-object triples
 - **Entity Type Recognition**: Identifies 12 entity types (ORG, PERSON, GPE, LOC, PRODUCT, EVENT, etc.)
-- **Combined Quality Scoring** *(v0.3.0)*: Confidence combines semantic similarity (50%) + subject/object noun scores (25% each)
-- **spaCy-First Predicates** *(v0.3.0)*: Always uses spaCy for predicate extraction (model predicates are unreliable)
-- **Multi-Candidate Extraction** *(v0.3.0)*: Generates 3 candidates per statement (hybrid, spaCy-only, predicate-split)
-- **Best Triple Selection** *(v0.3.0)*: Keeps only highest-scoring triple per source (use `--all-triples` to keep all)
-- **Extraction Method Tracking** *(v0.3.0)*: Each statement includes `extraction_method` field (hybrid, spacy, split, model)
-- **Beam Merging** *(v0.2.0)*: Combines top beams for better coverage instead of picking one
-- **Embedding-based Dedup** *(v0.2.0)*: Uses semantic similarity to detect near-duplicate predicates
-- **Predicate Taxonomies** *(v0.2.0)*: Normalize predicates to canonical forms via embeddings
-- **Contextualized Matching** *(v0.2.2)*: Compares full "Subject Predicate Object" against source text for better accuracy
-- **Entity Type Merging** *(v0.2.3)*: Automatically merges UNKNOWN entity types with specific types during deduplication
-- **Reversal Detection** *(v0.2.3)*: Detects and corrects subject-object reversals using embedding comparison
-- **Command Line Interface** *(v0.2.4)*: Full-featured CLI for terminal usage
+- **GLiNER2 Integration** *(v0.4.0)*: Uses GLiNER2 (205M params) for entity recognition and relation extraction
+- **Predefined Predicates** *(v0.4.0)*: Optional `--predicates` list for GLiNER2 relation extraction mode
+- **Entity-based Scoring** *(v0.4.0)*: Confidence combines semantic similarity (50%) + entity recognition scores (25% each)
+- **Multi-Candidate Extraction**: Generates 3 candidates per statement (hybrid, GLiNER2-only, predicate-split)
+- **Best Triple Selection**: Keeps only highest-scoring triple per source (use `--all-triples` to keep all)
+- **Extraction Method Tracking**: Each statement includes `extraction_method` field (hybrid, gliner, split, model)
+- **Beam Merging**: Combines top beams for better coverage instead of picking one
+- **Embedding-based Dedup**: Uses semantic similarity to detect near-duplicate predicates
+- **Predicate Taxonomies**: Normalize predicates to canonical forms via embeddings
+- **Contextualized Matching**: Compares full "Subject Predicate Object" against source text for better accuracy
+- **Entity Type Merging**: Automatically merges UNKNOWN entity types with specific types during deduplication
+- **Reversal Detection**: Detects and corrects subject-object reversals using embedding comparison
+- **Command Line Interface**: Full-featured CLI for terminal usage
 - **Multiple Output Formats**: Get results as Pydantic models, JSON, XML, or dictionaries
 
 ## Installation
@@ -69,7 +70,7 @@ Extract structured subject-predicate-object statements from unstructured text us
 pip install corp-extractor
 ```
 
-The spaCy model for predicate inference is downloaded automatically on first use.
+The GLiNER2 model (205M params) is downloaded automatically on first use.
 
 **Note**: This package requires `transformers>=5.0.0` for T5-Gemma2 model support.
 
@@ -179,7 +180,8 @@ Options:
   --no-dedup                   Disable deduplication
   --no-embeddings              Disable embedding-based dedup (faster)
   --no-merge                   Disable beam merging
-  --no-spacy                   Disable spaCy extraction (use raw model output)
+  --no-gliner                  Disable GLiNER2 extraction (use raw model output)
+  --predicates TEXT            Comma-separated predicate types for GLiNER2 relation extraction
   --all-triples                Keep all candidate triples (default: best per source)
   --dedup-threshold FLOAT      Deduplication threshold (default: 0.65)
   --min-confidence FLOAT       Min confidence filter (default: 0)
@@ -283,20 +285,42 @@ for stmt in fixed_statements:
 
 During deduplication, reversed duplicates (e.g., "A -> P -> B" and "B -> P -> A") are now detected and merged, with the correct orientation determined by source text similarity.
 
-## New in v0.3.0: spaCy-First Extraction & Semantic Scoring
+## New in v0.4.0: GLiNER2 Integration
 
-v0.3.0 introduces significant improvements to extraction quality:
+v0.4.0 replaces spaCy with **GLiNER2** (205M params) for entity recognition and relation extraction. GLiNER2 is a unified model that handles NER, text classification, structured data extraction, and relation extraction with CPU-optimized inference.
 
-### spaCy-First Predicate Extraction
+### Why GLiNER2?
 
-The T5-Gemma model is excellent at:
+The T5-Gemma model excels at:
 - **Triple isolation** - identifying that a relationship exists
 - **Coreference resolution** - resolving pronouns to named entities
 
-But unreliable at:
-- **Predicate extraction** - often returns empty or wrong predicates
+GLiNER2 now handles:
+- **Entity recognition** - refining subject/object boundaries
+- **Relation extraction** - when predefined predicates are provided
+- **Entity scoring** - scoring how "entity-like" subjects/objects are
 
-**Solution:** v0.3.0 always uses spaCy for predicate extraction. The model provides subject, object, entity types, and source text; spaCy provides the predicate.
+### Two Extraction Modes
+
+**Mode 1: With Predicate List** (GLiNER2 relation extraction)
+```python
+from statement_extractor import extract_statements, ExtractionOptions
+
+options = ExtractionOptions(predicates=["works_for", "founded", "acquired", "headquartered_in"])
+result = extract_statements("John works for Apple Inc. in Cupertino.", options)
+```
+
+Or via CLI:
+```bash
+corp-extractor "John works for Apple Inc." --predicates "works_for,founded,acquired"
+```
+
+**Mode 2: Without Predicate List** (entity-refined extraction)
+```python
+result = extract_statements("Apple announced a new iPhone.")
+# Uses GLiNER2 for entity extraction to refine boundaries
+# Extracts predicate from source text using T5-Gemma's hint
+```
 
 ### Three Candidate Extraction Methods
 
@@ -304,48 +328,46 @@ For each statement, three candidates are generated and the best is selected:
 
 | Method | Description |
 |--------|-------------|
-| `hybrid` | Model subject/object + spaCy predicate |
-| `spacy` | All components from spaCy dependency parsing |
+| `hybrid` | Model subject/object + GLiNER2/extracted predicate |
+| `gliner` | All components refined by GLiNER2 |
 | `split` | Source text split around the predicate |
 
 ```python
 for stmt in result:
     print(f"{stmt.subject.text} --[{stmt.predicate}]--> {stmt.object.text}")
-    print(f"  Method: {stmt.extraction_method}")  # hybrid, spacy, split, or model
+    print(f"  Method: {stmt.extraction_method}")  # hybrid, gliner, split, or model
     print(f"  Confidence: {stmt.confidence_score:.2f}")
 ```
 
 ### Combined Quality Scoring
 
-Confidence scores combine **semantic similarity** and **grammatical accuracy**:
+Confidence scores combine **semantic similarity** and **entity recognition**:
 
 | Component | Weight | Description |
 |-----------|--------|-------------|
 | Semantic similarity | 50% | Cosine similarity between source text and reassembled triple |
-| Subject noun score | 25% | How noun-like the subject is |
-| Object noun score | 25% | How noun-like the object is |
-
-**Noun scoring:**
-- Proper noun(s) only: 1.0
-- Common noun(s) only: 0.8
-- Contains noun + other words: 0.4-0.8 (based on ratio)
-- No nouns: 0.2
+| Subject entity score | 25% | How entity-like the subject is (via GLiNER2) |
+| Object entity score | 25% | How entity-like the object is (via GLiNER2) |
 
-This ensures extracted subjects and objects are grammatically valid entities, not fragments or verb phrases.
+**Entity scoring (via GLiNER2):**
+- Recognized entity with high confidence: 1.0
+- Recognized entity with moderate confidence: 0.8
+- Partially recognized: 0.6
+- Not recognized: 0.2
 
 ### Extraction Method Tracking
 
-Each statement now includes an `extraction_method` field:
-- `hybrid` - Model subject/object + spaCy predicate
-- `spacy` - All components from spaCy dependency parsing
+Each statement includes an `extraction_method` field:
+- `hybrid` - Model subject/object + GLiNER2 predicate
+- `gliner` - All components refined by GLiNER2
 - `split` - Subject/object from splitting source text around predicate
-- `model` - All components from T5-Gemma model (only when `--no-spacy`)
+- `model` - All components from T5-Gemma model (only when `--no-gliner`)
 
 ### Best Triple Selection
 
-By default, only the **highest-scoring triple** is kept for each source sentence. This ensures clean output without redundant candidates.
+By default, only the **highest-scoring triple** is kept for each source sentence.
 
-To keep all candidate triples (for debugging or analysis):
+To keep all candidate triples:
 ```python
 options = ExtractionOptions(all_triples=True)
 result = extract_statements(text, options)
@@ -356,15 +378,15 @@ Or via CLI:
 corp-extractor "Your text" --all-triples --verbose
 ```
 
-**Disable spaCy extraction** to use only model output:
+**Disable GLiNER2 extraction** to use only model output:
 ```python
-options = ExtractionOptions(use_spacy_extraction=False)
+options = ExtractionOptions(use_gliner_extraction=False)
 result = extract_statements(text, options)
 ```
 
 Or via CLI:
 ```bash
-corp-extractor "Your text" --no-spacy
+corp-extractor "Your text" --no-gliner
 ```
 
 ## Disable Embeddings
@@ -436,14 +458,14 @@ for text in texts:
 This library uses the T5-Gemma 2 statement extraction model with **Diverse Beam Search** ([Vijayakumar et al., 2016](https://arxiv.org/abs/1610.02424)):
 
 1. **Diverse Beam Search**: Generates 4+ candidate outputs using beam groups with diversity penalty
-2. **Quality Scoring** *(v0.2.0)*: Each triple scored for groundedness in source text
-3. **Beam Merging** *(v0.2.0)*: Top beams combined for better coverage
-4. **Embedding Dedup** *(v0.2.0)*: Semantic similarity removes near-duplicate predicates
-5. **Predicate Normalization** *(v0.2.0)*: Optional taxonomy matching via embeddings
-6. **Contextualized Matching** *(v0.2.2)*: Full statement context used for canonicalization and dedup
-7. **Entity Type Merging** *(v0.2.3)*: UNKNOWN types merged with specific types during dedup
-8. **Reversal Detection** *(v0.2.3)*: Subject-object reversals detected and corrected via embedding comparison
-9. **Hybrid spaCy** *(v0.2.12)*: spaCy candidates added to pool alongside model output for better coverage
+2. **Quality Scoring**: Each triple scored for groundedness in source text
+3. **Beam Merging**: Top beams combined for better coverage
+4. **Embedding Dedup**: Semantic similarity removes near-duplicate predicates
+5. **Predicate Normalization**: Optional taxonomy matching via embeddings
+6. **Contextualized Matching**: Full statement context used for canonicalization and dedup
+7. **Entity Type Merging**: UNKNOWN types merged with specific types during dedup
+8. **Reversal Detection**: Subject-object reversals detected and corrected via embedding comparison
+9. **GLiNER2 Extraction** *(v0.4.0)*: Entity recognition and relation extraction for improved accuracy
 
 ## Requirements
 
@@ -452,7 +474,7 @@ This library uses the T5-Gemma 2 statement extraction model with **Diverse Beam
 - Transformers 5.0+
 - Pydantic 2.0+
 - sentence-transformers 2.2+
-- spaCy 3.5+ (model downloaded automatically on first use)
+- GLiNER2 (model downloaded automatically on first use)
 - ~2GB VRAM (GPU) or ~4GB RAM (CPU)
 
 ## Links

corp_extractor-0.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+statement_extractor/__init__.py,sha256=KwZfWnTB9oevTLw0TrNlYFu67qIYO-34JqDtcpjOhZI,3013
+statement_extractor/canonicalization.py,sha256=ZMLs6RLWJa_rOJ8XZ7PoHFU13-zeJkOMDnvK-ZaFa5s,5991
+statement_extractor/cli.py,sha256=FOkkihVfoROc-Biu8ICCzlLJeDScYYNLLJHnv0GCGGM,9507
+statement_extractor/extractor.py,sha256=d0HnCeCPybw-4jDxH_ffZ4LY9Klvqnza_wa90Bd4Q18,40074
+statement_extractor/gliner_extraction.py,sha256=KNs3n5-fnoUwY1wvbPwZL8j-3YVstmioJlcjp2k1FmY,10491
+statement_extractor/models.py,sha256=cyCQc3vlYB3qlg6-uL5Vt4odIiulKtHzz1Cyrf0lEAU,12198
+statement_extractor/predicate_comparer.py,sha256=jcuaBi5BYqD3TKoyj3pR9dxtX5ihfDJvjdhEd2LHCwc,26184
+statement_extractor/scoring.py,sha256=s_8nhavBNzPPFmGf2FyBummH4tgP7YGpXoMhl2Jh3Xw,16650
+corp_extractor-0.4.0.dist-info/METADATA,sha256=8f2CDtZG757kaB6XMfbBVdNSRMyS5-4Lflc_LoZCC_8,17725
+corp_extractor-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+corp_extractor-0.4.0.dist-info/entry_points.txt,sha256=i0iKFqPIusvb-QTQ1zNnFgAqatgVah-jIhahbs5TToQ,115
+corp_extractor-0.4.0.dist-info/RECORD,,

statement_extractor/cli.py

@@ -34,7 +34,7 @@ def _configure_logging(verbose: bool) -> None:
         "statement_extractor.scoring",
         "statement_extractor.predicate_comparer",
         "statement_extractor.canonicalization",
-        "statement_extractor.spacy_extraction",
+        "statement_extractor.gliner_extraction",
     ]:
         logging.getLogger(logger_name).setLevel(level)
 
@@ -66,7 +66,8 @@ from .models import (
 @click.option("--no-dedup", is_flag=True, help="Disable deduplication")
 @click.option("--no-embeddings", is_flag=True, help="Disable embedding-based deduplication (faster)")
 @click.option("--no-merge", is_flag=True, help="Disable beam merging (select single best beam)")
-@click.option("--no-spacy", is_flag=True, help="Disable spaCy extraction (use raw model output)")
+@click.option("--no-gliner", is_flag=True, help="Disable GLiNER2 extraction (use raw model output)")
+@click.option("--predicates", type=str, help="Comma-separated list of predicate types for GLiNER2 relation extraction")
 @click.option("--all-triples", is_flag=True, help="Keep all candidate triples instead of selecting best per source")
 @click.option("--dedup-threshold", type=float, default=0.65, help="Similarity threshold for deduplication (default: 0.65)")
 # Quality options
@@ -92,7 +93,8 @@ def main(
     no_dedup: bool,
     no_embeddings: bool,
     no_merge: bool,
-    no_spacy: bool,
+    no_gliner: bool,
+    predicates: Optional[str],
     all_triples: bool,
     dedup_threshold: float,
     min_confidence: float,
@@ -157,6 +159,13 @@ def main(
     # Configure scoring
     scoring_config = ScoringConfig(min_confidence=min_confidence)
 
+    # Parse predicates if provided
+    predicate_list = None
+    if predicates:
+        predicate_list = [p.strip() for p in predicates.split(",") if p.strip()]
+        if not quiet:
+            click.echo(f"Using predicate list: {predicate_list}", err=True)
+
     # Configure extraction options
     options = ExtractionOptions(
         num_beams=beams,
@@ -165,7 +174,8 @@ def main(
         deduplicate=not no_dedup,
         embedding_dedup=not no_embeddings,
         merge_beams=not no_merge,
-        use_spacy_extraction=not no_spacy,
+        use_gliner_extraction=not no_gliner,
+        predicates=predicate_list,
         all_triples=all_triples,
         predicate_taxonomy=predicate_taxonomy,
         predicate_config=predicate_config,

statement_extractor/extractor.py

@@ -721,16 +721,17 @@ class StatementExtractor:
         Parse XML output into Statement objects.
 
         Uses model for subject, object, entity types, and source_text.
-        Always uses spaCy for predicate extraction (model predicates are unreliable).
+        Always uses GLiNER2 for predicate extraction (model predicates are unreliable).
 
         Produces two candidates for each statement:
-        1. Hybrid: model subject/object + spaCy predicate
-        2. spaCy-only: all components from spaCy
+        1. Hybrid: model subject/object + GLiNER2 predicate
+        2. GLiNER2-only: all components from GLiNER2
 
         Both go into the candidate pool; scoring/dedup picks the best.
         """
         statements: list[Statement] = []
-        use_spacy_extraction = options.use_spacy_extraction if options else True
+        use_gliner_extraction = options.use_gliner_extraction if options else True
+        predicates = options.predicates if options else None
 
         try:
             root = ET.fromstring(xml_output)
@@ -780,57 +781,63 @@ class StatementExtractor:
                     logger.debug(f"Skipping statement: missing subject or object from model")
                     continue
 
-                if use_spacy_extraction and source_text:
+                if use_gliner_extraction and source_text:
                     try:
-                        from .spacy_extraction import extract_triple_from_text, extract_triple_by_predicate_split
-                        spacy_result = extract_triple_from_text(
+                        from .gliner_extraction import extract_triple_from_text, extract_triple_by_predicate_split
+
+                        # Get model predicate for fallback/refinement
+                        predicate_elem = stmt_elem.find('predicate')
+                        model_predicate = predicate_elem.text.strip() if predicate_elem is not None and predicate_elem.text else ""
+
+                        gliner_result = extract_triple_from_text(
                             source_text=source_text,
                             model_subject=subject_text,
                             model_object=object_text,
-                            model_predicate="",  # Don't pass model predicate
+                            model_predicate=model_predicate,
+                            predicates=predicates,
                         )
-                        if spacy_result:
-                            spacy_subj, spacy_pred, spacy_obj = spacy_result
+                        if gliner_result:
+                            gliner_subj, gliner_pred, gliner_obj = gliner_result
 
-                            if spacy_pred:
-                                # Candidate 1: Hybrid (model subject/object + spaCy predicate)
+                            if gliner_pred:
+                                # Candidate 1: Hybrid (model subject/object + GLiNER2 predicate)
                                 logger.debug(
-                                    f"Adding hybrid candidate: '{subject_text}' --[{spacy_pred}]--> '{object_text}'"
+                                    f"Adding hybrid candidate: '{subject_text}' --[{gliner_pred}]--> '{object_text}'"
                                 )
                                 statements.append(Statement(
                                     subject=Entity(text=subject_text, type=subject_type),
-                                    predicate=spacy_pred,
+                                    predicate=gliner_pred,
                                     object=Entity(text=object_text, type=object_type),
                                     source_text=source_text,
                                     extraction_method=ExtractionMethod.HYBRID,
                                 ))
 
-                                # Candidate 2: spaCy-only (if different from hybrid)
-                                if spacy_subj and spacy_obj:
-                                    is_different = (spacy_subj != subject_text or spacy_obj != object_text)
+                                # Candidate 2: GLiNER2-only (if different from hybrid)
+                                if gliner_subj and gliner_obj:
+                                    is_different = (gliner_subj != subject_text or gliner_obj != object_text)
                                     if is_different:
                                         logger.debug(
-                                            f"Adding spaCy-only candidate: '{spacy_subj}' --[{spacy_pred}]--> '{spacy_obj}'"
+                                            f"Adding GLiNER2-only candidate: '{gliner_subj}' --[{gliner_pred}]--> '{gliner_obj}'"
                                         )
                                         statements.append(Statement(
-                                            subject=Entity(text=spacy_subj, type=subject_type),
-                                            predicate=spacy_pred,
-                                            object=Entity(text=spacy_obj, type=object_type),
+                                            subject=Entity(text=gliner_subj, type=subject_type),
+                                            predicate=gliner_pred,
+                                            object=Entity(text=gliner_obj, type=object_type),
                                             source_text=source_text,
-                                            extraction_method=ExtractionMethod.SPACY,
+                                            extraction_method=ExtractionMethod.GLINER,
                                         ))
 
                                 # Candidate 3: Predicate-split (split source text around predicate)
                                 split_result = extract_triple_by_predicate_split(
                                     source_text=source_text,
-                                    predicate=spacy_pred,
+                                    predicate=gliner_pred,
                                 )
                                 if split_result:
                                     split_subj, split_pred, split_obj = split_result
                                     # Only add if different from previous candidates
                                     is_different_from_hybrid = (split_subj != subject_text or split_obj != object_text)
-                                    is_different_from_spacy = (split_subj != spacy_subj or split_obj != spacy_obj)
-                                    if is_different_from_hybrid and is_different_from_spacy:
+                                    is_different_from_gliner = (split_subj != gliner_subj or split_obj != gliner_obj)
+                                    if is_different_from_hybrid and is_different_from_gliner:
                                         logger.debug(
                                             f"Adding predicate-split candidate: '{split_subj}' --[{split_pred}]--> '{split_obj}'"
                                         )
@@ -843,12 +850,12 @@ class StatementExtractor:
                                         ))
                             else:
                                 logger.debug(
-                                    f"spaCy found no predicate for: '{subject_text}' --> '{object_text}'"
+                                    f"GLiNER2 found no predicate for: '{subject_text}' --> '{object_text}'"
                                 )
                     except Exception as e:
-                        logger.debug(f"spaCy extraction failed: {e}")
+                        logger.debug(f"GLiNER2 extraction failed: {e}")
                 else:
-                    # spaCy disabled - fall back to model predicate
+                    # GLiNER2 disabled - fall back to model predicate
                     predicate_elem = stmt_elem.find('predicate')
                     model_predicate = predicate_elem.text.strip() if predicate_elem is not None and predicate_elem.text else ""
 

statement_extractor/gliner_extraction.py

@@ -0,0 +1,288 @@
+"""
+GLiNER2-based triple extraction.
+
+Uses GLiNER2 for relation extraction and entity recognition to extract
+subject, predicate, and object from source text. T5-Gemma model provides
+triple structure and coreference resolution, while GLiNER2 handles
+linguistic analysis.
+
+The GLiNER2 model is loaded automatically on first use.
+"""
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Lazy-loaded GLiNER2 model
+_model = None
+
+
+def _get_model():
+    """
+    Lazy-load the GLiNER2 model.
+
+    Uses the base model (205M parameters) which is CPU-optimized.
+    """
+    global _model
+    if _model is None:
+        from gliner2 import GLiNER2
+
+        logger.info("Loading GLiNER2 model 'fastino/gliner2-base-v1'...")
+        _model = GLiNER2.from_pretrained("fastino/gliner2-base-v1")
+        logger.debug("GLiNER2 model loaded")
+    return _model
+
+
+def extract_triple_from_text(
+    source_text: str,
+    model_subject: str,
+    model_object: str,
+    model_predicate: str,
+    predicates: Optional[list[str]] = None,
+) -> tuple[str, str, str] | None:
+    """
+    Extract subject, predicate, object from source text using GLiNER2.
+
+    Returns a GLiNER2-based triple that can be added to the candidate pool
+    alongside the model's triple. The existing scoring/dedup logic will
+    pick the best one.
+
+    Args:
+        source_text: The source sentence to analyze
+        model_subject: Subject from T5-Gemma (used for matching and fallback)
+        model_object: Object from T5-Gemma (used for matching and fallback)
+        model_predicate: Predicate from T5-Gemma (used when no predicates provided)
+        predicates: Optional list of predefined relation types to extract
+
+    Returns:
+        Tuple of (subject, predicate, object) from GLiNER2, or None if extraction fails
+    """
+    if not source_text:
+        return None
+
+    try:
+        model = _get_model()
+
+        if predicates:
+            # Use relation extraction with predefined predicates
+            result = model.extract_relations(source_text, predicates)
+
+            # Find best matching relation
+            relation_data = result.get("relation_extraction", {})
+            best_match = None
+            best_confidence = 0.0
+
+            for rel_type, relations in relation_data.items():
+                for rel in relations:
+                    # Handle both tuple format and dict format
+                    if isinstance(rel, tuple):
+                        head, tail = rel
+                        confidence = 1.0
+                    else:
+                        head = rel.get("head", {}).get("text", "")
+                        tail = rel.get("tail", {}).get("text", "")
+                        confidence = min(
+                            rel.get("head", {}).get("confidence", 0.5),
+                            rel.get("tail", {}).get("confidence", 0.5)
+                        )
+
+                    # Score based on match with model hints
+                    score = confidence
+                    if model_subject.lower() in head.lower() or head.lower() in model_subject.lower():
+                        score += 0.2
+                    if model_object.lower() in tail.lower() or tail.lower() in model_object.lower():
+                        score += 0.2
+
+                    if score > best_confidence:
+                        best_confidence = score
+                        best_match = (head, rel_type, tail)
+
+            if best_match:
+                logger.debug(
+                    f"GLiNER2 extracted (relation): subj='{best_match[0]}', pred='{best_match[1]}', obj='{best_match[2]}'"
+                )
+                return best_match
+
+        else:
+            # No predicate list provided - use GLiNER2 for entity extraction
+            # and extract predicate from source text using the model's hint
+
+            # Extract entities to refine subject/object boundaries
+            entity_types = [
+                "person", "organization", "company", "location", "city", "country",
+                "product", "event", "date", "money", "quantity"
+            ]
+            result = model.extract_entities(source_text, entity_types)
+            entities = result.get("entities", {})
+
+            # Find entities that match model subject/object
+            refined_subject = model_subject
+            refined_object = model_object
+
+            for entity_type, entity_list in entities.items():
+                for entity in entity_list:
+                    entity_lower = entity.lower()
+                    # Check if this entity matches or contains the model's subject/object
+                    if model_subject.lower() in entity_lower or entity_lower in model_subject.lower():
+                        # Use the entity text if it's more complete
+                        if len(entity) >= len(refined_subject):
+                            refined_subject = entity
+                    if model_object.lower() in entity_lower or entity_lower in model_object.lower():
+                        if len(entity) >= len(refined_object):
+                            refined_object = entity
+
+            # Extract predicate from source text using predicate split
+            predicate_result = extract_triple_by_predicate_split(source_text, model_predicate)
+            if predicate_result:
+                _, extracted_predicate, _ = predicate_result
+            else:
+                extracted_predicate = model_predicate
+
+            if extracted_predicate:
+                logger.debug(
+                    f"GLiNER2 extracted (entity-refined): subj='{refined_subject}', pred='{extracted_predicate}', obj='{refined_object}'"
+                )
+                return (refined_subject, extracted_predicate, refined_object)
+
+        return None
+
+    except ImportError as e:
+        logger.warning(f"GLiNER2 not installed: {e}")
+        return None
+    except Exception as e:
+        logger.debug(f"GLiNER2 extraction failed: {e}")
+        return None
+
+
+def extract_triple_by_predicate_split(
+    source_text: str,
+    predicate: str,
+) -> tuple[str, str, str] | None:
+    """
+    Extract subject and object by splitting the source text around the predicate.
+
+    This is useful when the predicate is known but subject/object boundaries
+    are uncertain. Uses the predicate as an anchor point.
+
+    Args:
+        source_text: The source sentence
+        predicate: The predicate (verb phrase) to split on
+
+    Returns:
+        Tuple of (subject, predicate, object) or None if split fails
+    """
+    if not source_text or not predicate:
+        return None
+
+    # Find the predicate in the source text (case-insensitive)
+    source_lower = source_text.lower()
+    pred_lower = predicate.lower()
+
+    pred_pos = source_lower.find(pred_lower)
+    if pred_pos < 0:
+        # Try finding just the main verb (first word of predicate)
+        main_verb = pred_lower.split()[0] if pred_lower.split() else ""
+        if main_verb and len(main_verb) > 2:
+            pred_pos = source_lower.find(main_verb)
+            if pred_pos >= 0:
+                # Adjust to use the actual predicate length for splitting
+                predicate = main_verb
+
+    if pred_pos < 0:
+        return None
+
+    # Extract subject (text before predicate, trimmed)
+    subject = source_text[:pred_pos].strip()
+
+    # Extract object (text after predicate, trimmed)
+    pred_end = pred_pos + len(predicate)
+    obj = source_text[pred_end:].strip()
+
+    # Clean up: remove trailing punctuation from object
+    obj = obj.rstrip('.,;:!?')
+
+    # Clean up: remove leading articles/prepositions from object if very short
+    obj_words = obj.split()
+    if obj_words and obj_words[0].lower() in ('a', 'an', 'the', 'to', 'of', 'for'):
+        if len(obj_words) > 1:
+            obj = ' '.join(obj_words[1:])
+
+    # Validate: both subject and object should have meaningful content
+    if len(subject) < 2 or len(obj) < 2:
+        return None
+
+    logger.debug(
+        f"Predicate-split extracted: subj='{subject}', pred='{predicate}', obj='{obj}'"
+    )
+
+    return (subject, predicate, obj)
+
+
+def score_entity_content(text: str) -> float:
+    """
+    Score how entity-like a text is using GLiNER2 entity recognition.
+
+    Returns:
+        1.0 - Recognized as a named entity with high confidence
+        0.8 - Recognized as an entity with moderate confidence
+        0.6 - Partially recognized or contains entity-like content
+        0.2 - Not recognized as any entity type
+    """
+    if not text or not text.strip():
+        return 0.2
+
+    try:
+        model = _get_model()
+
+        # Check if text is recognized as common entity types
+        entity_types = [
+            "person", "organization", "company", "location", "city", "country",
+            "product", "event", "date", "money", "quantity"
+        ]
+
+        result = model.extract_entities(
+            text,
+            entity_types,
+            include_confidence=True
+        )
+
+        # Result format: {'entities': {'person': [{'text': '...', 'confidence': 0.99}], ...}}
+        entities_dict = result.get("entities", {})
+
+        # Find best matching entity across all types
+        best_confidence = 0.0
+        text_lower = text.lower().strip()
+
+        for entity_type, entity_list in entities_dict.items():
+            for entity in entity_list:
+                if isinstance(entity, dict):
+                    entity_text = entity.get("text", "").lower().strip()
+                    confidence = entity.get("confidence", 0.5)
+                else:
+                    # Fallback for string format
+                    entity_text = str(entity).lower().strip()
+                    confidence = 0.8
+
+                # Check if entity covers most of the input text
+                if entity_text == text_lower:
+                    # Exact match
+                    best_confidence = max(best_confidence, confidence)
+                elif entity_text in text_lower or text_lower in entity_text:
+                    # Partial match - reduce confidence
+                    best_confidence = max(best_confidence, confidence * 0.8)
+
+        if best_confidence >= 0.9:
+            return 1.0
+        elif best_confidence >= 0.7:
+            return 0.8
+        elif best_confidence >= 0.5:
+            return 0.6
+        elif best_confidence > 0:
+            return 0.4
+        else:
+            return 0.2
+
+    except Exception as e:
+        logger.debug(f"Entity scoring failed for '{text}': {e}")
+        return 0.5  # Neutral score on error

statement_extractor/models.py

@@ -26,10 +26,10 @@ class EntityType(str, Enum):
 
 class ExtractionMethod(str, Enum):
     """Method used to extract the triple components."""
-    HYBRID = "hybrid"  # Model subject/object + spaCy predicate
-    SPACY = "spacy"  # All components from spaCy dependency parsing
+    HYBRID = "hybrid"  # Model subject/object + GLiNER2 predicate
+    GLINER = "gliner"  # All components from GLiNER2 extraction
     SPLIT = "split"  # Subject/object from splitting source text around predicate
-    MODEL = "model"  # All components from T5-Gemma model (when spaCy disabled)
+    MODEL = "model"  # All components from T5-Gemma model (when GLiNER2 disabled)
 
 
 class Entity(BaseModel):
@@ -295,9 +295,15 @@ class ExtractionOptions(BaseModel):
         default=True,
         description="Use embedding similarity for predicate deduplication"
     )
-    use_spacy_extraction: bool = Field(
+    use_gliner_extraction: bool = Field(
         default=True,
-        description="Use spaCy for predicate/subject/object extraction (model provides structure + coreference)"
+        description="Use GLiNER2 for predicate/subject/object extraction (model provides structure + coreference)"
+    )
+
+    # GLiNER2 predicate configuration
+    predicates: Optional[list[str]] = Field(
+        default=None,
+        description="Optional list of predefined predicate types for GLiNER2 relation extraction (e.g., ['works_for', 'founded'])"
     )
 
     # Verbose logging

statement_extractor/scoring.py

@@ -15,41 +15,21 @@ from .models import ScoringConfig, Statement
 
 logger = logging.getLogger(__name__)
 
-# Lazy-loaded spaCy model for grammatical analysis
-_nlp = None
-
-
-def _get_nlp():
-    """Lazy-load spaCy model for POS tagging."""
-    global _nlp
-    if _nlp is None:
-        import spacy
-        try:
-            _nlp = spacy.load("en_core_web_sm", disable=["ner", "lemmatizer"])
-        except OSError:
-            # Model not found, try to download
-            from .spacy_extraction import _download_model
-            if _download_model():
-                _nlp = spacy.load("en_core_web_sm", disable=["ner", "lemmatizer"])
-            else:
-                raise
-    return _nlp
-
 
 class TripleScorer:
     """
-    Score individual triples combining semantic similarity and grammatical accuracy.
+    Score individual triples combining semantic similarity and entity recognition.
 
     The score is a weighted combination of:
     - Semantic similarity (50%): Cosine similarity between source text and reassembled triple
-    - Subject noun score (25%): How noun-like the subject is
-    - Object noun score (25%): How noun-like the object is
-
-    Noun scoring:
-    - Proper noun only (PROPN): 1.0
-    - Common noun only (NOUN): 0.8
-    - Contains noun + other words: 0.6
-    - No noun: 0.2
+    - Subject entity score (25%): How entity-like the subject is (via GLiNER2)
+    - Object entity score (25%): How entity-like the object is (via GLiNER2)
+
+    Entity scoring (via GLiNER2):
+    - Recognized entity with high confidence: 1.0
+    - Recognized entity with moderate confidence: 0.8
+    - Partially recognized: 0.6
+    - Not recognized: 0.2
     """
 
     def __init__(
@@ -102,54 +82,22 @@ class TripleScorer:
 
     def _score_noun_content(self, text: str) -> float:
         """
-        Score how noun-like a text is.
+        Score how entity-like a text is using GLiNER2 entity recognition.
 
         Returns:
-            1.0 - Entirely proper noun(s)
-            0.8 - Entirely common noun(s)
-            0.6 - Contains noun(s) but also other words
-            0.2 - No nouns found
+            1.0 - Recognized as a named entity with high confidence
+            0.8 - Recognized as an entity with moderate confidence
+            0.6 - Partially recognized or contains entity-like content
+            0.2 - Not recognized as any entity type
         """
         if not text or not text.strip():
             return 0.2
 
         try:
-            nlp = _get_nlp()
-            doc = nlp(text)
-
-            # Count token types (excluding punctuation and spaces)
-            tokens = [t for t in doc if not t.is_punct and not t.is_space]
-            if not tokens:
-                return 0.2
-
-            proper_nouns = sum(1 for t in tokens if t.pos_ == "PROPN")
-            common_nouns = sum(1 for t in tokens if t.pos_ == "NOUN")
-            total_nouns = proper_nouns + common_nouns
-            total_tokens = len(tokens)
-
-            if total_nouns == 0:
-                # No nouns at all
-                return 0.2
-
-            if total_nouns == total_tokens:
-                # Entirely nouns
-                if proper_nouns == total_tokens:
-                    # All proper nouns
-                    return 1.0
-                elif common_nouns == total_tokens:
-                    # All common nouns
-                    return 0.8
-                else:
-                    # Mix of proper and common nouns
-                    return 0.9
-
-            # Contains nouns but also other words
-            # Score based on noun ratio
-            noun_ratio = total_nouns / total_tokens
-            return 0.4 + (noun_ratio * 0.4)  # Range: 0.4 to 0.8
-
+            from .gliner_extraction import score_entity_content
+            return score_entity_content(text)
         except Exception as e:
-            logger.debug(f"Noun scoring failed for '{text}': {e}")
+            logger.debug(f"Entity scoring failed for '{text}': {e}")
             return 0.5  # Neutral score on error
 
     def score_triple(self, statement: Statement, source_text: str) -> float:

corp_extractor-0.3.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-statement_extractor/__init__.py,sha256=KwZfWnTB9oevTLw0TrNlYFu67qIYO-34JqDtcpjOhZI,3013
-statement_extractor/canonicalization.py,sha256=ZMLs6RLWJa_rOJ8XZ7PoHFU13-zeJkOMDnvK-ZaFa5s,5991
-statement_extractor/cli.py,sha256=JMEXiT2xwmW1J8JmJliQh32AT-7bTAtAscPx1AGRfPg,9054
-statement_extractor/extractor.py,sha256=vS8UCgE8uITt_28PwCh4WCqOjWLpfrJcN3fh1YPBcjA,39657
-statement_extractor/models.py,sha256=FxLj2fIodX317XVIJLZ0GFNahm_VV07KzdoLSSjoVD4,11952
-statement_extractor/predicate_comparer.py,sha256=jcuaBi5BYqD3TKoyj3pR9dxtX5ihfDJvjdhEd2LHCwc,26184
-statement_extractor/scoring.py,sha256=pdNgyLHmlk-npISzm4nycK9G4wM2nztg5KTG7piFACI,18135
-statement_extractor/spacy_extraction.py,sha256=ACvIB-Ag7H7h_Gb0cdypIr8fnf3A-UjyJnqqjWD5Ccs,12320
-corp_extractor-0.3.0.dist-info/METADATA,sha256=eu8b7R_FQxFyc_9FSocy078TTyB7BwvGX-YAS79hKgg,17042
-corp_extractor-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-corp_extractor-0.3.0.dist-info/entry_points.txt,sha256=i0iKFqPIusvb-QTQ1zNnFgAqatgVah-jIhahbs5TToQ,115
-corp_extractor-0.3.0.dist-info/RECORD,,

statement_extractor/spacy_extraction.py

@@ -1,386 +0,0 @@
-"""
-spaCy-based triple extraction.
-
-Uses spaCy dependency parsing to extract subject, predicate, and object
-from source text. T5-Gemma model provides triple structure and coreference
-resolution, while spaCy handles linguistic analysis.
-
-The spaCy model is downloaded automatically on first use.
-"""
-
-import logging
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-# Lazy-loaded spaCy model
-_nlp = None
-
-
-def _download_model():
-    """Download the spaCy model if not present."""
-    import shutil
-    import subprocess
-    import sys
-
-    # Direct URL to the spaCy model wheel
-    MODEL_URL = "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl"
-
-    logger.info("Downloading spaCy model 'en_core_web_sm'...")
-
-    # Try uv first (for uv-managed environments)
-    uv_path = shutil.which("uv")
-    if uv_path:
-        try:
-            result = subprocess.run(
-                [uv_path, "pip", "install", MODEL_URL],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode == 0:
-                logger.info("Successfully downloaded spaCy model via uv")
-                return True
-            logger.debug(f"uv pip install failed: {result.stderr}")
-        except Exception as e:
-            logger.debug(f"uv pip install failed: {e}")
-
-    # Try pip directly
-    try:
-        result = subprocess.run(
-            [sys.executable, "-m", "pip", "install", MODEL_URL],
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode == 0:
-            logger.info("Successfully downloaded spaCy model via pip")
-            return True
-        logger.debug(f"pip install failed: {result.stderr}")
-    except Exception as e:
-        logger.debug(f"pip install failed: {e}")
-
-    # Try spacy's download as last resort
-    try:
-        from spacy.cli import download
-        download("en_core_web_sm")
-        # Check if it actually worked
-        import spacy
-        spacy.load("en_core_web_sm")
-        logger.info("Successfully downloaded spaCy model via spacy")
-        return True
-    except Exception:
-        pass
-
-    logger.warning(
-        "Failed to download spaCy model automatically. "
-        "Please run: uv pip install https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl"
-    )
-    return False
-
-
-def _get_nlp():
-    """
-    Lazy-load the spaCy model.
-
-    Disables NER and lemmatizer for faster processing since we only
-    need dependency parsing. Automatically downloads the model if not present.
-    """
-    global _nlp
-    if _nlp is None:
-        import spacy
-
-        # Try to load the model, download if not present
-        try:
-            _nlp = spacy.load("en_core_web_sm", disable=["ner", "lemmatizer"])
-            logger.debug("Loaded spaCy model for extraction")
-        except OSError:
-            # Model not found, try to download it
-            if _download_model():
-                _nlp = spacy.load("en_core_web_sm", disable=["ner", "lemmatizer"])
-                logger.debug("Loaded spaCy model after download")
-            else:
-                raise OSError(
-                    "spaCy model not found and automatic download failed. "
-                    "Please run: python -m spacy download en_core_web_sm"
-                )
-    return _nlp
-
-
-def _get_full_noun_phrase(token) -> str:
-    """
-    Get the full noun phrase for a token, including compounds and modifiers.
-    """
-    # Get all tokens in the subtree that form the noun phrase
-    phrase_tokens = []
-
-    # Collect compound modifiers and the token itself
-    for t in token.subtree:
-        # Include compounds, adjectives, determiners, and the head noun
-        if t.dep_ in ("compound", "amod", "det", "poss", "nummod", "nmod") or t == token:
-            phrase_tokens.append(t)
-
-    # Sort by position and join
-    phrase_tokens.sort(key=lambda x: x.i)
-    return " ".join([t.text for t in phrase_tokens])
-
-
-def _extract_verb_phrase(verb_token) -> str:
-    """
-    Extract the full verb phrase including auxiliaries and particles.
-    """
-    parts = []
-
-    # Collect auxiliaries that come before the verb
-    for child in verb_token.children:
-        if child.dep_ in ("aux", "auxpass") and child.i < verb_token.i:
-            parts.append((child.i, child.text))
-
-    # Add the main verb
-    parts.append((verb_token.i, verb_token.text))
-
-    # Collect particles and prepositions that are part of phrasal verbs
-    for child in verb_token.children:
-        if child.dep_ == "prt" and child.i > verb_token.i:
-            parts.append((child.i, child.text))
-        # Include prepositions for phrasal verbs like "announced by"
-        elif child.dep_ == "agent" and child.i > verb_token.i:
-            # For passive constructions, include "by"
-            parts.append((child.i, child.text))
-
-    # Sort by position and join
-    parts.sort(key=lambda x: x[0])
-    return " ".join([p[1] for p in parts])
-
-
-def _match_entity_boundaries(
-    spacy_text: str,
-    model_text: str,
-    source_text: str,
-) -> str:
-    """
-    Match entity boundaries between spaCy extraction and model hint.
-
-    If model text is a superset that includes spaCy text, use model text
-    for better entity boundaries (e.g., "Apple" -> "Apple Inc.").
-    """
-    spacy_lower = spacy_text.lower()
-    model_lower = model_text.lower()
-
-    # If model text contains spaCy text, prefer model text
-    if spacy_lower in model_lower:
-        return model_text
-
-    # If spaCy text contains model text, prefer spaCy text
-    if model_lower in spacy_lower:
-        return spacy_text
-
-    # If they overlap significantly, prefer the one that appears in source
-    if spacy_text in source_text:
-        return spacy_text
-    if model_text in source_text:
-        return model_text
-
-    # Default to spaCy extraction
-    return spacy_text
-
-
-def _extract_spacy_triple(doc, model_subject: str, model_object: str, source_text: str) -> tuple[str | None, str | None, str | None]:
-    """Extract subject, predicate, object from spaCy doc."""
-    # Find the root verb
-    root = None
-    for token in doc:
-        if token.dep_ == "ROOT":
-            root = token
-            break
-
-    if root is None:
-        return None, None, None
-
-    # Extract predicate from root verb
-    predicate = None
-    if root.pos_ == "VERB":
-        predicate = _extract_verb_phrase(root)
-    elif root.pos_ == "AUX":
-        predicate = root.text
-
-    # Extract subject (nsubj, nsubjpass)
-    subject = None
-    for child in root.children:
-        if child.dep_ in ("nsubj", "nsubjpass"):
-            subject = _get_full_noun_phrase(child)
-            break
-
-    # If no direct subject, check parent
-    if subject is None and root.head != root:
-        for child in root.head.children:
-            if child.dep_ in ("nsubj", "nsubjpass"):
-                subject = _get_full_noun_phrase(child)
-                break
-
-    # Extract object (dobj, pobj, attr, oprd)
-    obj = None
-    for child in root.children:
-        if child.dep_ in ("dobj", "attr", "oprd"):
-            obj = _get_full_noun_phrase(child)
-            break
-        elif child.dep_ == "prep":
-            for pchild in child.children:
-                if pchild.dep_ == "pobj":
-                    obj = _get_full_noun_phrase(pchild)
-                    break
-            if obj:
-                break
-        elif child.dep_ == "agent":
-            for pchild in child.children:
-                if pchild.dep_ == "pobj":
-                    obj = _get_full_noun_phrase(pchild)
-                    break
-            if obj:
-                break
-
-    # Match against model values for better entity boundaries
-    if subject:
-        subject = _match_entity_boundaries(subject, model_subject, source_text)
-    if obj:
-        obj = _match_entity_boundaries(obj, model_object, source_text)
-
-    return subject, predicate, obj
-
-
-def extract_triple_from_text(
-    source_text: str,
-    model_subject: str,
-    model_object: str,
-    model_predicate: str,
-) -> tuple[str, str, str] | None:
-    """
-    Extract subject, predicate, object from source text using spaCy.
-
-    Returns a spaCy-based triple that can be added to the candidate pool
-    alongside the model's triple. The existing scoring/dedup logic will
-    pick the best one.
-
-    Args:
-        source_text: The source sentence to analyze
-        model_subject: Subject from T5-Gemma (used for entity boundary matching)
-        model_object: Object from T5-Gemma (used for entity boundary matching)
-        model_predicate: Predicate from T5-Gemma (unused, kept for API compat)
-
-    Returns:
-        Tuple of (subject, predicate, object) from spaCy, or None if extraction fails
-    """
-    if not source_text:
-        return None
-
-    try:
-        nlp = _get_nlp()
-        doc = nlp(source_text)
-        spacy_subject, spacy_predicate, spacy_object = _extract_spacy_triple(
-            doc, model_subject, model_object, source_text
-        )
-
-        # Only return if we got at least a predicate
-        if spacy_predicate:
-            logger.debug(
-                f"spaCy extracted: subj='{spacy_subject}', pred='{spacy_predicate}', obj='{spacy_object}'"
-            )
-            return (
-                spacy_subject or model_subject,
-                spacy_predicate,
-                spacy_object or model_object,
-            )
-
-        return None
-
-    except OSError as e:
-        logger.debug(f"Cannot load spaCy model: {e}")
-        return None
-    except Exception as e:
-        logger.debug(f"spaCy extraction failed: {e}")
-        return None
-
-
-def extract_triple_by_predicate_split(
-    source_text: str,
-    predicate: str,
-) -> tuple[str, str, str] | None:
-    """
-    Extract subject and object by splitting the source text around the predicate.
-
-    This is useful when the predicate is known but subject/object boundaries
-    are uncertain. Uses the predicate as an anchor point.
-
-    Args:
-        source_text: The source sentence
-        predicate: The predicate (verb phrase) to split on
-
-    Returns:
-        Tuple of (subject, predicate, object) or None if split fails
-    """
-    if not source_text or not predicate:
-        return None
-
-    # Find the predicate in the source text (case-insensitive)
-    source_lower = source_text.lower()
-    pred_lower = predicate.lower()
-
-    pred_pos = source_lower.find(pred_lower)
-    if pred_pos < 0:
-        # Try finding just the main verb (first word of predicate)
-        main_verb = pred_lower.split()[0] if pred_lower.split() else ""
-        if main_verb and len(main_verb) > 2:
-            pred_pos = source_lower.find(main_verb)
-            if pred_pos >= 0:
-                # Adjust to use the actual predicate length for splitting
-                predicate = main_verb
-
-    if pred_pos < 0:
-        return None
-
-    # Extract subject (text before predicate, trimmed)
-    subject = source_text[:pred_pos].strip()
-
-    # Extract object (text after predicate, trimmed)
-    pred_end = pred_pos + len(predicate)
-    obj = source_text[pred_end:].strip()
-
-    # Clean up: remove trailing punctuation from object
-    obj = obj.rstrip('.,;:!?')
-
-    # Clean up: remove leading articles/prepositions from object if very short
-    obj_words = obj.split()
-    if obj_words and obj_words[0].lower() in ('a', 'an', 'the', 'to', 'of', 'for'):
-        if len(obj_words) > 1:
-            obj = ' '.join(obj_words[1:])
-
-    # Validate: both subject and object should have meaningful content
-    if len(subject) < 2 or len(obj) < 2:
-        return None
-
-    logger.debug(
-        f"Predicate-split extracted: subj='{subject}', pred='{predicate}', obj='{obj}'"
-    )
-
-    return (subject, predicate, obj)
-
-
-# Keep old function for backwards compatibility
-def infer_predicate(
-    subject: str,
-    obj: str,
-    source_text: str,
-) -> Optional[str]:
-    """
-    Infer the predicate from source text using dependency parsing.
-
-    DEPRECATED: Use extract_triple_from_text instead.
-    """
-    result = extract_triple_from_text(
-        source_text=source_text,
-        model_subject=subject,
-        model_object=obj,
-        model_predicate="",
-    )
-    if result:
-        _, predicate, _ = result
-        return predicate if predicate else None
-    return None