Convertir un thésaurus sous forme de liste alphabétique en SKOS

#!/usr/bin/env python

import argparse
import itertools
from pathlib import Path

import pyparsing as pp


def gen_id():
    counter = itertools.count(start=1)

    def new_counter():
        return f"{next(counter):010}"

    return new_counter


def extract_thesaurus(alpha_thesaurus):
    lines = Path(alpha_thesaurus).read_text()

    EOL = pp.LineEnd().suppress()
    term = pp.Regex("[^a-z:,\(\)\n]{2,}").setResultsName("term")
    entry = pp.LineStart() + term.setResultsName("entry") + EOL
    thes_op = pp.oneOf(["TG", "TS", "TA", "EM", "Employé pour", "Définition"])
    thes = (
        thes_op.setResultsName("thes")
        + pp.Literal(":").suppress()
        + pp.SkipTo(entry | thes_op).setResultsName("entry")
    )
    line = thes | entry

    r = line.searchString(lines)

    final_thesaurus = {}
    promosanthes_id = gen_id()
    for e in r:
        if len(e) == 1:
            last_entry = e[0]
            final_thesaurus.setdefault(last_entry, {}).update({"id": promosanthes_id()})
        if len(e) == 2:
            if e[0] in ("TA", "TG", "TS", "EM"):
                final_thesaurus[last_entry][e[0]] = [
                    value.strip()
                    for value in e[1].strip().replace("\n", " ").split(",")
                ]
            else:
                final_thesaurus[last_entry][e[0]] = e[1].strip().replace("\n", " ")

    for term, data in final_thesaurus.copy().items():
        final_thesaurus[term]["term"] = term
        tg_id = []
        for tg in data.get("TG", []):
            if tg in final_thesaurus:
                tg_id.append(final_thesaurus[tg]["id"])
        final_thesaurus[term]["TG"] = tg_id

        ts_id = []
        for ts in data.get("TS", []):
            if ts in final_thesaurus:
                ts_id.append(final_thesaurus[ts]["id"])
        final_thesaurus[term]["TS"] = ts_id

        ta_id = []
        for ta in data.get("TA", []):
            if ta in final_thesaurus:
                ta_id.append(final_thesaurus[ta]["id"])
        final_thesaurus[term]["TA"] = ta_id

        em_id = []
        for em in data.get("EM", []):
            if em in final_thesaurus:
                em_id.append(final_thesaurus[em]["id"])
        final_thesaurus[term]["EM"] = em_id

    return final_thesaurus


def convert2skos(thes, skos_filename):
    with Path(skos_filename).open("w") as skos:
        skos.write(
            """@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
@prefix thesaurus: <http://localhost/thesaurus/skos/term#> .

"""
        )
        for term in thes.values():
            skos.write(f"thesaurus:{term['id']} a skos:Concept ;\n")
            for b in term["TG"]:
                skos.write(f"  skos:broader thesaurus:{b} ;\n")
            for n in term["TS"]:
                skos.write(f"  skos:narrower thesaurus:{n} ;\n")
            for r in term["TA"]:
                skos.write(f"  skos:relatedMatch thesaurus:{r} ;\n")
            skos.write(f'  skos:prefLabel "{term["term"]}"@fr .\n')
            skos.write("\n")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Generating synonyms for Elasticsearch based on a SKOS file (Turtle representation)."
    )

    parser.add_argument(
        "-t",
        "--thesaurus",
        help="Specifiy the filename for the thesaurus.",
        required=True,
    )
    parser.add_argument(
        "-s",
        "--skos",
        help="Specifiy the filename where to output the SKOS version of the thesaurus.",
        required=False,
    )
    args = parser.parse_args()

    thesaurus = extract_thesaurus(args.thesaurus)
    convert2skos(thesaurus, args.skos)