utils.py

import re
import csv
import geopy
from rdflib import Literal

def get_context(text, span, ngram_context_size=5):
    word = span["word"]
    start = span["start"]
    end = span["end"]
    label = span["entity_group"]

    # Extract context
    previous_text = text[:start].strip()
    next_text = text[end:].strip()
    previous_words = previous_text.split()[-ngram_context_size:]
    next_words = next_text.split()[:ngram_context_size]

    # Build context string
    context = f"[{word}]: {' '.join(previous_words)} {word} {' '.join(next_words)}"
    return word, context, label

def add_triplet(g, subject, predicate, obj):
    """Add the triplet (subject, predicate, obj) in graph g if not already present"""
    if subject and predicate and obj and (subject, predicate, obj) not in g:
        g.add((subject, predicate, obj))

def find_most_probable_subject(head_type, head_uri, relation_type, prev_span_type, prev_span_uri, next_span_type, relation_triplets):
    triplet_1 = (head_type, relation_type, next_span_type)
    triplet_2 = (prev_span_type, relation_type, next_span_type)
    if triplet_1 in relation_triplets and triplet_2 in relation_triplets:
        if relation_triplets[triplet_1] >= relation_triplets[triplet_2]:
            return head_uri
        else:
            return prev_span_uri
    elif triplet_1 in relation_triplets:
        return head_uri
    elif triplet_2 in relation_triplets:
        return prev_span_uri
    else:
        return  head_uri # return head uri

def identifier_distance(text):
    text = text.replace("’", "'").replace("–", "-").lower()

    # Liste des nombres en lettres simples
    nombres_lettres = [
        "un", "une", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix",
        "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf",
        "vingt", "vingt-et-un", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept",
        "vingt-huit", "vingt-neuf",
        "trente", "trente-et-un", "trente-deux", "trente-trois", "trente-quatre", "trente-cinq", "trente-six",
        "trente-sept", "trente-huit", "trente-neuf",
        "quarante", "quarante-et-un", "quarante-deux", "quarante-trois", "quarante-quatre", "quarante-cinq",
        "quarante-six", "quarante-sept", "quarante-huit", "quarante-neuf",
        "cinquante", "cinquante-et-un", "cinquante-deux", "cinquante-trois", "cinquante-quatre", "cinquante-cinq",
        "cinquante-six", "cinquante-sept", "cinquante-huit", "cinquante-neuf",
        "soixante", "soixante-et-un", "soixante-deux", "soixante-trois", "soixante-quatre", "soixante-cinq",
        "soixante-six", "soixante-sept", "soixante-huit", "soixante-neuf",
        "soixante-dix", "soixante-et-onze", "soixante-douze", "soixante-treize", "soixante-quatorze", "soixante-quinze",
        "soixante-seize", "soixante-dix-sept", "soixante-dix-huit", "soixante-dix-neuf",
        "quatre-vingt", "quatre-vingt-un", "quatre-vingt-deux", "quatre-vingt-trois", "quatre-vingt-quatre",
        "quatre-vingt-cinq", "quatre-vingt-six", "quatre-vingt-sept", "quatre-vingt-huit", "quatre-vingt-neuf",
        "quatre-vingt-dix", "quatre-vingt-onze", "quatre-vingt-douze", "quatre-vingt-treize", "quatre-vingt-quatorze",
        "quatre-vingt-quinze", "quatre-vingt-seize", "quatre-vingt-dix-sept", "quatre-vingt-dix-huit",
        "quatre-vingt-dix-neuf",
        "cent"
    ]
    pattern_nombres_lettres = r'\b(?:' + '|'.join(nombres_lettres) + r')\b'

    # 1. Nombre + unité
    pattern_complet = pattern_nombres_lettres + r'\s*(?:lieue[s]?|mille[s]?|kilomètre[s]?|pas|toise[s]?|parasange[s]?)\b|\b\d+\s*(?:lieue[s]?|mille[s]?|kilomètre[s]?|pas|toise[s]?)\b'
    match = re.search(pattern_complet, text)
    if match:
        return match.group()

    # 2. Chiffre seul
    match = re.search(r'\b\d+\b', text)
    if match:
        return match.group()

    # 3. Nombre en lettres seul
    match = re.search(pattern_nombres_lettres, text)
    if match:
        return match.group()

    return None

