pyannotators-entityfishing 0.6.3__py3-none-any.whl

pyannotators_entityfishing/__init__.py

@@ -0,0 +1,3 @@
+"""Annotator based on entity-fishing"""
+
+__version__ = "0.6.3"

pyannotators_entityfishing/ef_client.py

@@ -0,0 +1,242 @@
+import hashlib
+import logging
+import time
+from collections.abc import Iterable
+from concurrent.futures import as_completed
+from datetime import timedelta
+
+import requests
+from collections_extended import RangeMap
+from pymultirole_plugins.v1.schema import Document
+from requests.adapters import DEFAULT_POOLSIZE, HTTPAdapter
+from requests_cache import CachedSession
+from requests_futures.sessions import FuturesSession
+
+logger = logging.getLogger("ef-client")
+
+DEFAULT_CHUNK_SIZE = 1000
+
+
+class EntityFishingClient:
+    def __init__(
+        self,
+        base_url: str = "https://sherpa-entityfishing.kairntech.com",
+        chunk_size: int = DEFAULT_CHUNK_SIZE,
+        cache_disamb: int = -1,
+        cache_concept: int = -1,
+        pool_size: int = 8,
+        full: bool = False,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.chunk_size = chunk_size
+        self.full = full
+
+        self.dsession = (
+            CachedSession(
+                "file:disamb_cache?mode=memory&cache=shared",
+                backend="sqlite",
+                uri=True,
+                wal=True,
+                cache_control=True,
+                expire_after=timedelta(seconds=cache_disamb),
+                allowable_methods=["POST"],
+            )
+            if cache_disamb > 0
+            else requests.Session()
+        )
+        self.dsession.mount("http://", HTTPAdapter(pool_maxsize=max(DEFAULT_POOLSIZE, pool_size)))
+        self.dsession.mount("https://", HTTPAdapter(pool_maxsize=max(DEFAULT_POOLSIZE, pool_size)))
+        self.dsession.headers.update({"Content-Type": "application/json", "Accept": "application/json"})
+        self.dsession.verify = False
+        self.fdsession = FuturesSession(session=self.dsession, max_workers=pool_size)
+
+        self.ksession = (
+            CachedSession(
+                "file:concept_cache?mode=memory&cache=shared",
+                backend="sqlite",
+                uri=True,
+                wal=True,
+                cache_control=True,
+                expire_after=timedelta(seconds=cache_concept),
+                allowable_methods=["GET"],
+            )
+            if cache_concept > 0
+            else requests.Session()
+        )
+        self.ksession.mount("http://", HTTPAdapter(pool_maxsize=max(DEFAULT_POOLSIZE, pool_size)))
+        self.ksession.mount("https://", HTTPAdapter(pool_maxsize=max(DEFAULT_POOLSIZE, pool_size)))
+        self.ksession.headers.update({"Content-Type": "application/json", "Accept": "application/json"})
+        self.ksession.verify = False
+        self.fksession = FuturesSession(session=self.ksession, max_workers=pool_size)
+
+        self.disamb_url = "/service/disambiguate/"
+        self.kb_url = "/service/kb/concept/"
+        self.term_url = "/service/kb/term/"
+
+    def _build_disamb_query(self, text: str, sentences: list[dict], lang: str, minSelectorScore: float, maxTermFrequency: float | None, short_text: bool = False) -> dict:
+        text = text.replace("\r\n", " \n")
+        disamb_query = {
+            "sentences": sentences,
+            "language": {"lang": lang},
+            "mentions": ["wikipedia"],
+            "nbest": short_text,
+            "sentence": False,
+            "full": self.full,
+            "customisation": "generic",
+            "minSelectorScore": minSelectorScore,
+        }
+        if short_text:
+            disamb_query["shortText"] = text
+        else:
+            disamb_query["text"] = text
+        if maxTermFrequency is not None and isinstance(maxTermFrequency, float):
+            disamb_query["maxTermFrequency"] = maxTermFrequency
+        return disamb_query
+
+    def disamb_query(self, text: str, lang: str, minSelectorScore: float, maxTermFrequency: float | None, sents: tuple, short_text: bool = False) -> list:
+        sentences = [{"offsetStart": s[0], "offsetEnd": s[1]} for s in sents]
+        disamb_query = self._build_disamb_query(text, sentences, lang, minSelectorScore, maxTermFrequency, short_text)
+        try:
+            start = time.time()
+            resp = self.dsession.post(self.base_url + self.disamb_url, json=disamb_query, timeout=(30, 300))
+            duration = time.time() - start
+            logger.debug("EF disamb duration %0.3fs", duration)
+            if resp.ok:
+                result = resp.json()
+                return result.get("entities", [])
+            else:
+                resp.raise_for_status()
+        except Exception:
+            logging.warning("An exception was thrown!", exc_info=True)
+        return []
+
+    def disamb_queries(self, inputs: list[Document], langs: list[str], minSelectorScore: float, maxTermFrequency: float | None, short_text: bool = False) -> list[list]:
+        futures = []
+        results: list[list] = [[] for _ in range(len(inputs))]
+        start = time.time()
+
+        for idx, (doc, lang) in enumerate(zip(inputs, langs, strict=True)):
+            sents = [(s.start, s.end) for s in doc.sentences] if doc.sentences else [(0, len(doc.text))]
+            sentences = [{"offsetStart": s[0], "offsetEnd": s[1]} for s in sents]
+            disamb_query = self._build_disamb_query(doc.text, sentences, lang, minSelectorScore, maxTermFrequency, short_text)
+            future = self.fdsession.post(self.base_url + self.disamb_url, json=disamb_query, timeout=(30, 300))
+            future.idx = idx
+            futures.append(future)
+
+        for future in as_completed(futures):
+            try:
+                resp = future.result()
+                if resp.ok:
+                    result = resp.json()
+                    results[future.idx] = result.get("entities", [])
+                else:
+                    resp.raise_for_status()
+            except Exception:
+                logging.warning("An exception was thrown!", exc_info=True)
+        duration = time.time() - start
+        logger.debug("EF disamb duration with %d docs %0.3fs", len(inputs), duration)
+        return results
+
+    @staticmethod
+    def group_sentences(text: str, sentences: list[dict], chunk_size: int = DEFAULT_CHUNK_SIZE):
+        chunks = RangeMap()
+        for sent in sentences:
+            if sent["offsetStart"] < sent["offsetEnd"]:
+                chunks[sent["offsetStart"] : sent["offsetEnd"]] = sent
+        cstart = 0
+        cend = 0
+        sstart = 0
+        while cend < len(text):
+            ranges = chunks.get_range(cstart, cstart + chunk_size)
+            if ranges.start is None or ranges.end is None:
+                break
+            send = sstart + len(ranges)
+            first_sent = ranges[ranges.start]
+            last_sent = ranges[ranges.end - 1]
+            if first_sent is not None and "offsetStart" in first_sent:
+                cstart = first_sent["offsetStart"]
+                if last_sent is not None and "offsetEnd" in last_sent:
+                    cend = last_sent["offsetEnd"]
+                    yield (cstart, cend, sstart, send)
+                    cstart = cend
+                    sstart = send
+
+    @staticmethod
+    def chunk_sentences(text: str, sentences: list[dict], chunk_size: int = DEFAULT_CHUNK_SIZE) -> list[tuple]:
+        chunks = list(EntityFishingClient.group_sentences(text, sentences, chunk_size))
+        # If last chunk is too small aggregate it to the previous
+        if len(chunks) > 1 and (chunks[-1][1] - chunks[-1][0]) < chunk_size / 10:
+            last_chunk = chunks.pop()
+            chunks[-1] = (chunks[-1][0], last_chunk[1], chunks[-1][2], last_chunk[3])
+        return chunks
+
+    def disamb_query_chunks(self, text: str, lang: str, minSelectorScore: float, maxTermFrequency: float | None, sents: tuple, short_text: bool = False) -> list:
+        sentences = [{"offsetStart": s[0], "offsetEnd": s[1]} for s in sents]
+        if self.chunk_size < 0:
+            return self.disamb_query(text, lang, minSelectorScore, maxTermFrequency, sents, short_text)
+
+        start = time.time()
+        text = text.replace("\r\n", " \n")
+        entities = []
+        chunks = self.chunk_sentences(text, sentences, self.chunk_size)
+        futures = []
+        cstarts = {}
+        for cstart, cend, sstart, send in chunks:
+            ctext = text[cstart:cend]
+            cid = int(hashlib.md5(ctext.encode("utf-8")).hexdigest(), 16)
+            csentences = [{"offsetStart": s["offsetStart"] - cstart, "offsetEnd": s["offsetEnd"] - cstart} for s in sentences[sstart:send]]
+            disamb_query = self._build_disamb_query(ctext, csentences, lang, minSelectorScore, maxTermFrequency, short_text)
+            cstarts[cid] = cstart
+            futures.append(self.fdsession.post(self.base_url + self.disamb_url, json=disamb_query, timeout=(30, 300)))
+
+        for future in as_completed(futures):
+            try:
+                resp = future.result()
+                if resp.ok:
+                    result = resp.json()
+                    rtext = result["shortText"] if short_text else result["text"]
+                    cid = int(hashlib.md5(rtext.encode("utf-8")).hexdigest(), 16)
+                    cstart = cstarts[cid]
+                    ents = result.get("entities", [])
+                    for ent in ents:
+                        ent["offsetStart"] += cstart
+                        ent["offsetEnd"] += cstart
+                    entities.extend(ents)
+                else:
+                    resp.raise_for_status()
+            except Exception:
+                logging.warning("An exception was thrown!", exc_info=True)
+        duration = time.time() - start
+        logger.debug("EF disamb duration with %d chunks %0.3fs", len(chunks), duration)
+        return entities
+
+    def get_kb_concept(self, qid: str) -> dict:
+        try:
+            resp = self.ksession.get(self.base_url + self.kb_url + qid)
+            if resp.ok:
+                return resp.json()
+            else:
+                resp.raise_for_status()
+        except Exception:
+            logging.warning("An exception was thrown!", exc_info=True)
+        return {}
+
+    def get_kb_concepts(self, qids: Iterable[str]) -> dict:
+        qids = list(qids)
+        start = time.time()
+        futures = [self.fksession.get(self.base_url + self.kb_url + qid) for qid in qids]
+        concepts = dict.fromkeys(qids)
+        for future in as_completed(futures):
+            try:
+                resp = future.result()
+                if resp.ok:
+                    concept = resp.json()
+                    if "wikidataId" in concept:
+                        concepts[concept["wikidataId"]] = concept
+                else:
+                    resp.raise_for_status()
+            except Exception:
+                logging.warning("An exception was thrown!", exc_info=True)
+        duration = time.time() - start
+        logger.debug("EF get kb %d concepts duration %0.3fs", len(qids), duration)
+        return concepts

pyannotators_entityfishing/entityfishing.py

@@ -0,0 +1,347 @@
+import json
+import logging
+import os
+import time
+from collections import defaultdict
+from collections.abc import Iterable
+from typing import cast
+
+import mongoquery
+from collections_extended import RangeMap
+from pydantic import BaseModel, Field
+from pymultirole_plugins.util import comma_separated_to_list
+from pymultirole_plugins.v1.annotator import AnnotatorBase, AnnotatorParameters
+from pymultirole_plugins.v1.schema import Annotation, Document, Term
+
+from pyannotators_entityfishing.ef_client import EntityFishingClient
+
+logger = logging.getLogger("ef-annotator")
+
+SUPPORTED_LANGUAGES = "en,fr,de,es,it,pt,ar,fa,ja,zh,ru,uk,sv,bn,hi,ko,nl,pl"
+
+
+class EntityFishingParameters(AnnotatorParameters):
+    ef_uri: str = Field(
+        os.getenv("APP_EF_URI", "https://sherpa-entityfishing.kairntech.com"),
+        description="Base URL of the entity-fishing service",
+        json_schema_extra={"extra": "advanced"},
+    )
+    ef_pool_size: int = Field(
+        8,
+        description="Number of parallel HTTP connections to entity-fishing",
+        json_schema_extra={"extra": "advanced"},
+    )
+    ef_full: bool = Field(
+        False,
+        description="Request full concept data from entity-fishing (avoids separate KB lookups)",
+        json_schema_extra={"extra": "advanced"},
+    )
+    minSelectorScore: float = Field(
+        0.3,
+        description="Minimum selector threshold to retain a concept",
+    )
+    maxTermFrequency: float | None = Field(
+        None,
+        description="""Maximum term frequency above which terms are skipped.<br/>
+        Expressed as Zipf (typically 0-8). Lower values speed up processing but may miss entities.""",
+    )
+    mapped_labels: dict[str, str] | None = Field(
+        None,
+        description="Mapping from label name to a JSON mongo-query expression matching Wikidata concept properties",
+        json_schema_extra={"extra": "key:label,val:json"},
+    )
+    default_label: str | None = Field(
+        None,
+        description="Default label for unmapped concepts (if None, unmapped concepts are ignored)",
+        json_schema_extra={"extra": "label"},
+    )
+    output_labels: list[str] | None = Field(
+        None,
+        description="Subset of labels to keep in the output",
+        json_schema_extra={"extra": "label"},
+    )
+    noun_forms_only: bool = Field(
+        False,
+        description="Filter out terms that do not include at least one noun or proper name (requires spacy)",
+        json_schema_extra={"extra": "advanced"},
+    )
+    fingerprint: str | None = Field(
+        None,
+        description="Comma-separated list of Wikidata properties to consider for the fingerprint",
+        json_schema_extra={"extra": "advanced"},
+    )
+    wikidata_properties: str | None = Field(
+        None,
+        description="Comma-separated list of Wikidata properties to retrieve",
+        json_schema_extra={"extra": "advanced"},
+    )
+    do_chunking: bool = Field(
+        False,
+        description="Split input document into chunks and process them in parallel",
+        json_schema_extra={"extra": "advanced"},
+    )
+    short_text: bool = Field(
+        False,
+        description="Use short-text disambiguation mode (for search queries or titles)",
+        json_schema_extra={"extra": "advanced"},
+    )
+    multivalued_props: bool = Field(
+        False,
+        description="Use all property values in fingerprint (default keeps only one)",
+        json_schema_extra={"extra": "advanced"},
+    )
+
+
+def _get_spacy_tagger(lang: str):
+    """Lazily load a spacy model for POS tagging."""
+    try:
+        import spacy
+    except ImportError as e:
+        raise ImportError("spacy is required when noun_forms_only=True. Install with: pip install spacy") from e
+
+    model_map = {
+        "en": "en_core_web_sm",
+        "fr": "fr_core_news_sm",
+        "de": "de_core_news_sm",
+        "es": "es_core_news_sm",
+        "it": "it_core_news_sm",
+        "pt": "pt_core_news_sm",
+        "nl": "nl_core_news_sm",
+        "zh": "zh_core_web_sm",
+        "ja": "ja_core_news_sm",
+        "ru": "ru_core_news_sm",
+        "pl": "pl_core_news_sm",
+    }
+    model_name = model_map.get(lang)
+    if model_name is None:
+        raise ValueError(f"No spacy model configured for language '{lang}'. Disable noun_forms_only or add a model mapping.")
+    try:
+        return spacy.load(model_name, disable=["parser", "ner", "lemmatizer"])
+    except OSError as e:
+        raise OSError(f"Spacy model '{model_name}' not found. Install with: python -m spacy download {model_name}") from e
+
+
+def _document_language(doc: Document, default: str | None = None) -> str | None:
+    if doc.metadata is not None and "language" in doc.metadata:
+        return doc.metadata["language"]
+    return default
+
+
+def _filter_annotations(annotations: Iterable[Annotation], longest_match: bool = True) -> list[Annotation]:
+    """Filter annotations and remove overlaps. Longest span wins."""
+    if not longest_match:
+        return list(annotations)
+
+    sorted_annotations = sorted(annotations, key=lambda ann: (ann.end - ann.start, -ann.start), reverse=True)
+    result = []
+    seen_offsets = RangeMap()
+    for ann in sorted_annotations:
+        if seen_offsets.get(ann.start) is None and seen_offsets.get(ann.end - 1) is None:
+            result.append(ann)
+            seen_offsets[ann.start : ann.end] = ann
+    return sorted(result, key=lambda ann: ann.start)
+
+
+def _enrich_concepts_with_properties(concepts: dict, wiki_props: list[str], multivalued_props: bool = False):  # noqa: ARG001
+    """Enrich concept dicts with extracted wikidata_properties."""
+    for concept in concepts.values():
+        if concept is not None and "statements" in concept:
+            fingerprint = defaultdict(list)
+            for wp in wiki_props:
+                fingerprint[wp] = []
+            for st in concept["statements"]:
+                if st["propertyId"] in wiki_props:
+                    fingerprint[st["propertyId"]].append(st["value"])
+            if sum(len(v) for v in fingerprint.values()) > 0:
+                concept["wikidata_properties"] = dict(fingerprint)
+
+
+def _map_concepts_to_labels(concepts: dict, mapping: dict) -> dict:
+    """Apply mongoquery mappings to assign labels to wikidata concepts."""
+    mapped = {}
+    for key, condition in mapping.items():
+        query = mongoquery.Query(condition)
+        for qid, concept in concepts.items():
+            if concept is not None and query.match(concept):
+                mapped[qid] = key
+    return mapped
+
+
+def _build_annotation(entity: dict, label: str, concept: dict | None, lang: str, fingerprints: list[str], wikidata_properties: list[str], multivalued_props: bool) -> Annotation:
+    """Build an Annotation from an entity-fishing entity and its resolved concept."""
+    qid = entity["wikidataId"]
+    ann_term = Term(
+        identifier=qid,
+        lexicon="wikidata",
+        score=entity.get("confidence_score", 1.0),
+        properties={},
+    )
+    ann_term.properties["wikidataId"] = qid
+
+    if concept and "wikidata_properties" in concept:
+        if fingerprints:
+            fp_parts = []
+            for f in fingerprints:
+                fvals = concept["wikidata_properties"].get(f, [])
+                if fvals:
+                    fingers = [f"{f}:{v}" for v in sorted(fvals) if isinstance(v, str)]
+                    if multivalued_props:
+                        fp_parts.extend(fingers)
+                    elif fingers:
+                        fp_parts.append(fingers[0])
+            ann_term.properties["fingerprint"] = ",".join(fp_parts)
+        if wikidata_properties:
+            for wp in wikidata_properties:
+                fvals = concept["wikidata_properties"].get(wp, [])
+                if len(fvals) == 1:
+                    ann_term.properties[wp] = fvals[0]
+                elif len(fvals) > 1:
+                    ann_term.properties[wp] = fvals
+
+    # Preferred form: use multilingual term for the document language, else preferredTerm, else rawName
+    if "rawName" in entity:
+        ann_term.preferredForm = entity["rawName"]
+    if concept:
+        if "preferredTerm" in concept:
+            ann_term.preferredForm = concept["preferredTerm"]
+        if "multilingual" in concept:
+            multi_terms = {m["lang"]: m["term"] for m in concept["multilingual"]}
+            if lang in multi_terms:
+                ann_term.preferredForm = multi_terms[lang]
+    if "wikipediaExternalRef" in entity:
+        ann_term.properties["wikipediaExternalRef"] = str(entity["wikipediaExternalRef"])
+
+    return Annotation(
+        start=entity["offsetStart"],
+        end=entity["offsetEnd"],
+        labelName=label,
+        score=entity.get("confidence_score", 1.0),
+        terms=[ann_term],
+        properties=None,
+    )
+
+
+def _check_noun_form(spacy_doc, entity: dict) -> bool:
+    """Check if the entity span contains at least one noun or proper noun."""
+    from spacy.parts_of_speech import NOUN, NUM, PROPN, PUNCT
+
+    span = spacy_doc.char_span(entity["offsetStart"], entity["offsetEnd"])
+    if span is None:
+        return False
+    pos_set = {PUNCT if t.is_punct else NUM if t.is_digit else t.pos for t in span}
+    return bool(pos_set.intersection({NOUN, PROPN}))
+
+
+class EntityFishingAnnotator(AnnotatorBase):
+    __doc__ = (
+        """[entity-fishing](https://github.com/kermitt2/entity-fishing) annotator for named entity recognition and disambiguation against Wikidata.
+    #need-segments
+    #languages:"""
+        + SUPPORTED_LANGUAGES
+    )
+
+    def annotate(self, documents: list[Document], parameters: AnnotatorParameters) -> list[Document]:
+        params: EntityFishingParameters = cast(EntityFishingParameters, parameters)
+
+        supported_languages = comma_separated_to_list(SUPPORTED_LANGUAGES)
+
+        # Parse parameters
+        mapping = {k: json.loads(v) for k, v in params.mapped_labels.items()} if params.mapped_labels else {}
+        fingerprints = comma_separated_to_list(params.fingerprint)
+        wp_list = comma_separated_to_list(params.wikidata_properties)
+        wiki_props = fingerprints + wp_list
+        do_chunking = params.do_chunking and not params.short_text
+        noun_forms_only = params.noun_forms_only
+
+        # Build the set of valid output classes
+        classes = list(mapping.keys())
+        if params.default_label:
+            classes.append(params.default_label)
+        if params.output_labels:
+            classes = [c for c in classes if c in params.output_labels]
+
+        if not classes:
+            # Nothing to produce: return documents untouched
+            return documents
+
+        # Create client
+        client = EntityFishingClient(
+            base_url=params.ef_uri,
+            pool_size=params.ef_pool_size,
+            full=params.ef_full,
+        )
+
+        # Validate languages
+        langs = []
+        for doc in documents:
+            lang = _document_language(doc)
+            if lang is None or lang not in supported_languages:
+                raise AttributeError(f"Metadata language '{lang}' is required and must be in {SUPPORTED_LANGUAGES}")
+            langs.append(lang)
+
+        # Load spacy taggers if needed
+        spacy_docs = None
+        if noun_forms_only:
+            spacy_docs = []
+            for doc, lang in zip(documents, langs, strict=True):
+                tagger = _get_spacy_tagger(lang)
+                spacy_docs.append(tagger(doc.text))
+
+        # Disambiguate: parallel batch if multiple docs, else single-doc (with optional chunking)
+        if len(documents) > 1 and not do_chunking:
+            all_results = client.disamb_queries(documents, langs, params.minSelectorScore, params.maxTermFrequency, params.short_text)
+        else:
+            all_results = []
+            for doc, lang in zip(documents, langs, strict=True):
+                sents = tuple((s.start, s.end) for s in doc.sentences) if doc.sentences else ((0, len(doc.text)),)
+                if do_chunking:
+                    result = client.disamb_query_chunks(doc.text, lang, params.minSelectorScore, params.maxTermFrequency, sents, params.short_text)
+                else:
+                    result = client.disamb_query(doc.text, lang, params.minSelectorScore, params.maxTermFrequency, sents, params.short_text)
+                all_results.append(result)
+
+        # Process results for each document
+        for doc_idx, (doc, lang, result) in enumerate(zip(documents, langs, all_results, strict=True)):
+            start = time.time()
+            entities = [e for e in result if "wikidataId" in e]
+
+            # Resolve concepts
+            if params.ef_full:
+                concepts = {e["wikidataId"]: e for e in entities}
+            else:
+                qids = {e["wikidataId"] for e in entities}
+                concepts = client.get_kb_concepts(qids) if qids else {}
+
+            # Enrich with wikidata properties
+            if wiki_props:
+                _enrich_concepts_with_properties(concepts, wiki_props, params.multivalued_props)
+
+            # Map concepts to labels
+            mapped_concepts = _map_concepts_to_labels(concepts, mapping)
+
+            # Build annotations
+            spacy_doc = spacy_docs[doc_idx] if spacy_docs else None
+            anns = []
+            for entity in entities:
+                qid = entity["wikidataId"]
+                label = mapped_concepts.get(qid, params.default_label)
+                if not label or label not in classes:
+                    continue
+                concept = concepts.get(qid)
+
+                # Noun form filtering
+                if spacy_doc and noun_forms_only and not _check_noun_form(spacy_doc, entity):
+                    continue
+
+                ann = _build_annotation(entity, label, concept, lang, fingerprints, wp_list, params.multivalued_props)
+                anns.append(ann)
+
+            doc.annotations = _filter_annotations(anns)
+            duration = time.time() - start
+            logger.debug("EF annotator doc %d chars done in %0.3fs", len(doc.text), duration)
+
+        return documents
+
+    @classmethod
+    def get_model(cls) -> type[BaseModel]:
+        return EntityFishingParameters

pyannotators_entityfishing-0.6.3.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: pyannotators-entityfishing
+Version: 0.6.3
+Summary: Annotator based on entity-fishing
+Project-URL: Homepage, https://github.com/oterrier/pyannotators_entityfishing/
+Author-email: Olivier Terrier <olivier.terrier@kairntech.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: collections-extended
+Requires-Dist: mongoquery
+Requires-Dist: pydantic<3.0,>=2.0
+Requires-Dist: pymultirole-plugins<0.7.0,>=0.6.0
+Requires-Dist: python-singleton-metaclasses
+Requires-Dist: requests
+Requires-Dist: requests-cache
+Requires-Dist: requests-futures
+Provides-Extra: dev
+Requires-Dist: bump2version; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: jupyter-sphinx; extra == 'docs'
+Requires-Dist: lxml-html-clean; extra == 'docs'
+Requires-Dist: m2r2; extra == 'docs'
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme; extra == 'docs'
+Requires-Dist: sphinxcontrib-apidoc; extra == 'docs'
+Provides-Extra: spacy
+Requires-Dist: spacy>=3.0; extra == 'spacy'
+Provides-Extra: test
+Requires-Dist: dirty-equals; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pyannotators-entityfishing
+
+Annotator based on [entity-fishing](https://github.com/kermitt2/entity-fishing) for named entity recognition and disambiguation against Wikidata.
+
+## Installation
+
+```bash
+pip install pyannotators-entityfishing
+```
+
+For noun-form filtering (optional):
+
+```bash
+pip install pyannotators-entityfishing[spacy]
+python -m spacy download en_core_web_sm  # or other language models
+```
+
+## Usage
+
+```python
+from pymultirole_plugins.v1.schema import Document
+from pyannotators_entityfishing.entityfishing import EntityFishingAnnotator, EntityFishingParameters
+
+annotator = EntityFishingAnnotator()
+parameters = EntityFishingParameters(
+    default_label="ENTITY",
+    minSelectorScore=0.3,
+)
+
+docs = annotator.annotate(
+    [Document(text="Albert Einstein was born in Ulm.", metadata={"language": "en"})],
+    parameters,
+)
+
+for ann in docs[0].annotations:
+    print(f"{ann.start}:{ann.end} {ann.labelName} {ann.terms[0].identifier}")
+```
+
+## Development
+
+Install test dependencies:
+
+```bash
+uv pip install -e ".[test]"
+```
+
+### Linting
+
+```bash
+uv run ruff check src/ tests/
+uv run ruff format --check src/ tests/
+```
+
+### Testing
+
+```bash
+uv run pytest
+```
+
+### Coverage
+
+```bash
+uv run pytest --cov=src --cov-report=term-missing
+```

pyannotators_entityfishing-0.6.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyannotators_entityfishing/__init__.py,sha256=y0SVZb5M4ba_bmzuoYxi0ElC6IjH9BvSj_NWoj_Oozo,63
+pyannotators_entityfishing/ef_client.py,sha256=PsefEjekG5znoHlgIOU42BA_QfUeIrAV3VuvR9B_j5g,10780
+pyannotators_entityfishing/entityfishing.py,sha256=r3sDDnQl9tl71-wBOdilHSnIDqyO5zM4c0gncz_uhWo,14139
+pyannotators_entityfishing-0.6.3.dist-info/METADATA,sha256=k3TOmdvP12NAnoyc6979Y6j96fQSP8fux_-RXVNbgUQ,3114
+pyannotators_entityfishing-0.6.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pyannotators_entityfishing-0.6.3.dist-info/entry_points.txt,sha256=cvNE5rkDk8lFjc-nvac1AJpC47ua8yxfXgswkZ5cAh8,103
+pyannotators_entityfishing-0.6.3.dist-info/RECORD,,

pyannotators_entityfishing-0.6.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyannotators_entityfishing-0.6.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pyannotators.plugins]
+entityfishing = pyannotators_entityfishing.entityfishing:EntityFishingAnnotator