cxrfescore 0.2.2__py3-none-any.whl

cxrfescore/__init__.py

@@ -0,0 +1,7 @@
+"""CXRFEScore: fact-level embedding metric for chest X-ray report evaluation."""
+
+from cxrfescore.cache_utils import inspect_cache
+from cxrfescore.metric import CXRFEScore
+
+__all__ = ["CXRFEScore", "inspect_cache"]
+__version__ = "0.2.2"

cxrfescore/cache_utils.py

@@ -0,0 +1,129 @@
+"""Helpers for inspecting CXRFEScore on-disk caches."""
+
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from cxrfescore.metric import DEFAULT_CACHE_DIR
+
+
+def _format_size(num_bytes: int) -> str:
+    if num_bytes < 1024:
+        return f"{num_bytes} B"
+    if num_bytes < 1024**2:
+        return f"{num_bytes / 1024:.2f} KB"
+    if num_bytes < 1024**3:
+        return f"{num_bytes / 1024**2:.2f} MB"
+    return f"{num_bytes / 1024**3:.2f} GB"
+
+
+def _sample_entry(key: Any, value: Any) -> Dict[str, Any]:
+    sample: Dict[str, Any] = {"key": key}
+    if hasattr(value, "shape"):
+        sample["value_kind"] = "array"
+        sample["shape"] = tuple(value.shape)
+        sample["dtype"] = str(getattr(value, "dtype", ""))
+    else:
+        sample["value_kind"] = type(value).__name__
+        value_repr = repr(value)
+        if len(value_repr) > 120:
+            value_repr = value_repr[:120] + "..."
+        sample["value_repr"] = value_repr
+    return sample
+
+
+def inspect_cache(
+    cache_dir: Optional[Union[str, Path]] = None,
+    max_samples: int = 5,
+    *,
+    print_report: bool = True,
+) -> Dict[str, Any]:
+    """
+    Inspect CXRFEScore cache pickle files under ``cache_dir``.
+
+    Looks for ``*.pkl`` recursively (sentence→facts at the root and
+    fact→embedding files under ``embeddings/<encoder>/``).
+
+    Args:
+        cache_dir: Base cache directory. Defaults to the platform user cache
+            dir for ``cxrfescore`` (same default as ``CXRFEScore``).
+        max_samples: How many key/value samples to show per file.
+        print_report: If True, print a human-readable report.
+
+    Returns:
+        A summary dict with ``cache_dir``, ``exists``, and a ``files`` list.
+    """
+    root = Path(cache_dir) if cache_dir is not None else Path(DEFAULT_CACHE_DIR)
+    summary: Dict[str, Any] = {
+        "cache_dir": str(root),
+        "exists": root.exists(),
+        "files": [],
+    }
+
+    if print_report:
+        print("=" * 60)
+        print(f"CXRFEScore cache: {root}")
+        print("=" * 60)
+
+    if not root.exists():
+        if print_report:
+            print("Cache directory does not exist yet.")
+        return summary
+
+    pkl_paths = sorted(root.rglob("*.pkl"))
+    if not pkl_paths:
+        if print_report:
+            print("No .pkl cache files found.")
+        return summary
+
+    for path in pkl_paths:
+        rel = str(path.relative_to(root))
+        file_info: Dict[str, Any] = {
+            "path": str(path),
+            "relative_path": rel,
+            "size_bytes": path.stat().st_size,
+            "size_human": _format_size(path.stat().st_size),
+            "entries": None,
+            "error": None,
+            "samples": [],
+        }
+
+        if print_report:
+            print(f"\n--- {rel} ({file_info['size_human']}) ---")
+
+        try:
+            with open(path, "rb") as f:
+                data = pickle.load(f)
+            if not isinstance(data, dict):
+                file_info["error"] = f"expected dict, got {type(data).__name__}"
+                if print_report:
+                    print(f"Unexpected type: {type(data).__name__}")
+            else:
+                file_info["entries"] = len(data)
+                keys = list(data.keys())[:max_samples]
+                for key in keys:
+                    file_info["samples"].append(_sample_entry(key, data[key]))
+                if print_report:
+                    print(f"entries: {len(data)}")
+                    for sample in file_info["samples"]:
+                        if sample["value_kind"] == "array":
+                            print(
+                                f"  {sample['key']!r} -> array "
+                                f"shape={sample['shape']} dtype={sample['dtype']}"
+                            )
+                        else:
+                            print(f"  {sample['key']!r} -> {sample['value_repr']}")
+                    if len(data) > max_samples:
+                        print(f"  ... ({len(data) - max_samples} more)")
+        except Exception as e:
+            file_info["error"] = str(e)
+            if print_report:
+                print(f"failed to load: {e}")
+
+        summary["files"].append(file_info)
+
+    if print_report:
+        print()
+    return summary

cxrfescore/metric.py