def identifier_cardinal(text):
    text = text.lower()
    # Liste de tuples (forme possible, cardinal normalisé)
    formes_cardinaux = [
        ('nord-ouest', 'NORD-OUEST'), ('n.o.', 'NORD-OUEST'),('n. o.', 'NORD-OUEST'),
        ('nord-est', 'NORD-EST'), ('n.e.', 'NORD-EST'),('n. e.', 'NORD-EST'),
        ('sud-ouest', 'SUD-OUEST'), ('s.o.', 'SUD-OUEST'),('s. o.', 'SUD-OUEST'),('midi occidental', 'SUD-OUEST'),
        ('sud-est', 'SUD-EST'), ('s.e.', 'SUD-EST'),('s. e.', 'SUD-EST'),
        ('nord', 'NORD'), ('n.', 'NORD'),('septentrion','NORD'),('septentrional','NORD'),('septentrionale','NORD'),('n. ', 'NORD'),
        ('sud', 'SUD'), ('s.', 'SUD'), ('midi', 'SUD'),('méridional','SUD'),('méridionale','SUD'),('s. ', 'SUD'),
        ('ouest', 'OUEST'), ('o.', 'OUEST'), ('occident', 'OUEST'), ('couchant', 'OUEST'),("l'ouest", 'EST'), ('o. ', 'OUEST'),
        ('est', 'EST'), ('e.', 'EST'), ('orient', 'EST'), ('levant', 'EST'),("l'est", 'EST'),('e. ', 'EST'),
    ]

    for forme, cardinal in formes_cardinaux:
        if forme in text:
            return cardinal

    return None

