oracle_context_cache_v3/MinishLab__semhash.json

{"repo": "MinishLab/semhash", "n_pairs": 33, "version": "v3_compressed", "max_tokens": 6000, "contexts": {"tests/test_utils.py::14": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["make_hashable"], "enclosing_function": "test_make_hashable", "extracted_code": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 837, "extracted_code_full": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_chars_compressed": 837, "compression_ratio": 1.0}, "tests/test_utils.py::45": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["coerce_value"], "enclosing_function": "test_coerce_value", "extracted_code": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 549, "extracted_code_full": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_chars_compressed": 549, "compression_ratio": 1.0}, "tests/test_utils.py::15": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["make_hashable"], "enclosing_function": "test_make_hashable", "extracted_code": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 837, "extracted_code_full": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_chars_compressed": 837, "compression_ratio": 1.0}, "tests/test_utils.py::117": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["remove_exact_duplicates"], "enclosing_function": "test_remove_exact_duplicates", "extracted_code": "# Source: semhash/records.py\ndef remove_exact_duplicates(\n    records: Sequence[dict[str, Any]],\n    columns: Sequence[str],\n    reference_records: list[list[dict[str, Any]]] | None = None,\n) -> tuple[list[dict[str, Any]], list[tuple[dict[str, Any], list[dict[str, Any]]]]]:\n    \"\"\"\n    Remove exact duplicates based on the hashable representation of each record.\n\n    If reference_records is None, the function will only check for duplicates within the records list.\n\n    :param records: A list of records to check for exact duplicates.\n    :param columns: Columns to unpack.\n    :param reference_records: A list of records to compare against. These are already unpacked\n    :return: A list of deduplicated records and a list of duplicates.\n    \"\"\"\n    deduplicated: list[dict[str, Any]] = []\n    duplicates: list[tuple[dict[str, Any], list[dict[str, Any]]]] = []\n\n    column_set = set(columns)\n\n    # Build seen set from reference_records (cross-dataset mode) or empty (single-dataset mode)\n    seen: defaultdict[frozendict[str, Any], list[dict[str, Any]]] = defaultdict(list)\n    if reference_records is not None:\n        for record_set in reference_records:\n            key = to_frozendict(record_set[0], column_set)\n            seen[key] = list(record_set)\n\n    for record in records:\n        frozen_record = to_frozendict(record, column_set)\n        if duplicated_records := seen.get(frozen_record):\n            duplicates.append((record, duplicated_records))\n        else:\n            deduplicated.append(record)\n            # Single-dataset mode: track this record for future comparisons\n            if reference_records is None:\n                seen[frozen_record].append(record)\n\n    return deduplicated, duplicates", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 1725, "extracted_code_full": "# Source: semhash/records.py\ndef remove_exact_duplicates(\n    records: Sequence[dict[str, Any]],\n    columns: Sequence[str],\n    reference_records: list[list[dict[str, Any]]] | None = None,\n) -> tuple[list[dict[str, Any]], list[tuple[dict[str, Any], list[dict[str, Any]]]]]:\n    \"\"\"\n    Remove exact duplicates based on the hashable representation of each record.\n\n    If reference_records is None, the function will only check for duplicates within the records list.\n\n    :param records: A list of records to check for exact duplicates.\n    :param columns: Columns to unpack.\n    :param reference_records: A list of records to compare against. These are already unpacked\n    :return: A list of deduplicated records and a list of duplicates.\n    \"\"\"\n    deduplicated: list[dict[str, Any]] = []\n    duplicates: list[tuple[dict[str, Any], list[dict[str, Any]]]] = []\n\n    column_set = set(columns)\n\n    # Build seen set from reference_records (cross-dataset mode) or empty (single-dataset mode)\n    seen: defaultdict[frozendict[str, Any], list[dict[str, Any]]] = defaultdict(list)\n    if reference_records is not None:\n        for record_set in reference_records:\n            key = to_frozendict(record_set[0], column_set)\n            seen[key] = list(record_set)\n\n    for record in records:\n        frozen_record = to_frozendict(record, column_set)\n        if duplicated_records := seen.get(frozen_record):\n            duplicates.append((record, duplicated_records))\n        else:\n            deduplicated.append(record)\n            # Single-dataset mode: track this record for future comparisons\n            if reference_records is None:\n                seen[frozen_record].append(record)\n\n    return deduplicated, duplicates", "n_chars_compressed": 1725, "compression_ratio": 1.0}, "tests/test_datamodels.py::42": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DuplicateRecord"], "enclosing_function": "test_rethreshold", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 666, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]", "n_chars_compressed": 666, "compression_ratio": 1.0}, "tests/test_utils.py::81": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["compute_candidate_limit"], "enclosing_function": "test_compute_candidate_limit", "extracted_code": "# Source: semhash/utils.py\ndef compute_candidate_limit(\n    total: int,\n    selection_size: int,\n    fraction: float = 0.1,\n    min_candidates: int = 100,\n    max_candidates: int = 1000,\n) -> int:\n    \"\"\"\n    Compute the 'auto' candidate limit based on the total number of records.\n\n    :param total: Total number of records.\n    :param selection_size: Number of representatives to select.\n    :param fraction: Fraction of total records to consider as candidates.\n    :param min_candidates: Minimum number of candidates.\n    :param max_candidates: Maximum number of candidates.\n    :return: Computed candidate limit.\n    \"\"\"\n    # 1) fraction of total\n    limit = int(total * fraction)\n    # 2) ensure enough to pick selection_size\n    limit = max(limit, selection_size)\n    # 3) enforce lower bound\n    limit = max(limit, min_candidates)\n    # 4) enforce upper bound (and never exceed the dataset)\n    limit = min(limit, max_candidates, total)\n    return limit", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 961, "extracted_code_full": "# Source: semhash/utils.py\ndef compute_candidate_limit(\n    total: int,\n    selection_size: int,\n    fraction: float = 0.1,\n    min_candidates: int = 100,\n    max_candidates: int = 1000,\n) -> int:\n    \"\"\"\n    Compute the 'auto' candidate limit based on the total number of records.\n\n    :param total: Total number of records.\n    :param selection_size: Number of representatives to select.\n    :param fraction: Fraction of total records to consider as candidates.\n    :param min_candidates: Minimum number of candidates.\n    :param max_candidates: Maximum number of candidates.\n    :return: Computed candidate limit.\n    \"\"\"\n    # 1) fraction of total\n    limit = int(total * fraction)\n    # 2) ensure enough to pick selection_size\n    limit = max(limit, selection_size)\n    # 3) enforce lower bound\n    limit = max(limit, min_candidates)\n    # 4) enforce upper bound (and never exceed the dataset)\n    limit = min(limit, max_candidates, total)\n    return limit", "n_chars_compressed": 961, "compression_ratio": 1.0}, "tests/test_datamodels.py::123": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_selected_with_duplicates_dicts", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}, "tests/test_utils.py::44": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["coerce_value"], "enclosing_function": "test_coerce_value", "extracted_code": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 549, "extracted_code_full": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_chars_compressed": 549, "compression_ratio": 1.0}, "tests/test_semhash.py::57": {"resolved_imports": ["semhash/__init__.py", "semhash/datamodels.py", "semhash/utils.py"], "used_names": ["Encoder", "SemHash"], "enclosing_function": "test_multi_dataset_deduplication", "extracted_code": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_imports_parsed": 5, "n_files_resolved": 3, "n_chars_extracted": 722, "extracted_code_full": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_chars_compressed": 722, "compression_ratio": 1.0}, "tests/test_utils.py::151": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["prepare_records", "pytest"], "enclosing_function": "test_prepare_records", "extracted_code": "# Source: semhash/records.py\ndef prepare_records(\n    records: Sequence[Record], columns: Sequence[str] | None\n) -> tuple[list[dict[str, Any]], Sequence[str], bool]:\n    \"\"\"\n    Validate and prepare records for processing.\n\n    :param records: A list of records (strings or dictionaries).\n    :param columns: Columns to use if records are dictionaries.\n    :return: Tuple of (dict_records, columns, was_string).\n    :raises ValueError: If records are empty.\n    :raises ValueError: If columns are not provided for dictionary records.\n    :raises ValueError: If dict record contains None values.\n    :raises ValueError: If records are not homogeneous (mixed strings and dicts).\n    \"\"\"\n    if len(records) == 0:\n        raise ValueError(\"records must not be empty\")\n\n    if columns is None and isinstance(records[0], dict):\n        raise ValueError(\"Columns must be specified when passing dictionaries.\")\n\n    # String path: convert to dicts with \"text\" column\n    if isinstance(records[0], str):\n        if not all(isinstance(r, str) for r in records):\n            raise ValueError(\"All records must be strings when the first record is a string.\")\n        columns = [\"text\"]\n        dict_records: list[dict[str, Any]] = [{\"text\": record} for record in records]\n        was_string = True\n    # Dict path: validate and coerce values\n    else:\n        if not all(isinstance(r, dict) for r in records):\n            raise ValueError(\"All records must be dicts when the first record is a dict.\")\n        assert columns is not None\n\n        # Coerce values: stringify primitives, keep complex types raw (for images, etc.)\n        dict_records_typed: list[dict[str, Any]] = list(records)\n        dict_records = []\n        for record in dict_records_typed:\n            # Start with a copy of the full record to preserve non-embedding fields\n            coerced: dict[str, Any] = dict(record)\n            # Then coerce only the embedding columns\n            for column in columns:\n                val = record.get(column)\n                if val is None:\n                    raise ValueError(f\"Column '{column}' has None value in record {record}\")\n                coerced[column] = coerce_value(val)\n            dict_records.append(coerced)\n        was_string = False\n\n    return dict_records, columns, was_string", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 2302, "extracted_code_full": "# Source: semhash/records.py\ndef prepare_records(\n    records: Sequence[Record], columns: Sequence[str] | None\n) -> tuple[list[dict[str, Any]], Sequence[str], bool]:\n    \"\"\"\n    Validate and prepare records for processing.\n\n    :param records: A list of records (strings or dictionaries).\n    :param columns: Columns to use if records are dictionaries.\n    :return: Tuple of (dict_records, columns, was_string).\n    :raises ValueError: If records are empty.\n    :raises ValueError: If columns are not provided for dictionary records.\n    :raises ValueError: If dict record contains None values.\n    :raises ValueError: If records are not homogeneous (mixed strings and dicts).\n    \"\"\"\n    if len(records) == 0:\n        raise ValueError(\"records must not be empty\")\n\n    if columns is None and isinstance(records[0], dict):\n        raise ValueError(\"Columns must be specified when passing dictionaries.\")\n\n    # String path: convert to dicts with \"text\" column\n    if isinstance(records[0], str):\n        if not all(isinstance(r, str) for r in records):\n            raise ValueError(\"All records must be strings when the first record is a string.\")\n        columns = [\"text\"]\n        dict_records: list[dict[str, Any]] = [{\"text\": record} for record in records]\n        was_string = True\n    # Dict path: validate and coerce values\n    else:\n        if not all(isinstance(r, dict) for r in records):\n            raise ValueError(\"All records must be dicts when the first record is a dict.\")\n        assert columns is not None\n\n        # Coerce values: stringify primitives, keep complex types raw (for images, etc.)\n        dict_records_typed: list[dict[str, Any]] = list(records)\n        dict_records = []\n        for record in dict_records_typed:\n            # Start with a copy of the full record to preserve non-embedding fields\n            coerced: dict[str, Any] = dict(record)\n            # Then coerce only the embedding columns\n            for column in columns:\n                val = record.get(column)\n                if val is None:\n                    raise ValueError(f\"Column '{column}' has None value in record {record}\")\n                coerced[column] = coerce_value(val)\n            dict_records.append(coerced)\n        was_string = False\n\n    return dict_records, columns, was_string", "n_chars_compressed": 2302, "compression_ratio": 1.0}, "tests/test_datamodels.py::224": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_selected_with_duplicates_cache_invalidation_on_rethreshold", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}, "tests/test_utils.py::53": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["coerce_value"], "enclosing_function": "test_coerce_value", "extracted_code": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 549, "extracted_code_full": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_chars_compressed": 549, "compression_ratio": 1.0}, "tests/test_datamodels.py::29": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult"], "enclosing_function": "test_deduplication_scoring_empty", "extracted_code": "# Source: semhash/datamodels.py\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4351, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4351, "compression_ratio": 1.0}, "tests/test_utils.py::79": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["compute_candidate_limit"], "enclosing_function": "test_compute_candidate_limit", "extracted_code": "# Source: semhash/utils.py\ndef compute_candidate_limit(\n    total: int,\n    selection_size: int,\n    fraction: float = 0.1,\n    min_candidates: int = 100,\n    max_candidates: int = 1000,\n) -> int:\n    \"\"\"\n    Compute the 'auto' candidate limit based on the total number of records.\n\n    :param total: Total number of records.\n    :param selection_size: Number of representatives to select.\n    :param fraction: Fraction of total records to consider as candidates.\n    :param min_candidates: Minimum number of candidates.\n    :param max_candidates: Maximum number of candidates.\n    :return: Computed candidate limit.\n    \"\"\"\n    # 1) fraction of total\n    limit = int(total * fraction)\n    # 2) ensure enough to pick selection_size\n    limit = max(limit, selection_size)\n    # 3) enforce lower bound\n    limit = max(limit, min_candidates)\n    # 4) enforce upper bound (and never exceed the dataset)\n    limit = min(limit, max_candidates, total)\n    return limit", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 961, "extracted_code_full": "# Source: semhash/utils.py\ndef compute_candidate_limit(\n    total: int,\n    selection_size: int,\n    fraction: float = 0.1,\n    min_candidates: int = 100,\n    max_candidates: int = 1000,\n) -> int:\n    \"\"\"\n    Compute the 'auto' candidate limit based on the total number of records.\n\n    :param total: Total number of records.\n    :param selection_size: Number of representatives to select.\n    :param fraction: Fraction of total records to consider as candidates.\n    :param min_candidates: Minimum number of candidates.\n    :param max_candidates: Maximum number of candidates.\n    :return: Computed candidate limit.\n    \"\"\"\n    # 1) fraction of total\n    limit = int(total * fraction)\n    # 2) ensure enough to pick selection_size\n    limit = max(limit, selection_size)\n    # 3) enforce lower bound\n    limit = max(limit, min_candidates)\n    # 4) enforce upper bound (and never exceed the dataset)\n    limit = min(limit, max_candidates, total)\n    return limit", "n_chars_compressed": 961, "compression_ratio": 1.0}, "tests/test_utils.py::26": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["make_hashable"], "enclosing_function": "test_make_hashable", "extracted_code": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 837, "extracted_code_full": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_chars_compressed": 837, "compression_ratio": 1.0}, "tests/test_utils.py::46": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["coerce_value"], "enclosing_function": "test_coerce_value", "extracted_code": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 549, "extracted_code_full": "# Source: semhash/utils.py\ndef coerce_value(value: Any) -> Any:\n    \"\"\"\n    Coerce a value for encoding: stringify primitives, keep complex types raw.\n\n    This ensures primitives (int, float, bool) work with text encoders,\n    while complex types (PIL images, tensors, etc.) are passed through for multimodal encoders.\n\n    :param value: The value to coerce.\n    :return: The coerced value.\n    \"\"\"\n    if isinstance(value, (str, bytes)):\n        return value\n    if isinstance(value, (int, float, bool)):\n        return str(value)\n    return value", "n_chars_compressed": 549, "compression_ratio": 1.0}, "tests/test_utils.py::63": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["frozendict", "pytest", "to_frozendict"], "enclosing_function": "test_to_frozendict", "extracted_code": "# Source: semhash/utils.py\ndef to_frozendict(record: dict[str, Any], columns: Sequence[str] | set[str]) -> frozendict[str, Any]:\n    \"\"\"\n    Convert a record to a frozendict with hashable values.\n\n    :param record: The record to convert.\n    :param columns: The columns to include.\n    :return: A frozendict with only the specified columns (values made hashable).\n    :raises ValueError: If a column is missing from the record.\n    \"\"\"\n    try:\n        return frozendict({k: make_hashable(record[k]) for k in columns})\n    except KeyError as e:\n        missing = e.args[0]\n        raise ValueError(f\"Missing column '{missing}' in record {record}\") from e", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 655, "extracted_code_full": "# Source: semhash/utils.py\ndef to_frozendict(record: dict[str, Any], columns: Sequence[str] | set[str]) -> frozendict[str, Any]:\n    \"\"\"\n    Convert a record to a frozendict with hashable values.\n\n    :param record: The record to convert.\n    :param columns: The columns to include.\n    :return: A frozendict with only the specified columns (values made hashable).\n    :raises ValueError: If a column is missing from the record.\n    \"\"\"\n    try:\n        return frozendict({k: make_hashable(record[k]) for k in columns})\n    except KeyError as e:\n        missing = e.args[0]\n        raise ValueError(f\"Missing column '{missing}' in record {record}\") from e", "n_chars_compressed": 655, "compression_ratio": 1.0}, "tests/test_utils.py::77": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["compute_candidate_limit"], "enclosing_function": "test_compute_candidate_limit", "extracted_code": "# Source: semhash/utils.py\ndef compute_candidate_limit(\n    total: int,\n    selection_size: int,\n    fraction: float = 0.1,\n    min_candidates: int = 100,\n    max_candidates: int = 1000,\n) -> int:\n    \"\"\"\n    Compute the 'auto' candidate limit based on the total number of records.\n\n    :param total: Total number of records.\n    :param selection_size: Number of representatives to select.\n    :param fraction: Fraction of total records to consider as candidates.\n    :param min_candidates: Minimum number of candidates.\n    :param max_candidates: Maximum number of candidates.\n    :return: Computed candidate limit.\n    \"\"\"\n    # 1) fraction of total\n    limit = int(total * fraction)\n    # 2) ensure enough to pick selection_size\n    limit = max(limit, selection_size)\n    # 3) enforce lower bound\n    limit = max(limit, min_candidates)\n    # 4) enforce upper bound (and never exceed the dataset)\n    limit = min(limit, max_candidates, total)\n    return limit", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 961, "extracted_code_full": "# Source: semhash/utils.py\ndef compute_candidate_limit(\n    total: int,\n    selection_size: int,\n    fraction: float = 0.1,\n    min_candidates: int = 100,\n    max_candidates: int = 1000,\n) -> int:\n    \"\"\"\n    Compute the 'auto' candidate limit based on the total number of records.\n\n    :param total: Total number of records.\n    :param selection_size: Number of representatives to select.\n    :param fraction: Fraction of total records to consider as candidates.\n    :param min_candidates: Minimum number of candidates.\n    :param max_candidates: Maximum number of candidates.\n    :return: Computed candidate limit.\n    \"\"\"\n    # 1) fraction of total\n    limit = int(total * fraction)\n    # 2) ensure enough to pick selection_size\n    limit = max(limit, selection_size)\n    # 3) enforce lower bound\n    limit = max(limit, min_candidates)\n    # 4) enforce upper bound (and never exceed the dataset)\n    limit = min(limit, max_candidates, total)\n    return limit", "n_chars_compressed": 961, "compression_ratio": 1.0}, "tests/test_utils.py::13": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["make_hashable"], "enclosing_function": "test_make_hashable", "extracted_code": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 837, "extracted_code_full": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_chars_compressed": 837, "compression_ratio": 1.0}, "tests/test_datamodels.py::207": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_selected_with_duplicates_caching", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}, "tests/test_semhash.py::331": {"resolved_imports": ["semhash/__init__.py", "semhash/datamodels.py", "semhash/utils.py"], "used_names": ["Encoder", "SemHash"], "enclosing_function": "test_preserve_non_embedding_fields", "extracted_code": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_imports_parsed": 5, "n_files_resolved": 3, "n_chars_extracted": 722, "extracted_code_full": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_chars_compressed": 722, "compression_ratio": 1.0}, "tests/test_semhash.py::183": {"resolved_imports": ["semhash/__init__.py", "semhash/datamodels.py", "semhash/utils.py"], "used_names": ["Encoder", "SemHash", "pytest"], "enclosing_function": "test_filter_outliers", "extracted_code": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_imports_parsed": 5, "n_files_resolved": 3, "n_chars_extracted": 722, "extracted_code_full": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_chars_compressed": 722, "compression_ratio": 1.0}, "tests/test_semhash.py::333": {"resolved_imports": ["semhash/__init__.py", "semhash/datamodels.py", "semhash/utils.py"], "used_names": ["Encoder", "SemHash"], "enclosing_function": "test_preserve_non_embedding_fields", "extracted_code": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_imports_parsed": 5, "n_files_resolved": 3, "n_chars_extracted": 722, "extracted_code_full": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_chars_compressed": 722, "compression_ratio": 1.0}, "tests/test_datamodels.py::127": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_selected_with_duplicates_dicts", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}, "tests/test_semhash.py::147": {"resolved_imports": ["semhash/__init__.py", "semhash/datamodels.py", "semhash/utils.py"], "used_names": ["Encoder", "SemHash"], "enclosing_function": "test_self_find_representative", "extracted_code": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_imports_parsed": 5, "n_files_resolved": 3, "n_chars_extracted": 722, "extracted_code_full": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_chars_compressed": 722, "compression_ratio": 1.0}, "tests/test_utils.py::118": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["remove_exact_duplicates"], "enclosing_function": "test_remove_exact_duplicates", "extracted_code": "# Source: semhash/records.py\ndef remove_exact_duplicates(\n    records: Sequence[dict[str, Any]],\n    columns: Sequence[str],\n    reference_records: list[list[dict[str, Any]]] | None = None,\n) -> tuple[list[dict[str, Any]], list[tuple[dict[str, Any], list[dict[str, Any]]]]]:\n    \"\"\"\n    Remove exact duplicates based on the hashable representation of each record.\n\n    If reference_records is None, the function will only check for duplicates within the records list.\n\n    :param records: A list of records to check for exact duplicates.\n    :param columns: Columns to unpack.\n    :param reference_records: A list of records to compare against. These are already unpacked\n    :return: A list of deduplicated records and a list of duplicates.\n    \"\"\"\n    deduplicated: list[dict[str, Any]] = []\n    duplicates: list[tuple[dict[str, Any], list[dict[str, Any]]]] = []\n\n    column_set = set(columns)\n\n    # Build seen set from reference_records (cross-dataset mode) or empty (single-dataset mode)\n    seen: defaultdict[frozendict[str, Any], list[dict[str, Any]]] = defaultdict(list)\n    if reference_records is not None:\n        for record_set in reference_records:\n            key = to_frozendict(record_set[0], column_set)\n            seen[key] = list(record_set)\n\n    for record in records:\n        frozen_record = to_frozendict(record, column_set)\n        if duplicated_records := seen.get(frozen_record):\n            duplicates.append((record, duplicated_records))\n        else:\n            deduplicated.append(record)\n            # Single-dataset mode: track this record for future comparisons\n            if reference_records is None:\n                seen[frozen_record].append(record)\n\n    return deduplicated, duplicates", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 1725, "extracted_code_full": "# Source: semhash/records.py\ndef remove_exact_duplicates(\n    records: Sequence[dict[str, Any]],\n    columns: Sequence[str],\n    reference_records: list[list[dict[str, Any]]] | None = None,\n) -> tuple[list[dict[str, Any]], list[tuple[dict[str, Any], list[dict[str, Any]]]]]:\n    \"\"\"\n    Remove exact duplicates based on the hashable representation of each record.\n\n    If reference_records is None, the function will only check for duplicates within the records list.\n\n    :param records: A list of records to check for exact duplicates.\n    :param columns: Columns to unpack.\n    :param reference_records: A list of records to compare against. These are already unpacked\n    :return: A list of deduplicated records and a list of duplicates.\n    \"\"\"\n    deduplicated: list[dict[str, Any]] = []\n    duplicates: list[tuple[dict[str, Any], list[dict[str, Any]]]] = []\n\n    column_set = set(columns)\n\n    # Build seen set from reference_records (cross-dataset mode) or empty (single-dataset mode)\n    seen: defaultdict[frozendict[str, Any], list[dict[str, Any]]] = defaultdict(list)\n    if reference_records is not None:\n        for record_set in reference_records:\n            key = to_frozendict(record_set[0], column_set)\n            seen[key] = list(record_set)\n\n    for record in records:\n        frozen_record = to_frozendict(record, column_set)\n        if duplicated_records := seen.get(frozen_record):\n            duplicates.append((record, duplicated_records))\n        else:\n            deduplicated.append(record)\n            # Single-dataset mode: track this record for future comparisons\n            if reference_records is None:\n                seen[frozen_record].append(record)\n\n    return deduplicated, duplicates", "n_chars_compressed": 1725, "compression_ratio": 1.0}, "tests/test_datamodels.py::106": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord", "SelectedWithDuplicates"], "enclosing_function": "test_selected_with_duplicates_strings", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass SelectedWithDuplicates(Generic[Record]):\n    \"\"\"\n    A record that has been selected along with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being selected.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    duplicates: DuplicateList = field(default_factory=list)\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 5374, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass SelectedWithDuplicates(Generic[Record]):\n    \"\"\"\n    A record that has been selected along with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being selected.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    duplicates: DuplicateList = field(default_factory=list)\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 5374, "compression_ratio": 1.0}, "tests/test_semhash.py::175": {"resolved_imports": ["semhash/__init__.py", "semhash/datamodels.py", "semhash/utils.py"], "used_names": ["Encoder", "SemHash", "pytest"], "enclosing_function": "test_filter_outliers", "extracted_code": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_imports_parsed": 5, "n_files_resolved": 3, "n_chars_extracted": 722, "extracted_code_full": "# Source: semhash/__init__.py\nfrom pyversity import Strategy\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\nfrom semhash.semhash import SemHash\n\n__all__ = [\"SemHash\", \"Strategy\"]\n\n\n# Source: semhash/utils.py\nclass Encoder(Protocol):\n    \"\"\"An encoder protocol for SemHash. Supports text, images, or any encodable data.\"\"\"\n\n    def encode(\n        self,\n        inputs: Sequence[Any] | Any,\n        **kwargs: Any,\n    ) -> np.ndarray:\n        \"\"\"\n        Encode a list of inputs into embeddings.\n\n        :param inputs: A list of inputs to encode (strings, images, etc.).\n        :param **kwargs: Additional keyword arguments.\n        :return: The embeddings of the inputs.\n        \"\"\"\n        ...", "n_chars_compressed": 722, "compression_ratio": 1.0}, "tests/test_datamodels.py::241": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["FilterResult"], "enclosing_function": "test_filter_result_empty", "extracted_code": "# Source: semhash/datamodels.py\nclass FilterResult(Generic[Record]):\n    \"\"\"\n    Result of filtering operations.\n\n    Attributes\n    ----------\n        selected: List of records that passed the filter criteria.\n        filtered: List of records that were filtered out.\n        scores_selected: List of scores for the selected records.\n        scores_filtered: List of scores for the filtered records.\n\n    \"\"\"\n\n    selected: list[Record]\n    filtered: list[Record]\n    scores_selected: list[float] = field(default_factory=list)\n    scores_filtered: list[float] = field(default_factory=list)\n\n    @property\n    def filter_ratio(self) -> float:\n        \"\"\"Return the percentage of records filtered out.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len(self.filtered) / denom\n        return 0.0\n\n    @property\n    def selected_ratio(self) -> float:\n        \"\"\"Return the percentage of records selected.\"\"\"\n        return 1 - self.filter_ratio", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 977, "extracted_code_full": "# Source: semhash/datamodels.py\nclass FilterResult(Generic[Record]):\n    \"\"\"\n    Result of filtering operations.\n\n    Attributes\n    ----------\n        selected: List of records that passed the filter criteria.\n        filtered: List of records that were filtered out.\n        scores_selected: List of scores for the selected records.\n        scores_filtered: List of scores for the filtered records.\n\n    \"\"\"\n\n    selected: list[Record]\n    filtered: list[Record]\n    scores_selected: list[float] = field(default_factory=list)\n    scores_filtered: list[float] = field(default_factory=list)\n\n    @property\n    def filter_ratio(self) -> float:\n        \"\"\"Return the percentage of records filtered out.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len(self.filtered) / denom\n        return 0.0\n\n    @property\n    def selected_ratio(self) -> float:\n        \"\"\"Return the percentage of records selected.\"\"\"\n        return 1 - self.filter_ratio", "n_chars_compressed": 977, "compression_ratio": 1.0}, "tests/test_datamodels.py::126": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_selected_with_duplicates_dicts", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}, "tests/test_datamodels.py::23": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_deduplication_scoring_exact", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}, "tests/test_utils.py::16": {"resolved_imports": ["semhash/records.py", "semhash/utils.py"], "used_names": ["make_hashable"], "enclosing_function": "test_make_hashable", "extracted_code": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 837, "extracted_code_full": "# Source: semhash/utils.py\ndef make_hashable(value: Any) -> Any:\n    \"\"\"\n    Convert a value to a hashable representation for use as dict keys.\n\n    Strings and other hashable types are returned as-is.\n    Non-hashable types (like PIL images, numpy arrays) are hashed to a string.\n\n    :param value: The value to make hashable.\n    :return: A hashable representation of the value.\n    \"\"\"\n    # Fast path: most values are strings or already hashable\n    if isinstance(value, (str, int, float, bool, type(None))):\n        return value\n    # Handle objects with tobytes() (PIL Image, numpy array, etc.)\n    if hasattr(value, \"tobytes\"):\n        return hashlib.md5(value.tobytes()).hexdigest()\n    # Fallback: try to hash, otherwise stringify\n    try:\n        hash(value)\n        return value\n    except TypeError:\n        return str(value)", "n_chars_compressed": 837, "compression_ratio": 1.0}, "tests/test_datamodels.py::13": {"resolved_imports": ["semhash/datamodels.py"], "used_names": ["DeduplicationResult", "DuplicateRecord"], "enclosing_function": "test_deduplication_scoring", "extracted_code": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 4987, "extracted_code_full": "# Source: semhash/datamodels.py\nclass DuplicateRecord(Generic[Record]):\n    \"\"\"\n    A single record with its duplicates.\n\n    Attributes\n    ----------\n        record: The original record being deduplicated.\n        exact: Whether the record was identified as an exact match.\n        duplicates: List of tuples consisting of duplicate records and their associated scores.\n\n    \"\"\"\n\n    record: Record\n    exact: bool\n    duplicates: DuplicateList = field(default_factory=list)\n\n    def _rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        self.duplicates = [(d, score) for d, score in self.duplicates if score >= threshold]\n\nclass DeduplicationResult(Generic[Record]):\n    \"\"\"\n    Deduplication result.\n\n    Attributes\n    ----------\n        selected: List of deduplicated records after removing duplicates.\n        filtered: List of DuplicateRecord objects containing details about duplicates of an original record.\n        threshold: The similarity threshold used for deduplication.\n        columns: Columns used for deduplication.\n\n    \"\"\"\n\n    selected: list[Record] = field(default_factory=list)\n    filtered: list[DuplicateRecord] = field(default_factory=list)\n    threshold: float = field(default=0.9)\n    columns: Sequence[str] | None = field(default=None)\n\n    @property\n    def duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return 1.0 - len(self.selected) / denom\n        return 0.0\n\n    @property\n    def exact_duplicate_ratio(self) -> float:\n        \"\"\"Return the percentage of records dropped due to an exact match.\"\"\"\n        if denom := len(self.selected) + len(self.filtered):\n            return len([dup for dup in self.filtered if dup.exact]) / denom\n        return 0.0\n\n    def get_least_similar_from_duplicates(self, n: int = 1) -> list[tuple[Record, Record, float]]:\n        \"\"\"\n        Return the N least similar duplicate pairs.\n\n        :param n: The number of least similar pairs to return.\n        :return: A list of tuples consisting of (original_record, duplicate_record, score).\n        \"\"\"\n        all_pairs = [(dup.record, d, score) for dup in self.filtered for d, score in dup.duplicates]\n        sorted_pairs = sorted(all_pairs, key=lambda x: x[2])  # Sort by score\n        return sorted_pairs[:n]\n\n    def rethreshold(self, threshold: float) -> None:\n        \"\"\"Rethreshold the duplicates.\"\"\"\n        if self.threshold > threshold:\n            raise ValueError(\"Threshold is smaller than the given value.\")\n        # Invalidate cached property before modifying data\n        self.__dict__.pop(\"selected_with_duplicates\", None)\n        # Rethreshold duplicates and move records without duplicates to selected\n        for dup in list(self.filtered):\n            dup._rethreshold(threshold)\n            if not dup.duplicates:\n                self.filtered.remove(dup)\n                self.selected.append(dup.record)\n        self.threshold = threshold\n\n    @cached_property\n    def selected_with_duplicates(self) -> list[SelectedWithDuplicates[Record]]:\n        \"\"\"\n        For every kept record, return the duplicates that were removed along with their similarity scores.\n\n        :return: A list of tuples where each tuple contains a kept record\n                and a list of its duplicates with their similarity scores.\n        \"\"\"\n\n        def _to_hashable(record: Record) -> frozendict[str, str] | str:\n            \"\"\"Convert a record to a hashable representation.\"\"\"\n            if isinstance(record, dict) and self.columns is not None:\n                # Convert dict to frozendict for immutability and hashability\n                return to_frozendict(record, set(self.columns))\n            return str(record)\n\n        # Build a mapping from original-record  to  [(duplicate, score), …]\n        buckets: defaultdict[Hashable, DuplicateList] = defaultdict(list)\n        for duplicate_record in self.filtered:\n            for original_record, score in duplicate_record.duplicates:\n                buckets[_to_hashable(original_record)].append((duplicate_record.record, float(score)))\n\n        result: list[SelectedWithDuplicates[Record]] = []\n        for selected in self.selected:\n            # Get the list of duplicates for the selected record\n            raw_list = buckets.get(_to_hashable(selected), [])\n            # Ensure we don't have duplicates in the list\n            # Use full-record canonical JSON for dicts so that unhashable values are handled correctly\n            deduped = {\n                (\n                    json.dumps(rec, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False)\n                    if isinstance(rec, dict)\n                    else rec\n                ): (rec, score)\n                for rec, score in raw_list\n            }\n            result.append(SelectedWithDuplicates(record=selected, duplicates=list(deduped.values())))\n\n        return result", "n_chars_compressed": 4987, "compression_ratio": 1.0}}}