@@ -0,0 +1,864 @@
+"""CXRFEScore metric implementation."""
+
+from __future__ import annotations
+
+import logging
+import os
+import pickle
+import textwrap
+from typing import Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+from nltk.tokenize import sent_tokenize
+from platformdirs import user_cache_dir
+from sklearn.metrics.pairwise import cosine_similarity
+from torch.utils.data import DataLoader, Dataset
+from tqdm import tqdm
+from transformers import (
+    AutoModel,
+    AutoTokenizer,
+    BertForSequenceClassification,
+    BertTokenizer,
+    T5ForConditionalGeneration,
+    T5TokenizerFast,
+)
+
+from cxrfescore.nltk_setup import ensure_nltk_resources
+from cxrfescore.text_utils import parse_facts, remove_consecutive_repeated_words_from_text
+
+logger = logging.getLogger(__name__)
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+DEFAULT_CACHE_DIR = user_cache_dir("cxrfescore")
+
+# SRR-BERT-Leaves uses a classification head; we only use BERT CLS embeddings.
+SRR_BERT_LEAVES_NUM_LABELS = 55
+SRR_BERT_LEAVES_TOKENIZER = "microsoft/BiomedVLP-CXR-BERT-general"
+SRR_BERT_LEAVES_MAX_LENGTH = 128
+
+
+def _safe_model_dirname(model_name: str) -> str:
+    """Filesystem-safe directory name for a Hugging Face model id."""
+    return model_name.replace("/", "__")
+
+class TextDataset(Dataset):
+    def __init__(self, texts):
+        self.texts = texts
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, i):
+        return self.texts[i]
+
+
+def get_text_collate_batch_fn(tokenizer_func):
+    def collate_batch_fn(batch):
+        encoding = tokenizer_func(batch)
+        return {"encoding": encoding}
+
+    return collate_batch_fn
+
+
+def create_text_dataset_and_dataloader(texts, batch_size, num_workers, tokenizer_func):
+    collate_batch_fn = get_text_collate_batch_fn(tokenizer_func)
+    dataset = TextDataset(texts)
+    dataloader = DataLoader(
+        dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=num_workers,
+        collate_fn=collate_batch_fn,
+        pin_memory=True,
+    )
+    return dataset, dataloader
+
+
+class CXRFEScore:
+    """
+    Fact-level cosine similarity between radiology reports using a T5 fact
+    extractor and CXR-BERT / CXRFE embeddings.
+
+    Steps:
+    1. Split hypothesis and reference reports into sentences.
+    2. Extract facts with a T5 fact extractor.
+    3. Embed unique facts with a CXR-BERT-style encoder.
+    4. For each pair, compute soft bipartite matching as the average of
+       mean row-wise and mean column-wise maximum cosine similarities.
+    """
+
+    SUPPORTED_MODELS = [
+        "pamessina/CXRFE",
+        "microsoft/BiomedVLP-CXR-BERT-specialized",
+        "microsoft/BiomedVLP-BioViL-T",
+        "StanfordAIMI/SRR-BERT-Leaves",
+    ]
+
+    MODEL_EMBEDDING_DIMENSIONS = {
+        "pamessina/CXRFE": 128,
+        "microsoft/BiomedVLP-CXR-BERT-specialized": 128,
+        "microsoft/BiomedVLP-BioViL-T": 128,
+        "StanfordAIMI/SRR-BERT-Leaves": 768,
+    }
+
+    # projected: get_projected_text_embeddings (CXRFE / CXR-BERT family)
+    # cls: BERT CLS token from BertForSequenceClassification.bert
+    ENCODER_BACKEND = {
+        "pamessina/CXRFE": "projected",
+        "microsoft/BiomedVLP-CXR-BERT-specialized": "projected",
+        "microsoft/BiomedVLP-BioViL-T": "projected",
+        "StanfordAIMI/SRR-BERT-Leaves": "cls",
+    }
+
+    def __init__(
+        self,
+        encoder_model_name: str = "pamessina/CXRFE",
+        extractor_model_name: str = "pamessina/T5FactExtractor",
+        device: Optional[str] = None,
+        batch_size: int = 128,
+        num_workers: int = 3,
+        verbose: bool = False,
+        use_cache: bool = True,
+        cache_dir: Optional[str] = None,
+    ):
+        """
+        Initialize the CXRFEScore metric.
+
+        Args:
+            encoder_model_name: Hugging Face encoder. Must be one of
+                ``SUPPORTED_MODELS``.
+            extractor_model_name: Hugging Face T5 fact extractor.
+            device: Device string (``'cuda'``, ``'cpu'``). Auto-detected if None.
+            batch_size: Default batch size for fact extraction / embeddings.
+            num_workers: DataLoader workers for fact extraction.
+            verbose: Enable logging and progress bars.
+            use_cache: Enable in-memory caching for facts/embeddings. Disk
+                persistence is **manual** via ``save_cache()`` (not automatic
+                after every batch).
+            cache_dir: Base cache directory. Defaults to the platform user
+                cache dir for ``cxrfescore``. Sentence→facts live under this
+                directory; fact embeddings live under
+                ``cache_dir/embeddings/<encoder_model_name>/`` so encoders
+                do not share embedding caches.
+        """
+        if encoder_model_name not in self.SUPPORTED_MODELS:
+            raise ValueError(
+                f"Unsupported model name: {encoder_model_name}. "
+                f"Please choose from: {self.SUPPORTED_MODELS}"
+            )
+
+        if cache_dir is None:
+            cache_dir = DEFAULT_CACHE_DIR
+
+        if use_cache and cache_dir is None:
+            raise ValueError("cache_dir must be provided if use_cache is True.")
+
+        ensure_nltk_resources()
+
+        self.device = (
+            torch.device(device)
+            if device
+            else torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        )
+        self.encoder_model_name = encoder_model_name
+        self.extractor_model_name = extractor_model_name
+        self.encoder_backend = self.ENCODER_BACKEND[encoder_model_name]
+        self.encoder_max_length = (
+            SRR_BERT_LEAVES_MAX_LENGTH if self.encoder_backend == "cls" else None
+        )
+        self.default_batch_size = batch_size
+        self.default_num_workers = num_workers
+        self.verbose = verbose
+        self.use_cache = use_cache
+        self.cache_dir = cache_dir
+        self.facts_cache_dir = cache_dir
+        self.embed_cache_dir = os.path.join(
+            cache_dir, "embeddings", _safe_model_dirname(encoder_model_name)
+        )
+        self.embedding_dimension = self.MODEL_EMBEDDING_DIMENSIONS[
+            self.encoder_model_name
+        ]
+        self.sent_to_facts_cache = {}
+        self.fact_to_embedding_cache = {}
+        if self.use_cache:
+            self._load_cache()
+
+        if self.verbose:
+            logger.info(
+                f"Initializing CXRFEScore with encoder model: {self.encoder_model_name} and"
+                f" extractor model: {self.extractor_model_name}, use_cache: {self.use_cache},"
+                f" cache_dir: {self.cache_dir}, embed_cache_dir: {self.embed_cache_dir},"
+                f" default batch size: {self.default_batch_size},"
+                f" default num workers: {self.default_num_workers}."
+            )
+            logger.info(f"Using device: {self.device}")
+
+        self._load_encoder()
+
+        self.extractor_tokenizer = T5TokenizerFast.from_pretrained(
+            extractor_model_name
+        )
+        self.extractor_model = T5ForConditionalGeneration.from_pretrained(
+            extractor_model_name
+        )
+        self.extractor_model.to(self.device)
+        self.extractor_model.eval()
+
+    def _load_encoder(self):
+        """Load the configured fact encoder and its tokenizer."""
+        if self.encoder_backend == "projected":
+            self.encoder_tokenizer = AutoTokenizer.from_pretrained(
+                self.encoder_model_name, trust_remote_code=True
+            )
+            self.encoder_model = AutoModel.from_pretrained(
+                self.encoder_model_name, trust_remote_code=True
+            )
+            self.encoder_model.to(self.device)
+            self.encoder_model.eval()
+            return
+
+        if self.encoder_backend == "cls":
+            # Classification weights are unused; we only read BERT CLS states.
+            self.encoder_tokenizer = BertTokenizer.from_pretrained(
+                SRR_BERT_LEAVES_TOKENIZER
+            )
+            self.encoder_model = BertForSequenceClassification.from_pretrained(
+                self.encoder_model_name, num_labels=SRR_BERT_LEAVES_NUM_LABELS
+            )
+            self.encoder_model.to(self.device)
+            self.encoder_model.eval()
+            return
+
+        raise ValueError(f"Unknown encoder_backend: {self.encoder_backend}")
+
+    def _load_cache(self):
+        """Load fact and embedding caches from disk if they exist."""
+        facts_cache_path = os.path.join(self.facts_cache_dir, "sent_to_facts.pkl")
+        embed_cache_path = os.path.join(
+            self.embed_cache_dir, "fact_to_embedding.pkl"
+        )
+
+        if os.path.exists(facts_cache_path):
+            try:
+                with open(facts_cache_path, "rb") as f:
+                    self.sent_to_facts_cache = pickle.load(f)
+                if self.verbose:
+                    logger.info(
+                        f"Loaded {len(self.sent_to_facts_cache)} sentence-to-fact "
+                        f"mappings from {facts_cache_path}."
+                    )
+            except (pickle.UnpicklingError, EOFError):
+                logger.warning(
+                    f"Could not load sentence-to-fact mappings from {facts_cache_path}. "
+                    "Starting with an empty cache."
+                )
+
+        if os.path.exists(embed_cache_path):
+            try:
+                with open(embed_cache_path, "rb") as f:
+                    self.fact_to_embedding_cache = pickle.load(f)
+                if self.verbose:
+                    logger.info(
+                        f"Loaded {len(self.fact_to_embedding_cache)} fact embeddings "
+                        f"from {embed_cache_path}."
+                    )
+            except (pickle.UnpicklingError, EOFError):
+                logger.warning(
+                    f"Could not load fact embeddings from {embed_cache_path}. "
+                    "Starting with an empty cache."
+                )
+
+    def _save_cache_file(self, data: dict, directory: str, filename: str):
+        """Atomically save a cache dictionary to a pickle file."""
+        if not self.use_cache:
+            return
+
+        os.makedirs(directory, exist_ok=True)
+
+        final_path = os.path.join(directory, filename)
+        temp_path = final_path + ".tmp"
+
+        try:
+            with open(temp_path, "wb") as f:
+                pickle.dump(data, f)
+            os.replace(temp_path, final_path)
+            if self.verbose:
+                logger.info(f"Saved {len(data)} entries to {final_path}.")
+        except Exception as e:
+            logger.error(f"Failed to save cache to {final_path}: {e}")
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+
+    def _save_sent_to_facts_cache(self):
+        self._save_cache_file(
+            self.sent_to_facts_cache, self.facts_cache_dir, "sent_to_facts.pkl"
+        )
+
+    def _save_fact_to_embedding_cache(self):
+        self._save_cache_file(
+            self.fact_to_embedding_cache,
+            self.embed_cache_dir,
+            "fact_to_embedding.pkl",
+        )
+
+    def save_cache(self):
+        """
+        Persist in-memory caches to disk.
+
+        Call this explicitly after scoring a large batch (or at the end of a
+        job). Caches are updated in memory during ``compute`` /
+        ``extract_facts`` / ``embed_facts``, but are **not** written to disk
+        automatically.
+        """
+        self._save_sent_to_facts_cache()
+        self._save_fact_to_embedding_cache()
+
+    def inspect_cache(self, max_samples: int = 5, *, print_report: bool = True):
+        """Inspect on-disk caches for this metric's ``cache_dir``."""
+        from cxrfescore.cache_utils import inspect_cache
+
+        return inspect_cache(
+            self.cache_dir, max_samples=max_samples, print_report=print_report
+        )
+
+    @staticmethod
+    def _aggregate_facts(
+        report_sents: List[str], sent_to_facts_map: Dict[str, List[str]]
+    ) -> List[str]:
+        """Aggregate unique facts from a list of sentences."""
+        report_facts = []
+        seen_facts = set()
+        for sent in report_sents:
+            sent = sent.strip()
+            facts = sent_to_facts_map[sent]
+            if len(facts) == 0 and any(char.isalpha() for char in sent):
+                facts = [sent]
+            for fact in facts:
+                if fact not in seen_facts:
+                    report_facts.append(fact)
+                    seen_facts.add(fact)
+        return report_facts
+
+    def _extract_facts_batch(
+        self,
+        sentences: List[str],
+        batch_size: Optional[int] = None,
+        num_workers: Optional[int] = None,
+    ) -> List[List[str]]:
+        """Extract facts from a batch of sentences using the T5 fact extractor."""
+        if batch_size is None:
+            batch_size = self.default_batch_size
+        if num_workers is None:
+            num_workers = self.default_num_workers
+
+        if self.verbose:
+            logger.info(
+                f"Extracting facts from {len(sentences)} sentences in batches of "
+                f"{batch_size} with {num_workers} workers."
+            )
+
+        if self.use_cache:
+            output = [self.sent_to_facts_cache.get(sent, None) for sent in sentences]
+            missing_indices = [i for i in range(len(sentences)) if output[i] is None]
+            if not missing_indices:
+                if self.verbose:
+                    logger.info(
+                        f"All sentences found in cache. Returning {len(output)} "
+                        "sentences-to-facts mappings."
+                    )
+                return output
+            if self.verbose:
+                logger.info(
+                    f"Cache miss for {len(missing_indices)}/{len(sentences)} sentences."
+                )
+            sentences_to_process = [sentences[i] for i in missing_indices]
+        else:
+            sentences_to_process = sentences
+
+        _, dataloader = create_text_dataset_and_dataloader(
+            texts=sentences_to_process,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            tokenizer_func=lambda x: self.extractor_tokenizer(
+                x, padding="longest", return_tensors="pt"
+            ),
+        )
+
+        new_facts = [None] * len(sentences_to_process)
+        offset = 0
+        with torch.no_grad():
+            iterator = (
+                tqdm(dataloader, total=len(dataloader), mininterval=2)
+                if self.verbose
+                else dataloader
+            )
+            for batch in iterator:
+                encoding = batch["encoding"]
+                input_ids = encoding["input_ids"].to(self.device)
+                attention_mask = encoding["attention_mask"].to(self.device)
+                max_len = input_ids.shape[1] * 4
+                output_ids = self.extractor_model.generate(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    max_new_tokens=max_len,
+                    num_beams=1,
+                )
+                output_texts_batch = self.extractor_tokenizer.batch_decode(
+                    output_ids, skip_special_tokens=True
+                )
+                for i, output_text in enumerate(output_texts_batch):
+                    facts = parse_facts(output_text)
+                    facts = [
+                        remove_consecutive_repeated_words_from_text(f) for f in facts
+                    ]
+                    new_facts[offset + i] = facts
+                offset += len(output_texts_batch)
+        assert offset == len(sentences_to_process)
+        assert None not in new_facts
+
+        if self.use_cache:
+            for i, orig_idx in enumerate(missing_indices):
+                output[orig_idx] = new_facts[i]
+            self.sent_to_facts_cache.update(
+                {
+                    sent: facts
+                    for sent, facts in zip(sentences_to_process, new_facts)
+                }
+            )
+        else:
+            output = new_facts
+        assert None not in output
+        return output
+
+    def _get_embeddings_batch(
+        self,
+        texts: List[str],
+        batch_size: Optional[int] = None,
+    ) -> np.ndarray:
+        """Generate embeddings for a list of texts in batches."""
+        if batch_size is None:
+            batch_size = self.default_batch_size
+
+        if self.verbose:
+            logger.info(
+                f"Generating embeddings for {len(texts)} texts in batches of {batch_size}."
+            )
+
+        if not texts:
+            return np.array([])
+
+        if self.use_cache:
+            text_embeddings = np.empty(
+                (len(texts), self.embedding_dimension), dtype=np.float32
+            )
+            missing_indices = []
+            for i, text in enumerate(texts):
+                embedding = self.fact_to_embedding_cache.get(text, None)
+                if embedding is None:
+                    missing_indices.append(i)
+                else:
+                    text_embeddings[i] = embedding
+            if not missing_indices:
+                if self.verbose:
+                    logger.info(
+                        f"All texts found in cache. Returning {len(text_embeddings)} embeddings."
+                    )
+                return text_embeddings
+            if self.verbose:
+                logger.info(f"Cache miss for {len(missing_indices)} texts.")
+            texts_to_process = [texts[i] for i in missing_indices]
+        else:
+            texts_to_process = texts
+
+        self.encoder_model.eval()
+
+        new_embeddings = []
+        iterator = (
+            tqdm(
+                range(0, len(texts_to_process), batch_size),
+                desc="Generating embeddings",
+            )
+            if self.verbose
+            else range(0, len(texts_to_process), batch_size)
+        )
+
+        with torch.no_grad():
+            for i in iterator:
+                batch_texts = texts_to_process[i : i + batch_size]
+                if self.encoder_backend == "projected":
+                    # Prefer tokenizer __call__ (batch_encode_plus is missing on some
+                    # custom remote-code tokenizers under newer transformers).
+                    inputs = self.encoder_tokenizer(
+                        batch_texts,
+                        add_special_tokens=True,
+                        padding="longest",
+                        return_tensors="pt",
+                    )
+                    input_ids = inputs["input_ids"].to(self.device)
+                    attention_mask = inputs["attention_mask"].to(self.device)
+                    batch_embeddings = self.encoder_model.get_projected_text_embeddings(
+                        input_ids=input_ids, attention_mask=attention_mask
+                    )
+                elif self.encoder_backend == "cls":
+                    inputs = self.encoder_tokenizer(
+                        batch_texts,
+                        padding="longest",
+                        truncation=True,
+                        max_length=self.encoder_max_length,
+                        return_tensors="pt",
+                        return_attention_mask=True,
+                    )
+                    input_ids = inputs["input_ids"].to(self.device)
+                    attention_mask = inputs["attention_mask"].to(self.device)
+                    bert_out = self.encoder_model.bert(
+                        input_ids, attention_mask=attention_mask, return_dict=True
+                    )
+                    batch_embeddings = bert_out.last_hidden_state[:, 0, :]
+                else:
+                    raise ValueError(
+                        f"Unknown encoder_backend: {self.encoder_backend}"
+                    )
+                new_embeddings.append(batch_embeddings.cpu().numpy())
+
+        new_embeddings = np.concatenate(new_embeddings, axis=0)
+
+        if self.use_cache:
+            text_embeddings[missing_indices] = new_embeddings
+            self.fact_to_embedding_cache.update(
+                {
+                    text: embedding
+                    for text, embedding in zip(texts_to_process, new_embeddings)
+                }
+            )
+            return text_embeddings
+        return new_embeddings
+
+    def extract_facts(
+        self,
+        reports: List[str],
+        batch_size: Optional[int] = None,
+        num_workers: Optional[int] = None,
+    ) -> List[List[str]]:
+        """
+        Extract unique facts from full radiology reports.
+
+        Each input string is treated as a **full report** (not a single
+        sentence): it is sentence-split with NLTK, facts are extracted per
+        sentence with the T5 fact extractor, then unique facts are aggregated
+        in report order — the same pipeline used by ``compute``.
+
+        Args:
+            reports: List of full report strings.
+            batch_size: Batch size for the fact extractor.
+            num_workers: DataLoader workers for fact extraction.
+
+        Returns:
+            A list of fact lists, one per input report.
+        """
+        if self.verbose:
+            logger.info(
+                f"extract_facts: treating {len(reports)} inputs as full reports "
+                "(sentence-split → extract → aggregate)."
+            )
+
+        sents_per_report = [sent_tokenize(report) for report in reports]
+
+        all_unique_sents = set()
+        for report_sents in sents_per_report:
+            all_unique_sents.update(s.strip() for s in report_sents if s.strip())
+        all_unique_sents_list = list(all_unique_sents)
+
+        facts_per_unique_sent = self._extract_facts_batch(
+            all_unique_sents_list, batch_size=batch_size, num_workers=num_workers
+        )
+        sent_to_facts = {
+            sent: facts
+            for sent, facts in zip(all_unique_sents_list, facts_per_unique_sent)
+        }
+        return [
+            self._aggregate_facts(sents, sent_to_facts) for sents in sents_per_report
+        ]
+
+    def embed_facts(
+        self,
+        facts: List[str],
+        batch_size: Optional[int] = None,
+    ) -> np.ndarray:
+        """
+        Embed a list of fact strings with the configured encoder.
+
+        Args:
+            facts: Fact strings (already extracted; not full reports).
+            batch_size: Batch size for embedding.
+
+        Returns:
+            Array of shape ``(len(facts), embedding_dimension)``.
+        """
+        return self._get_embeddings_batch(facts, batch_size=batch_size)
+
+    def compute(
+        self,
+        hyps: List[str],
+        refs: List[str],
+        batch_size: Optional[int] = None,
+        num_workers: Optional[int] = None,
+    ) -> Dict[str, Union[float, np.ndarray]]:
+        """
+        Compute fact-level similarity between hypothesis and reference reports.
+
+        Returns:
+            Dict with ``mean_similarity`` and ``per_pair_similarity``.
+        """
+        if len(hyps) != len(refs):
+            raise ValueError(
+                "The number of hypothesis and reference reports must be the same."
+            )
+
+        if self.verbose:
+            logger.info("Splitting reports into sentences...")
+        hyps_sents_per_report = [sent_tokenize(report) for report in hyps]
+        refs_sents_per_report = [sent_tokenize(report) for report in refs]
+
+        all_unique_sents = set()
+        for report_sents in hyps_sents_per_report:
+            all_unique_sents.update(s.strip() for s in report_sents if s.strip())
+        for report_sents in refs_sents_per_report:
+            all_unique_sents.update(s.strip() for s in report_sents if s.strip())
+        all_unique_sents_list = list(all_unique_sents)
+
+        if self.verbose:
+            logger.info(
+                f"Found {len(all_unique_sents_list)} unique sentences. Extracting facts..."
+            )
+
+        facts_per_unique_sent = self._extract_facts_batch(
+            all_unique_sents_list, batch_size=batch_size, num_workers=num_workers
+        )
+        sent_to_facts = {
+            sent: facts
+            for sent, facts in zip(all_unique_sents_list, facts_per_unique_sent)
+        }
+
+        hyps_facts = [
+            self._aggregate_facts(sents, sent_to_facts)
+            for sents in hyps_sents_per_report
+        ]
+        refs_facts = [
+            self._aggregate_facts(sents, sent_to_facts)
+            for sents in refs_sents_per_report
+        ]
+
+        unique_facts = set()
+        for facts in hyps_facts:
+            unique_facts.update(facts)
+        for facts in refs_facts:
+            unique_facts.update(facts)
+        unique_facts = list(unique_facts)
+
+        if self.verbose:
+            logger.info(f"Found {len(unique_facts)} unique facts.")
+
+        if not unique_facts:
+            return {
+                "mean_similarity": 0.0,
+                "per_pair_similarity": np.zeros(len(hyps), dtype=np.float32),
+            }
+
+        unique_embeddings = self._get_embeddings_batch(
+            unique_facts, batch_size=batch_size
+        )
+        fact_to_embedding_idx = {fact: i for i, fact in enumerate(unique_facts)}
+
+        per_pair_similarity = []
+        pair_iterator = (
+            tqdm(
+                zip(hyps_facts, refs_facts),
+                total=len(hyps),
+                desc="Computing pair-wise similarity",
+            )
+            if self.verbose
+            else zip(hyps_facts, refs_facts)
+        )
+
+        for hyp_facts, ref_facts in pair_iterator:
+            hyp_facts = [f.strip() for f in hyp_facts if f.strip()]
+            ref_facts = [f.strip() for f in ref_facts if f.strip()]
+
+            if not hyp_facts or not ref_facts:
+                per_pair_similarity.append(0.0)
+                continue
+
+            hyp_indices = [fact_to_embedding_idx[f] for f in hyp_facts]
+            ref_indices = [fact_to_embedding_idx[f] for f in ref_facts]
+
+            hyp_embeddings = unique_embeddings[hyp_indices]
+            ref_embeddings = unique_embeddings[ref_indices]
+
+            similarity_matrix = cosine_similarity(hyp_embeddings, ref_embeddings)
+
+            mean_row_max = np.mean(np.max(similarity_matrix, axis=1))
+            mean_col_max = np.mean(np.max(similarity_matrix, axis=0))
+
+            pair_score = (mean_row_max + mean_col_max) / 2.0
+            per_pair_similarity.append(pair_score)
+
+        per_pair_similarity_np = np.array(per_pair_similarity, dtype=np.float32)
+        mean_similarity = np.mean(per_pair_similarity_np).item()
+
+        if self.verbose:
+            logger.info("Similarity calculation complete.")
+
+        return {
+            "mean_similarity": mean_similarity,
+            "per_pair_similarity": per_pair_similarity_np,
+        }
+
+    def __call__(
+        self,
+        hyps: List[str],
+        refs: List[str],
+        batch_size: Optional[int] = None,
+        num_workers: Optional[int] = None,
+    ) -> Dict[str, Union[float, np.ndarray]]:
+        return self.compute(
+            hyps=hyps, refs=refs, batch_size=batch_size, num_workers=num_workers
+        )
+
+    def visualize_fact_similarity(
+        self,
+        ref_report: str,
+        cand_report: str,
+        figsize: Tuple[int, int] = (10, 8),
+        fontsize: int = 10,
+        wrap_width: int = 40,
+    ):
+        """
+        Visualize fact-level cosine similarity between a reference and candidate.
+
+        Requires the optional ``viz`` extra: ``pip install cxrfescore[viz]``.
+        """
+        try:
+            import matplotlib.pyplot as plt
+            from matplotlib.colors import LinearSegmentedColormap
+            from matplotlib.patches import Rectangle
+        except ImportError as e:
+            raise ImportError(
+                "Visualization requires matplotlib. Install with: "
+                "pip install cxrfescore[viz]"
+            ) from e
+
+        ref_sents = [s.strip() for s in sent_tokenize(ref_report) if s.strip()]
+        cand_sents = [s.strip() for s in sent_tokenize(cand_report) if s.strip()]
+
+        ref_facts = self._extract_facts_batch(ref_sents)
+        cand_facts = self._extract_facts_batch(cand_sents)
+
+        ref_facts = self._aggregate_facts(
+            ref_sents, {sent: facts for sent, facts in zip(ref_sents, ref_facts)}
+        )
+        cand_facts = self._aggregate_facts(
+            cand_sents, {sent: facts for sent, facts in zip(cand_sents, cand_facts)}
+        )
+
+        print("--- Candidate Report (Y-axis) ---")
+        print(cand_report)
+        print("\n--- Extracted Candidate Facts ---")
+        for fact in cand_facts:
+            print(f"- {fact}")
+
+        print("\n--- Reference Report (X-axis) ---")
+        print(ref_report)
+        print("\n--- Extracted Reference Facts ---")
+        for fact in ref_facts:
+            print(f"- {fact}")
+
+        if not ref_facts or not cand_facts:
+            print(
+                "\nCould not generate visualization: One or both reports have no facts."
+            )
+            return
+
+        ref_embeddings = self._get_embeddings_batch(ref_facts)
+        cand_embeddings = self._get_embeddings_batch(cand_facts)
+
+        sim_matrix = cosine_similarity(cand_embeddings, ref_embeddings)
+
+        wrapped_ref_labels = [textwrap.fill(s, width=wrap_width) for s in ref_facts]
+        wrapped_cand_labels = [textwrap.fill(s, width=wrap_width) for s in cand_facts]
+
+        fig, ax = plt.subplots(figsize=figsize)
+
+        colors = [
+            (1.0, 0.0, 0.0),
+            (1.0, 0.5, 0.0),
+            (1.0, 1.0, 1.0),
+            (0.0, 0.5, 1.0),
+            (0.0, 0.0, 1.0),
+        ]
+        positions = [0.0, 0.25, 0.5, 0.75, 1.0]
+        custom_cmap = LinearSegmentedColormap.from_list(
+            "red_white_blue", list(zip(positions, colors))
+        )
+
+        im = ax.imshow(sim_matrix, cmap=custom_cmap, vmin=-1, vmax=1)
+
+        cbar = fig.colorbar(im, ax=ax)
+        cbar.ax.set_ylabel("Cosine Similarity", rotation=-90, va="bottom")
+
+        ax.set_xticks(np.arange(len(wrapped_ref_labels)))
+        ax.set_yticks(np.arange(len(wrapped_cand_labels)))
+        ax.set_xticklabels(wrapped_ref_labels, rotation=90)
+        ax.set_yticklabels(wrapped_cand_labels)
+
+        ax.set_xlabel("Reference Facts", fontweight="bold")
+        ax.set_ylabel("Candidate Facts", fontweight="bold")
+        ax.set_title("Fact Similarity Matrix", fontweight="bold", fontsize=14)
+
+        for i in range(len(cand_facts)):
+            for j in range(len(ref_facts)):
+                color = "black" if -0.5 <= sim_matrix[i, j] <= 0.5 else "white"
+                ax.text(
+                    j,
+                    i,
+                    f"{sim_matrix[i, j]:.2f}",
+                    ha="center",
+                    va="center",
+                    color=color,
+                    fontsize=fontsize,
+                )
+
+        highlight_cells = set()
+        for i in range(sim_matrix.shape[0]):
+            max_val = np.max(sim_matrix[i, :])
+            max_cols = np.where(sim_matrix[i, :] == max_val)[0]
+            for j in max_cols:
+                highlight_cells.add((i, j))
+        for j in range(sim_matrix.shape[1]):
+            max_val = np.max(sim_matrix[:, j])
+            max_rows = np.where(sim_matrix[:, j] == max_val)[0]
+            for i in max_rows:
+                highlight_cells.add((i, j))
+        for i, j in highlight_cells:
+            ax.add_patch(
+                Rectangle(
+                    (j - 0.5, i - 0.5),
+                    1,
+                    1,
+                    fill=False,
+                    edgecolor="lightgreen",
+                    lw=3,
+                )
+            )
+
+        fig.tight_layout()
+        plt.show()
+
+        if sim_matrix.size > 0:
+            mean_row_max = np.mean(np.max(sim_matrix, axis=1))
+            mean_col_max = np.mean(np.max(sim_matrix, axis=0))
+            pair_score = (mean_row_max + mean_col_max) / 2.0
+            print(f"\nCXRFEScore for this pair: {pair_score:.4f}")
+        else:
+            print("\nCXRFEScore for this pair: 0.0")