def link_to_subject_object(g, head_type, head_uri, relation_type, relation_word, prev_span, next_span, statement_uris, EKG, RDF):

    relation_triplets = {}
    with open('./assets/reference_triplet_relation.csv', mode='r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            # Création de la clé tuple
            key = (row['type_sujet'],row['relation'],row['type_objet'])
            # Conversion du count en entier
            value = int(row['count'])
            # Insertion dans le dictionnaire
            relation_triplets[key] = value
            
    prev_span_type = prev_span.get('entity_group')
    next_span_type = next_span.get('entity_group')
    if next_span_type != 'Relation':
        #print('next_span', next_span)
        subject_uri = find_most_probable_subject(head_type, head_uri, relation_type, prev_span_type, prev_span['uri'], next_span_type, relation_triplets)

        # cas où le prédicat est une distance ou une orientation
        if relation_type != "Distance-Orientation":
            stmt_uri = EKG[f"Statement{len(statement_uris)}"]

            if relation_word.lower() in statement_uris:
                key = relation_word.lower() + str(len(statement_uris))
            else:
                key = relation_word.lower()
            
            statement_uris[key] = stmt_uri
            add_triplet(g, stmt_uri, RDF.subject, EKG[subject_uri])
            add_triplet(g, stmt_uri, RDF.object, EKG[next_span['uri']])
            add_triplet(g, stmt_uri, RDF.predicate, EKG[relation_type.lower()])
        else:
            cardinal = identifier_cardinal(relation_word)
            distance = identifier_distance(relation_word)

            if cardinal:
                stmt_uri = EKG[f"Statement{len(statement_uris)}"]
                if relation_word.lower() in statement_uris:
                    key = relation_word.lower() + str(len(statement_uris))
                else:
                    key = relation_word.lower()
                statement_uris[key] = stmt_uri
                add_triplet(g, stmt_uri, RDF.subject, EKG[subject_uri])
                add_triplet(g, stmt_uri, RDF.object, EKG[next_span['uri']])
                add_triplet(g, stmt_uri, RDF.predicate, EKG['orientation'])
                add_triplet(g, stmt_uri, RDF.value, Literal(cardinal))

            if distance:
                stmt_uri = EKG[f"Statement{len(statement_uris)}"]
                if relation_word.lower() in statement_uris:
                    key = relation_word.lower() + str(len(statement_uris))
                else:
                    key = relation_word.lower()
                statement_uris[key] = stmt_uri
                add_triplet(g, stmt_uri, RDF.subject, EKG[subject_uri])
                add_triplet(g, stmt_uri, RDF.object, EKG[next_span['uri']])
                add_triplet(g, stmt_uri, RDF.predicate, EKG['distance'])
                add_triplet(g, stmt_uri, RDF.value, Literal(distance))
        

def dms_to_dd(dms):
    try:
        point = geopy.Point(dms)
        return [point[0], point[1]-17.66]
    except:
        return None

def is_partitive_expression(text, spans, i, j):
    if spans[i]['entity_group'] == 'NC_Spatial' and spans[j]['entity_group'] == 'NP_Spatial':
        boundaries = [spans[i]['end'], spans[j]['start']]
        print("####partitive boundaries",boundaries)
        if " de " in text[boundaries[0]:boundaries[1]] or " d'" in text[boundaries[0]:boundaries[1]] or " du " in text[boundaries[0]:boundaries[1]]:
            return True
    return False

def pattern_starting_article(text, spans):
    if len(spans) >= 4:
        if spans[0]['entity_group'] == 'Head':
            if spans[1]['entity_group'] == 'Domain-mark':
                if is_partitive_expression(text, spans, 2, 3):
                    return spans[3]
                elif is_partitive_expression(text, spans, 3, 4):
                    return spans[4]
            else:
                if is_partitive_expression(text, spans, 1, 2):
                    return spans[2]
                elif is_partitive_expression(text, spans, 2, 3):
                    return spans[3]
    return None



def segmentation_head(head):

    pattern = "A-Za-zîÊÉÈÀÂÎÔêÛÄËÏÖÜÇ\-'\s,().Æ"
    # XXX ou XXX ou XXX
    match = re.fullmatch(r"([{}]+)\sou\s([{}]+)\sou\s([{}]+)$".format(pattern, pattern, pattern), head, re.IGNORECASE)
    if match:
        return match.groups()
        
    # XXX,ou XXX,ou XXX
    match = re.fullmatch(r"([{}]+),\sou\s([{}]+),\sou\s([{}]+)$".format(pattern, pattern, pattern), head, re.IGNORECASE)
    if match:
        return match.groups()
       
    # XXX,XXX,XXX
    match = re.fullmatch(
        r"([{}]+),([{}]+),([{}]+)$".format(pattern, pattern, pattern),
        head, re.IGNORECASE)
    if match:
        return match.groups()

    # XXX ou XXX ou XXX ou XXX
    match = re.fullmatch(
        r"([{}]+)\sou\s([{}]+)\sou\s([{}]+)\sou\s([{}]+)$".format(pattern, pattern, pattern, pattern),
        head, re.IGNORECASE)
    if match:
        return match.groups()

    # xxx ou xxx
    match = re.fullmatch(r"([{}]+)\sou\s([{}]+)$".format(pattern, pattern), head, re.IGNORECASE)
    if match:
        return match.groups()
    
    # XXX,ou XXX
    match = re.fullmatch(r"([{}]+),\sou\s([{}]+)$".format(pattern, pattern), head, re.IGNORECASE)
    if match:
        return match.groups()
    
    
    
    list_prefixe = ["le","la","le duché de","la grande","la vieille","la neuve","le cap","le Pays de","Foret d'","îles des","l'île de","Sant","Mer","riviere de S.","S.","l'île d'","mer","la Vallée de","l'île","les","san","la forêt d'","La","la terre de","le lac","le nouveau royaume de","Golfe de","fluvius","Landgraviat de","Vallée","l'Audience de","la vallée de","la riviere de","la cité de","S. Paul de","baie de","la préfecture de","le comté de","comté de","palatinat de","San","le canton de","riviere de la","Détroit de","plaine de","la vallée de","la côte de","île de","le royaume de","détroit de","Royaume de","Péninsule de","Détroit de","Golfe","la capitainerie de","l'île de","promontorium","mons","Contrée de",
                        "Empire de","province de","royaume de","Mont","Baie de","Promontoire de","l'île","Pagus","l'électorat de","l'Archevêché de","ile","val de","mont","ville de","l'empire de","le golfe du","nouveau","le comté de","la prévôté de","le bailliage de la","l'Isle de","la canal de","l'évêché de","canal de","comté de","golfe de","la haute","la basse","Isle de","le port","temple de","lac","le quartier de","le désert de","le lac de","riviere","Vent du","Val di","duché de","lac d'","L'","l'","Promontorium","Urbs","montagne des","Montes","le cap d'","le fort d'","montagne d'","Port d'","port de l'","la nouvelle","isle d'","évêché d'","porte","voie","Le pays d'","L'Ile d'","Vallée de","mont","Cap de","isthme de","la terre des",
                        "sinus","missions du","Santa","iles","col de la","la côte de la","le bois","l'île","St. Martin du","la vallée de","île de","l'exarchat de","san","sierras de","portus","le fleuve","isla de los","le cap de","île","el Rio","la rivière","la vallée des","les piscines de","le golfe de","le marquisat de","les iles","l'ile de","mare dio","Mer de","l'Isle de","cercle de","le cercle de la haute","le cercle de la basse","golphe de la","Cap","les îles de","San Nicolo di","nome","montagnes de","pointe de la","lac","cap","Rio de","palatinat de","rocher de","isle","mons","canton de","les iles","le mont","détroit de la","îles de la","îles","région des","lago della","val de","montagne de","détroit du","orum","cap","les îles de","saltus","campi","l'île du","Pic de","Isle de","l'étang de","Grottes de la","le lac de","la mer de","bosphore de","Flumen","îles des","viguerie de","île de la","le cap de","moines de la","quatier de","archevêché de","bois sacré de",
                        "la cité de la","pays des quatre","fontaine de","pays de","port de","état de","Motte de","les quatre","pays de","golphe","duché d'","détroit d'","seigneurie d'","isles","église de","salle de","l'ile","principauté de","île d'","cap de","isle de l'","Isle de l'"]
    list_saint = ["saint","sainte","Saint","Sainte","San","san","sant","Sant","S.","St.","St","Saint-","saint-","sainte-","Sainte-"]
    
    # XXX, XXX
    match = re.fullmatch(r"([{}]+),([{}]+)$".format(pattern, pattern), head, re.IGNORECASE)
    if match:

        label1, label2 = match.groups()
        # remove leading and trailing spaces
        label1 = label1.strip()
        label2 = label2.strip()
        print("***************label1,label2:[",label1,"][", label2,"]")
        if label2 not in list_prefixe and label2 not in list_saint:
            return [label1, label2]
        else:
            return [label2+" "+label1]

    # XXX (xxx)
    match = re.fullmatch(r"([{}]+)\s\(([{}]+)\)$".format(pattern, pattern), head, re.IGNORECASE)
    if match:
        nom, prefixe = match.groups()
        nom = nom.strip()
        prefixe = prefixe.strip()
        if prefixe not in list_saint:
            return [nom, prefixe+" "+nom]
        else:
            return [prefixe+" "+nom]


    #XXX,(xxx)
    match = re.fullmatch(r"([{}]+),\(([{}]+)\)$".format(pattern, pattern), head, re.IGNORECASE)
    if match:
        nom, prefixe = match.groups()
        nom = nom.strip()
        prefixe = prefixe.strip()
        if prefixe not in list_saint:
            return [nom, prefixe+" "+nom]
        else:
            return [prefixe+" "+nom]

    # XXX le/les/...
    match = re.fullmatch(r"([{}]+)\s(L'|la nouvelle|Vallée d'|isles de l'|isles des|l'ile de|la|colonnes d'|Monts|le|les|Les|les îles d'|l'Isle de|Baie d'|lac des|l'|lac d'|Sant|isle|Isle|mare|val|la terre|Santa|Colonia|île de la|Golfe|mons|terre des|palus|San|Mont|royaume de|sinus|alpes|Montes|flumen|Nemaviae|lucus|portus|aquae|pays de|la vallée de|isles de Scopelo|le cap de|vicus|cap de|Civitas|porte|insula|terre de|le chatel|san|lac|promontorium|oppidum|Iles|état de|ville de|la rade de|templum|fanum|le grand|le petit|Préfecture de|le comté de|l'île de|bailliage d'|comté de|regio)$", head,
                          re.IGNORECASE)
    if match:
        nom, prefixe = match.groups()
        nom = nom.strip()
        prefixe = prefixe.strip()
        if prefixe not in list_saint:
            return [nom, prefixe + " " + nom]
        else:
            return [prefixe + " " + nom]