Extraction.py

from prettytable import PrettyTable

class Extraction:
    sentences = []
    candidates = []
    simpleTerms = {}
    cplxTerms = {}         #Tous les termes extraits avec leurs scores
    terms = []             #Liste des nb Termes finaux,


    def __init__(self, sentences):
        self.sentences = sentences

    # Verifie si un mot est contenu dans un terme
    def contient(self, contenant, contenu):
        # Verifie que le mot contenu est un mot entier dans la phrase, et pas une partie d'un autre mot
        i = contenant.find(contenu)
        ln = len(contenu)

        if i != -1:
            # LES CHAINES SONT EGALES
            if ln == len(contenant):
                return 1

            # DEBUT DE LA PHRASE
            if i == 0:
                if contenant[i + ln].isalpha():
                    return 0
                else:
                    return 1

            # FIN DE PHRASE
            elif i + ln == len(contenant):
                if contenant[i - 1].isalpha():
                    return 0
                else:
                    return 1

            # MILIEU DE PHRASE
            elif contenant[i + ln].isalpha() | contenant[i - 1].isalpha():
                return 0
            else:
                return 1
        else:
            return 0

    # extrait les termes candidats qui sont soit des noms, soit des adjectifs, soit une combinaison de noms et d'adjectifs
    def extract_candidate_terms(self):
        prev = "NULL"
        for sentence in self.sentences:
            for token in sentence:
                if not token.is_stop and not token.is_punct:
                    if token.pos_ == 'ADJ' or token.pos_ == 'NOUN':
                        if len(self.candidates) != 0:
                            if self.contient(str(self.candidates[-1]), str(prev)):
                                self.candidates[-1] = str(self.candidates[-1]) + " " + str(token)
                            else:
                                self.candidates.append(token.lemma_)
                        else:
                            self.candidates.append(token.lemma_)
                prev = token

    # CALCULE LE NOMBRE DE MOTS DANS UN MOT CLE
    def nbMots(self, phrase):
        i = 0
        for token in phrase.split():
            i += 1
        return i

    # Calcule la frequence et le degre des termes simples (mots)
    def calcFreqDeg(self):
        self.simpleTerms = {}
        for token in self.candidates:
            degre = self.nbMots(token) - 1  # LE DEGRE EST LE NOMBRE DE MOTS EN COLLOCATION AVEC LE MOT ETUDIE
            for child in token.split():
                if child not in self.simpleTerms:
                    self.simpleTerms[child] = [0, 0, 0]
                # Incrémentation du score du terme
                self.simpleTerms[child][0] += 1
                self.simpleTerms[child][1] += degre

    # Calcule le score des mots (freq*degre)
    def calcScores(self):
        self.calcFreqDeg()
        for term, score in self.simpleTerms.items():
            if score[1] == 0:  # SI LE DEGRE EST NUL
                score[2] = score[0]  # LE SCORE EST EGAL A LA FREQUENCE
            else:
                score[2] = score[0] * score[1]  # SINON C'EST LA SOMME DE LA FREQUENCE ET DU DEGRE

    # Execute les deux fonctions precedentes
    def calcSimpleTerms(self):
        self.simpleTerms = self.calcFreqDeg()
        self.calcScores()

    # Calcule les scores des termes complexes a partir des scores des termes simples
    def calcCplxTerms(self):
        if self.simpleTerms == {}:
            self.calcSimpleTerms()

        for token in self.candidates:
            self.cplxTerms[token] = 0
            for child in token.split():
                self.cplxTerms[token] += self.simpleTerms[child][2]

    def extractTerms(self, limite, tri="Score"):
        self.extract_candidate_terms()
        self.calcCplxTerms()
        self.sortTerms(tri)
        self.terms = list(dict(self.cplxTerms).keys())[:limite]

    def sortTerms(self, tri="Score", rev=None):
        sortedTerms = {}
        if tri == "Score":
            if rev is None:
                rev = True
            sortedTerms = sorted(self.cplxTerms.items(), key=lambda x: x[1], reverse=rev)

        elif tri == "Terme":
            if rev is None:
                rev = True
            sortedTerms = sorted(self.cplxTerms.items(), key=lambda x: x[0], reverse=rev)

        self.cplxTerms = sortedTerms


    def printTerms(self, light=False):
        print(self.terms)

    def getTerms(self):
        return self.terms

def printTable(terms, light=False):
    # Create a new table object with the column headers
    table = PrettyTable()

    if isinstance(terms, dict):
        if light == True:
            lightTerms = {}
            for key, value in terms.items():
                if value != 1:
                    lightTerms[key] = value

        table.field_names = ["Term", "Score"]
        # Add the terms and their scores to the table
        for term, score in lightTerms.items():
            table.add_row([term, score])

    else:
        table.field_names = ["Term"]
        # Add the terms to the table
        for term in terms:
            table.add_row([term])

    # Print the table
    print(table)