cxrfescore/nltk_setup.py

@@ -0,0 +1,29 @@
+"""Ensure required NLTK tokenizers are available."""
+
+import nltk
+
+REQUIRED_RESOURCES = ["punkt", "punkt_tab"]
+
+
+def ensure_nltk_resources():
+    """Download missing NLTK resources needed for sentence tokenization."""
+    missing_resources = []
+    for resource in REQUIRED_RESOURCES:
+        try:
+            nltk.data.find(f"tokenizers/{resource}")
+        except LookupError:
+            missing_resources.append(resource)
+
+    if not missing_resources:
+        return
+
+    print(f"Downloading missing NLTK resources: {missing_resources}...")
+    try:
+        for resource in missing_resources:
+            nltk.download(resource, quiet=True)
+        for resource in missing_resources:
+            nltk.data.find(f"tokenizers/{resource}")
+        print("NLTK resources downloaded successfully.")
+    except Exception as e:
+        print(f"Error downloading NLTK data: {e}")
+        print(f"  python -m nltk.downloader {' '.join(missing_resources)}")

cxrfescore/text_utils.py

@@ -0,0 +1,71 @@
+"""Helpers for parsing and cleaning extracted radiology facts."""
+
+import json
+import re
+
+_COMMA_SEPARATED_LIST_REGEX = re.compile(r'\[\s*(\".+?\"(\s*,\s*\".+?\")*)?\s*\]?')
+
+
+def parse_facts(txt: str) -> list:
+    """Parse a JSON-like list of facts from T5 fact-extractor output."""
+    match = _COMMA_SEPARATED_LIST_REGEX.search(txt)
+    if match is None:
+        return []
+    facts_str = match.group()
+    if facts_str[-1] != "]":
+        facts_str += "]"
+    facts = json.loads(facts_str)
+    seen = set()
+    clean_facts = []
+    for fact in facts:
+        if fact not in seen:
+            clean_facts.append(fact)
+            seen.add(fact)
+    return clean_facts
+
+
+def _substrings_are_equal(text, i, j, k):
+    for x in range(k):
+        if text[i + x] != text[j + x]:
+            return False
+    return True
+
+
+def remove_consecutive_repeated_words_from_text(text, ks=None):
+    """Remove consecutive repeated word n-grams from text."""
+    if ks is None:
+        ks = [1, 2, 3, 4, 5, 6, 7, 8]
+    assert type(ks) is int or type(ks) is list
+    if type(ks) is int:
+        ks = [ks]
+    else:
+        assert len(ks) > 0
+        assert all(type(x) is int for x in ks)
+
+    tokens = text.split()
+    lower_tokens = text.lower().split()
+    dedup_tokens = []
+    dedup_lower_tokens = []
+
+    for k in ks:
+        for i in range(len(lower_tokens)):
+            skip = False
+            for j in range(k):
+                s = i - j
+                e = s + k - 1
+                if (
+                    s - k >= 0
+                    and e < len(lower_tokens)
+                    and _substrings_are_equal(lower_tokens, s, s - k, k)
+                ):
+                    skip = True
+                    break
+            if skip:
+                continue
+            dedup_tokens.append(tokens[i])
+            dedup_lower_tokens.append(lower_tokens[i])
+        tokens = dedup_tokens
+        lower_tokens = dedup_lower_tokens
+        dedup_tokens = []
+        dedup_lower_tokens = []
+    return " ".join(tokens)

