main.py

# /// script
# requires-python = ">=3.13"
# dependencies = [
#     "requests>=2.33.1",
# ]
# ///

import json
import logging

import requests

from constants import (
    API_DOI,
    FIELD_MATCH_SCORE,
    FIELD_PUBTYPE,
    FIELD_VENUE,
    FIELD_YEAR,
    FIELD_AUTHORS,
    FIELD_TITLE,
    FIELD_JOURNAL,
    FIELD_DOI,
    BASE_URL,
    API_POINT,
    SCORE_CRITICAL,
    SCORE_LIMIT_BAD,
    SCORE_LIMIT_GOOD,
    SCORE_UNKNOWN,
    bcolors,
)
from comparison import compare_references
from scoring import compute_total_score

LOGGER = logging.getLogger(__name__)

RETURN_FIELDS = ",".join(
    (FIELD_TITLE, FIELD_AUTHORS, FIELD_YEAR, FIELD_VENUE, FIELD_JOURNAL, FIELD_PUBTYPE)
)


def output_reference_results(
    reference: dict,
    scores: dict,
) -> None:
    doi = reference.get(FIELD_DOI)
    title = reference.get(FIELD_TITLE)
    LOGGER.info(f"{bcolors.BOLD}Title:{bcolors.ENDC} {title}")
    LOGGER.info(f"{bcolors.BOLD}DOI:{bcolors.ENDC} {doi}")
    output_score_results(scores)
    return


def output_score_results(scores: dict) -> None:
    for _field, _score in scores.items():
        LOGGER.debug(f"Sub-score {_field}: {_score:.2f}")
    total_score = compute_total_score(scores)

    if total_score == SCORE_UNKNOWN:
        LOGGER.warning(
            f"{bcolors.WARNING}Could not find a title in the reference. Manually check it.{bcolors.ENDC}"
        )
    elif total_score == SCORE_CRITICAL:
        LOGGER.critical(
            f"{bcolors.FAIL}No match found on SemanticScholar! The reference probably does not exist or is not a published paper.{bcolors.ENDC}"
        )
    elif total_score < SCORE_LIMIT_BAD:
        LOGGER.error(f"{bcolors.FAIL}Very low score: {total_score:.2f}{bcolors.ENDC}")
    elif total_score < SCORE_LIMIT_GOOD:
        LOGGER.warning(f"{bcolors.WARNING}Low score: {total_score:.2f}{bcolors.ENDC}")
    else:
        LOGGER.info(f"Score: {total_score:.2f}")
    return


def rate_single_reference(reference: dict) -> tuple[dict, dict]:
    request_params = {"fields": RETURN_FIELDS}
    match = {}

    doi = reference.get(FIELD_DOI)
    title = reference.get(FIELD_TITLE)

    if doi is not None:
        request_url = f"{BASE_URL}/{API_DOI}{doi}"
    elif title is None:
        LOGGER.error("Could not get a title")
        scores = {FIELD_TITLE: -1}
        return scores, match
    else:
        request_url = f"{BASE_URL}/{API_POINT}"
        request_params["query"] = f"{title}"

    r = requests.get(url=request_url, params=request_params)

    if r.status_code == 404:
        LOGGER.critical(f"Could not find a match for '{title}'")
        scores = {FIELD_TITLE: SCORE_CRITICAL}
    elif r.status_code == 200:
        match = r.json()
        # print(match)
        if doi is None:
            match = match["data"][0]
            if match[FIELD_MATCH_SCORE] < 100:
                LOGGER.error("Ultra low quality match.")
                scores = compare_references(reference, match)
            elif match[FIELD_MATCH_SCORE] < 175:
                LOGGER.warning("Low quality match")
                scores = compare_references(reference, match)
        scores = compare_references(reference, match)
    else:
        LOGGER.error(
            f"Error getting response from SemanticScholar. Response code {r.status_code:d}."
        )
        scores = {FIELD_TITLE: SCORE_UNKNOWN}
    r.close()
    return scores, match


def main(references_json):
    with open(references_json, "r") as json_file:
        references = json.load(json_file)

    for idx, reference in enumerate(references):
        LOGGER.info(f"Reviewing reference [{idx + 1:d}]")
        _scores, _match = rate_single_reference(reference)
        output_reference_results(reference, _scores)


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser()
    parser.add_argument("references_json")
    parser.add_argument(
        "-v", "--verbosity", action="count", default=0, help="Increase output verbosity"
    )
    args = parser.parse_args()
    args = vars(args)
    verb = args.pop("verbosity")
    logging.basicConfig(
        format=f"%(asctime)s - [{bcolors.OKBLUE}%(levelname)8s{bcolors.ENDC}]: %(message)s"
    )
    loglevel = logging.INFO - verb * 10
    LOGGER.setLevel(loglevel)
    main(**args)