generate_artifinder¶

`src.generators.artifinder.generate_artifinder` ¶

Generate ArtiFinder integration outputs.

Downloads the ArtiFinder-Data set, matches each discovered artifact link to an existing artifact-evaluation (AE) paper by title + author list, and:

back-patches assets/data/artifacts.json to add an artifinder_urls list to every AE artifact that ArtiFinder found a link for. These links carry no badges and never affect any score; the only place they may be reused is repository statistics (GitHub stars/forks), per project policy.
writes small Jekyll aggregates for the ArtiFinder discovery page: _data/artifinder_summary.yml, _data/artifinder_by_year.yml, _data/artifinder_by_conference.yml.

The raw discovered links live in the upstream ArtiFinder-Data repository; we do not republish them here.

Usage::

python -m src.generators.artifinder.generate_artifinder --data_dir ../reprodb.github.io/src

`match_entries(entries: list[dict], artifacts: list[dict], authors_by_title: dict[str, set[str]]) -> list[dict]` ¶

Match ArtiFinder entries to AE artifacts by title + author overlap.

Mutates matched artifacts in place to append artifinder_urls and returns the per-entry match records (used only to build the aggregates).

First pass: same conference + year + identical normalised title. Second pass (fuzzy): for still-unmatched entries, the closest AE title in the same conference+year with a :data:FUZZY_MIN_RATIO similarity, to recover same-paper titles that differ by Unicode/LaTeX artifacts or minor wording. Both passes reject a match when author lists are known on both sides but share no author (guards against title collisions / different papers).

Source code in src/generators/artifinder/generate_artifinder.py

def match_entries(
    entries: list[dict],
    artifacts: list[dict],
    authors_by_title: dict[str, set[str]],
) -> list[dict]:
    """Match ArtiFinder entries to AE artifacts by title + author overlap.

    Mutates matched ``artifacts`` in place to append ``artifinder_urls`` and
    returns the per-entry match records (used only to build the aggregates).

    First pass: same conference + year + identical normalised title. Second
    pass (fuzzy): for still-unmatched entries, the closest AE title in the same
    conference+year with a :data:`FUZZY_MIN_RATIO` similarity, to recover
    same-paper titles that differ by Unicode/LaTeX artifacts or minor wording.
    Both passes reject a match when author lists are known on both sides but
    share no author (guards against title collisions / different papers).
    """
    # Index artifacts by (conference, year, normalized_title) and by (conf, year).
    artifact_index: dict[tuple[str, int, str], dict] = {}
    by_conf_year: dict[tuple[str, int], list[tuple[str, dict]]] = defaultdict(list)
    for art_row in artifacts:
        conf = str(art_row.get("conference", "")).upper()
        year = int(art_row.get("year", 0))
        ant = normalize_title(art_row.get("title", ""))
        artifact_index.setdefault((conf, year, ant), art_row)
        by_conf_year[(conf, year)].append((ant, art_row))

    def _authors_overlap_ok(entry_authors: set[str], ae_norm_title: str) -> bool:
        """False only when both sides list authors but none overlap."""
        art_authors = authors_by_title.get(ae_norm_title, set())
        if entry_authors and art_authors:
            return bool(entry_authors & art_authors)
        return True

    def _fuzzy_match(nt: str, conf: str, year: int, entry_authors: set[str]) -> dict | None:
        """Return the best fuzzy-matching AE artifact in the same conf/year, or None."""
        best_ratio, best_art, best_nt = 0.0, None, ""
        for ant, art_row in by_conf_year.get((conf, year), ()):
            if not ant:
                continue
            ratio = SequenceMatcher(None, nt, ant).ratio()
            if ratio > best_ratio:
                best_ratio, best_art, best_nt = ratio, art_row, ant
        if best_art is not None and best_ratio >= FUZZY_MIN_RATIO and _authors_overlap_ok(entry_authors, best_nt):
            return best_art
        return None

    records: list[dict] = []
    fuzzy_matched = 0

    for entry in entries:
        conf = str(entry["conference"]).upper()
        year = int(entry["year"])
        nt = normalize_title(entry["title"])
        url = entry["discovered_artifact"]
        entry_authors = _author_key_set(entry.get("authors", []))

        # First pass: exact normalised title.
        art = artifact_index.get((conf, year, nt))
        matched = False
        via_fuzzy = False
        if art is not None and _authors_overlap_ok(entry_authors, nt):
            matched = True
        else:
            art = None

        # Second pass: fuzzy title within the same conference + year.
        if art is None:
            art = _fuzzy_match(nt, conf, year, entry_authors)
            if art is not None:
                matched = True
                via_fuzzy = True

        records.append(
            {
                "conference": entry["conference"],
                "year": year,
                "artifact_url": url,
                "matched_ae": matched,
            }
        )

        if matched and art is not None:
            if via_fuzzy:
                fuzzy_matched += 1
            existing = set(art.get("artifact_urls", [])) | set(art.get("artifinder_urls", []))
            # Compare on a scheme-insensitive / trailing-slash-insensitive basis.
            norm_existing = {u.rstrip("/") for u in existing}
            if url.rstrip("/") not in norm_existing:
                art.setdefault("artifinder_urls", []).append(url)

    if fuzzy_matched:
        logger.info("  ArtiFinder: %d links matched to AE papers via fuzzy title fallback", fuzzy_matched)

    return records