cxrfescore-0.2.2.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: cxrfescore
+Version: 0.2.2
+Summary: Fact-level embedding metric for evaluating chest X-ray radiology report generation.
+Project-URL: Homepage, https://github.com/PabloMessina/CXRFEScore
+Project-URL: Bug Tracker, https://github.com/PabloMessina/CXRFEScore/issues
+Project-URL: Paper, https://aclanthology.org/2024.findings-acl.236/
+Author-email: Pablo Messina <pablo.messina.g@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Pablo Messina
+        
+        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.
+License-File: LICENSE
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Requires-Dist: nltk>=3.8.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: transformers>=4.40.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: matplotlib>=3.7.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: twine>=5.0.0; extra == 'dev'
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7.0; extra == 'viz'
+Description-Content-Type: text/markdown
+
+# CXRFEScore
+
+Fact-level embedding metric for evaluating chest X-ray radiology report generation.
+
+CXRFEScore extracts factual statements from reports with a T5 fact extractor, embeds them with CXRFE (or compatible CXR-BERT models), and scores hypothesis/reference pairs via soft bipartite matching of fact embeddings.
+
+Based on:
+
+> Messina et al., *Extracting and Encoding: Leveraging Large Language Models and Medical Knowledge to Enhance Radiological Text Representation*, Findings of ACL 2024.
+
+## Install
+
+```bash
+pip install cxrfescore
+```
+
+Optional visualization support:
+
+```bash
+pip install cxrfescore[viz]
+```
+
+**Python:** 3.10+
+
+### Runtime dependencies (installed automatically)
+
+| Package | Role |
+|---|---|
+| `torch` | Model inference |
+| `transformers` | Load Hugging Face models |
+| `numpy` | Arrays / aggregation |
+| `scikit-learn` | Cosine similarity |
+| `nltk` | Sentence splitting |
+| `tqdm` | Progress bars |
+| `platformdirs` | Default cache directory |
+
+Optional: `matplotlib` via `cxrfescore[viz]` for `visualize_fact_similarity`.
+
+### Additional requirements (not pip packages)
+
+On first use the metric downloads:
+
+- **Encoder (default):** [`pamessina/CXRFE`](https://huggingface.co/pamessina/CXRFE)
+- **Fact extractor:** [`pamessina/T5FactExtractor`](https://huggingface.co/pamessina/T5FactExtractor)
+- **NLTK** `punkt` / `punkt_tab` (auto-downloaded)
+
+Supported alternate encoders:
+
+- `microsoft/BiomedVLP-CXR-BERT-specialized`
+- `microsoft/BiomedVLP-BioViL-T`
+- `StanfordAIMI/SRR-BERT-Leaves` (CLS embeddings only; label head unused)
+
+A GPU is recommended but not required. CPU works and is slower.
+
+Known-good stack from development: PyTorch 2.x + `transformers` 4.x / 5.x.
+
+## Quick start
+
+```python
+from cxrfescore import CXRFEScore
+
+metric = CXRFEScore(device="cuda")  # or "cpu"
+
+hyps = [
+    "There is a small right pleural effusion. The heart size is normal.",
+]
+refs = [
+    "Small right pleural effusion. Normal heart size.",
+]
+
+result = metric(hyps, refs)
+print(result["mean_similarity"])
+print(result["per_pair_similarity"])
+```
+
+### Extract facts or embeddings only
+
+`extract_facts` treats each input string as a **full report**: sentence-split → T5 fact extraction → unique-fact aggregation (same pipeline as scoring).
+
+```python
+facts_per_report = metric.extract_facts(hyps)
+embeddings = metric.embed_facts(facts_per_report[0])  # shape (num_facts, dim)
+```
+
+### Caching
+
+With `use_cache=True` (default), results are kept **in memory** during the session:
+
+- Sentence→facts: `{cache_dir}/sent_to_facts.pkl` (shared across encoders)
+- Fact→embedding: `{cache_dir}/embeddings/<encoder_name>/fact_to_embedding.pkl` (per encoder)
+
+Disk writes are **not** automatic. Call `save_cache()` explicitly after a large batch or at the end of a job:
+
+```python
+metric = CXRFEScore(use_cache=True, cache_dir="/path/to/cache")
+# ... score / extract / embed ...
+metric.save_cache()
+```
+
+Disable with `use_cache=False`.
+
+Inspect what is already on disk:
+
+```python
+from cxrfescore import inspect_cache
+
+inspect_cache()                 # default cache location
+# or: metric.inspect_cache()    # uses this instance's cache_dir
+```
+
+### Visualization
+
+```python
+# requires: pip install cxrfescore[viz]
+metric.visualize_fact_similarity(ref_report=refs[0], cand_report=hyps[0])
+```
+
+## Examples
+
+| File | Purpose |
+|---|---|
+| [`examples/colab_smoke.md`](examples/colab_smoke.md) | Full Colab smoke + adversarial pairs |
+| [`examples/minimal_cxrfe.md`](examples/minimal_cxrfe.md) | Default CXRFE encoder |
+| [`examples/minimal_cxr_bert_specialized.md`](examples/minimal_cxr_bert_specialized.md) | CXR-BERT specialized |
+| [`examples/minimal_biovil_t.md`](examples/minimal_biovil_t.md) | BioViL-T |
+| [`examples/minimal_srr_bert_leaves.md`](examples/minimal_srr_bert_leaves.md) | SRR-BERT-Leaves CLS |
+| [`examples/minimal_extract_embed.md`](examples/minimal_extract_embed.md) | `extract_facts` / `embed_facts` |
+
+## Try it on Google Colab
+
+After publishing, install in Colab (GPU runtime recommended):
+
+```python
+!pip install cxrfescore
+```
+
+For a pre-release check against TestPyPI:
+
+```python
+!pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ "cxrfescore==0.2.2"
+```
+
+## Citation
+
+If you use CXRFEScore, please cite:
+
+> Pablo Messina, Rene Vidal, Denis Parra, Alvaro Soto, and Vladimir Araujo. 2024. [Extracting and Encoding: Leveraging Large Language Models and Medical Knowledge to Enhance Radiological Text Representation](https://aclanthology.org/2024.findings-acl.236/). In *Findings of the Association for Computational Linguistics: ACL 2024*, pages 3955–3986, Bangkok, Thailand. Association for Computational Linguistics.
+
+```bibtex
+@inproceedings{messina-etal-2024-extracting,
+    title = "Extracting and Encoding: Leveraging Large Language Models and Medical Knowledge to Enhance Radiological Text Representation",
+    author = "Messina, Pablo  and
+      Vidal, Rene  and
+      Parra, Denis  and
+      Soto, Alvaro  and
+      Araujo, Vladimir",
+    editor = "Ku, Lun-Wei  and
+      Martins, Andre  and
+      Srikumar, Vivek",
+    booktitle = "Findings of the Association for Computational Linguistics: ACL 2024",
+    month = aug,
+    year = "2024",
+    address = "Bangkok, Thailand",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.findings-acl.236/",
+    doi = "10.18653/v1/2024.findings-acl.236",
+    pages = "3955--3986"
+}
+```
+
+Paper: [ACL Anthology](https://aclanthology.org/2024.findings-acl.236/) · [PDF](https://aclanthology.org/2024.findings-acl.236.pdf) · [arXiv](https://arxiv.org/abs/2407.01948)
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest                          # unit + mocked tests (default)
+pytest -m integration           # downloads HF models; needs network / GPU optional
+python -m build
+```
+
+## License
+
+MIT

cxrfescore-0.2.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+cxrfescore/__init__.py,sha256=tsUqqaP-lTvptQGvxbGkEJUDZX9WUNAF9iz387GLJZM,237
+cxrfescore/cache_utils.py,sha256=CRvKcgYsvpI_dH9Qjc8eORj3clWXjgSrYdChi0jiw-I,4303
+cxrfescore/metric.py,sha256=7AtCjufG-QmJIV3pCcHy1-g1nHIhDpnwdERaZQItRs4,31831
+cxrfescore/nltk_setup.py,sha256=8fi6taw7FvSk-6RojT_tW9Zv5PFli0juaSGt6kOXaFg,953
+cxrfescore/text_utils.py,sha256=KQHdb_S_D9OcTgKn23QXtwihVjgDF9zRkqsbZE1jCfQ,2016
+cxrfescore-0.2.2.dist-info/METADATA,sha256=F88uNfIXgdgCUVROmMvaBeEdbfjwPpB3mQu1yZkJoKU,8440
+cxrfescore-0.2.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+cxrfescore-0.2.2.dist-info/licenses/LICENSE,sha256=pX4oAsWen33iCK5RLpf1DLrrCpVUlDw8EwjjRXRj2Q8,1070
+cxrfescore-0.2.2.dist-info/RECORD,,

cxrfescore-0.2.2.dist-info/WHEEL

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

cxrfescore-0.2.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pablo Messina
+
+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.