main.utils¶

def parse_bibtex_file(full_biblatex: str, entry_type: str = "article") -> dict[str, dict[str, list[str]]]:
    """Parse BibTeX file and extract conference or journal data.

    Args:
        full_biblatex: Path to the BibLaTeX file.
        entry_type: Type of entry to parse - 'article' or 'inproceedings'.

    Returns:
        Dictionary containing parsed conference or journal data.

    Raises:
        ValueError: If entry_type is not 'article' or 'inproceedings'.
    """
    if entry_type not in ["article", "inproceedings"]:
        raise ValueError("entry_type must be 'article' or 'inproceedings'")

    config = {
        "article": {
            "prefix": "J_",
            "pattern": r"@article\{(.*?),\s*([^@]*)\}",
            "full_field": "journaltitle",
            "abbr_field": "shortjournal",
        },
        "inproceedings": {
            "prefix": "C_",
            "pattern": r"@inproceedings\{(.*?),\s*([^@]*)\}",
            "full_field": "booktitle",
            "abbr_field": "eventtitle",
        },
    }

    cfg = config[entry_type]
    content = read_str(full_biblatex)
    entries = re.findall(cfg["pattern"], content, re.DOTALL)

    result_dict = {}
    for cite_key, entry_content in entries:
        # Process only entries with the specified prefix
        if not cite_key.startswith(cfg["prefix"]):
            continue

        # Extract full and abbreviation fields
        full_match = re.search(cfg['full_field'] + r"\s*=\s*{" + r"(.*)" + "}", entry_content)
        abbr_match = re.search(cfg['abbr_field'] + r"\s*=\s*{" + r"(.*)" + "}", entry_content)

        if not full_match:
            continue

        full = full_match.group(1).strip()
        abbr = abbr_match.group(1).strip() if abbr_match else full

        # Remove case-protection
        full = full.replace("{", "").replace("}", "")
        abbr = abbr.replace("{", "").replace("}", "")

        parts = cite_key.split("_")
        if len(parts) >= 3:
            key = parts[1]

            # Check if key already exists
            if key in result_dict:
                existing_entry = result_dict[key]

                # Only add if full name is not already present
                if full not in existing_entry["names_full"]:
                    existing_entry["names_abbr"].append(abbr)
                    existing_entry["names_full"].append(full)
            else:
                # New key - add to dictionary
                result_dict[key] = {"names_abbr": [abbr], "names_full": [full]}

    return result_dict

def process_user_conferences_journals_json(full_json_c: str, full_json_j: str) -> tuple[dict, dict]:
    """Process user-defined conferences and journals JSON files.

    Notes:
        The structure of full_json_c follows the format
            {"publisher": {"conferences": {"abbr": {"names_abbr": [], "names_full": []}}}},
        while full_json_j adheres to the format
            {"publisher": {"journals": {"abbr": {"names_abbr": [], "names_full": []}}}}.
    """
    # Process user conferences JSON file
    json_dict = load_json_file(full_json_c)
    full_abbr_inproceedings_dict = {}

    # Try different possible keys for conferences section in JSON structure
    for flag in ["conferences", "Conferences", "CONFERENCES", "conference", "Conference", "CONFERENCE"]:
        full_abbr_inproceedings_dict = {p: json_dict[p].get(flag, {}) for p in json_dict}
        if full_abbr_inproceedings_dict:
            break

    # Flatten the nested dictionary structure to {abbr: value} format
    # Convert from {publisher: {abbr: data}} to {abbr: data}
    full_abbr_inproceedings_dict = {abbr: v[abbr] for v in full_abbr_inproceedings_dict.values() for abbr in v}
    # Standardize the structure to ensure consistent format
    # Extract only usefull information ("names_full" and "names_abbr")
    full_abbr_inproceedings_dict = {
        k: {"names_full": v.get("names_full", []), "names_abbr": v.get("names_abbr", [])}
        for k, v in full_abbr_inproceedings_dict.items()
    }

    # Process user journals JSON file
    json_dict = load_json_file(full_json_j)
    full_abbr_article_dict = {}

    # Try different possible keys for journals section in JSON structure
    for flag in ["journals", "Journals", "JOURNALS", "journal", "Journal", "JOURNAL"]:
        full_abbr_article_dict = {p: json_dict[p].get(flag, {}) for p in json_dict}
        if full_abbr_article_dict:
            break

    # Flatten the nested dictionary structure to {abbr: value} format
    # Convert from {publisher: {abbr: data}} to {abbr: data}
    full_abbr_article_dict = {abbr: v[abbr] for v in full_abbr_article_dict.values() for abbr in v}
    # Standardize the structure to ensure consistent format
    # Extract only usefull information ("names_full" and "names_abbr")
    full_abbr_article_dict = {
        k: {"names_full": v.get("names_full", []), "names_abbr": v.get("names_abbr", [])}
        for k, v in full_abbr_article_dict.items()
    }

    # Return both processed dictionaries
    return full_abbr_inproceedings_dict, full_abbr_article_dict

def read_str(full_file: str) -> str:
    """Read file content as string.

    Args:
        full_file: Path to the file to read.

    Returns:
        Content of the file as string.
    """
    with open(full_file, encoding="utf-8", newline="\n") as file:
        content = file.read()
    return content