Utilisateur:Youni Verciti Bot/Scripts

 vcb.py

 vcbscan.py

 vcbformat.py

 international.py

Le script va scanner les pages dans l'espace de nom donné en argument, chercher le vocabulaire dans les modèles 'traductions' et 'prononciations', créer la liste dans Département/Index_vocabulaire/vcb-Nom_de_la_page.

#!/usr/bin/python
# -*- coding: latin-1 -*-

import urllib, re, sys, pywikibot, codecs # PWB now
from vcbscan import *
from vcbformat import *
from international import *
srv="https://fr.wikiversity.org/w/api.php" # Adresse du serveur API
site = pywikibot.Site('fr', u'wikiversity') ### Variables PWB The site we want to run our bot on
arg1 = sys.argv[1]
uArg1 = unicode(arg1, 'utf-8') # Encodage den UNICODE pour PWB 
lPath = pathname(arg1, srv)

[name, rootName, lastName, nbName, lSec, linker] = lPath
[className, titleS, linkTo, link, reLink, retplk, defaultKey ] = linker
print className
# Si Chapitre liste = arg1
# Si Leçon fonction shortliste appliquée à query=allfiles
# Si departement ufileList lpage
# Si none undefine => leçon

reClassName = re.compile(className)

title = uArg1 # L'espace de nom passé en ligne de commande
page = pywikibot.Page(site, title)
### Variables API
# TOUS LES MODÊLES CONTENUS DANS LA PAGE Parse templates
# rqParseTpl = '?action=parse&format=xml&page=%s&prop=templates' % name
rqRootLang = '?action=languagesearch&format=xml&search=%s' % rootName
fromPage = arg1
toPage = arg1 + 'a'
rqAllPages = '?action=query&list=allpages&format=xml&apfrom='+fromPage+'&apto='+toPage+'&aplimit=275'
rqParseWkt = '?action=parse&format=xml&page=%s&prop=wikitext&contentdataZone=wikitext' % arg1 # REQUETE PARSE Format XML content WIKITEXT

### RECHERCHE PAGELANG
sts = str(site)
i=sts.find(':')
sts = sts[i+1:]
pageLang = sts
### RECHERCHE ROOTLANG
askRootLang = srv + rqRootLang
objr = urllib.urlopen(askRootLang)
varf = objr.read()
strl1 = str(varf)
reRootLang = re.compile('languagesearch":{"\w*"')
moRootLang = reRootLang.search(strl1)
rootLang = moRootLang.group()
rootLang = rootLang[ 18 : len(rootLang)-1 ]
print rootLang + '-' + pageLang 
###
strLog = '' # Variable pour le journal
lAudio = [] # Liste pour la 3ème colonne de modèle Prononciation
globalDict = {} # Dictionnaire global 
###
fileList = urllib.urlopen(srv + rqAllPages) ### ATTENTION Si Dept, Leçon, Chap: liste des fichiers à traiter
vfileList = fileList.read()
ufileList = unicode(vfileList, 'utf-8')
#allFiles = len(ufileList) # Liste de TOus les fichiers dans l'espace de nom fournit en argument

rePg=re.compile('title=".*"') # recherche du nom de page
rePron = re.compile('[P|p]rononciation\w*') # recherche le modèle
reTrad = re.compile('[T|t]raduction\w*') # ''
reEq = re.compile('=') # recherche des parametres
l1 = re.compile('langue1') # First raw (filtre param Langue1)
l2 = re.compile('langue2') # Second raw ('' langue2)

### Analyse ufileList pour créer liste de page lPage
listePg = ufileList.split('>') # divise pour filtre nom page
lPage = [] # liste pour pages
for l in listePg: # pour chaque chaine dans xml listePg
  moPg = rePg.search(l)   # Cherche le titre
  if moPg:                # 
    p=moPg.group()        # 
    cp = p[7:len(p)-1]    # filtre la chaine nom de page
    lPage.append(cp)      # enregistre liste des pages
allFiles = len(lPage) # Voir nbPages
if className == 'Leçon': # L 
  lPage = shortlist(lPage, arg1)   # Filtre les fichiers de la leçon

### Analyse modèles de chaque page, creation de listes distinctes pour chaque modèle, 
lPron = [] # Liste des modèles Prononcition
lTrad = [] # Liste des modèles Traduction
for p in lPage: # chaque pages
  title = p
  page = pywikibot.Page(site, p)
  gen = page.templatesWithParams() # liste les modèles et contenu
  linkIn = 'none'
  if gen:# si  modeles
    for g in gen: #pour chaque item du generator
      a = g[0] # a le nom de la pge du modele
      b = g[1] # b a liste des params
      stra = str(a)
      moTrad = reTrad.search(stra) # cherche trad dans liste des modele
      if moTrad:
	lTrad.append(g) # si trad enregistre dans LISTE TRAD
      moPron = rePron.search(stra)
      if moPron:
	lPron.append(g) # si pron enregistre dans LISTE PRON
nbPages = len(lPage)
nbPron = len(lPron)
nbTrad = len(lTrad)
part1Log = str(nbPages) + ' pages\n' + str(nbPron) + ' modèle PRON, ' + str(nbTrad) + ' modèle TRAD\n'
strLog = strLog + part1Log
print strLog
print '### Les Listes sont prêtes ###' # On a une liste pour chaque modele


if nbPron > 0:
  for l in lPron: # LPRON
    # Ce modèle propose une qutrimr colonne transcritpion
    # quand cette 4èmme colonne existe
    # les données ne sont pas collectée cf strLog
    a = l[0] # Nom du modele
    lb = l[1] # Liste des parametres
    lrm = []  # liste des elemennts à supprimer
    count = 1 # initialise le compteur
    for b in lb:  # pour chaque parametre
      i = lb.index(b)  # calcul l'index du parametre
      moEq = reEq.search(b)   # cherche symbol egual, param nommé
      if moEq: # Si le param est nommé
	pass 
      else:  # c’est une cellule
	if count % 3 == 0: # si elle est multiple de trois
	 lAudio.append(b) # copie dans la liste lAudio
	 lrm.append(b) # copie dans liste à supprmer
      count =count + 1     # prochain param
    for rm in lrm:   #  chaque element
      lb.remove(rm)   # est supprimé
    lTrad.append(l)   # copie les param restants dans lTrad
  # Il faudrait detecter la quatrième colonne si existe

nbMod = len(lTrad)
strLog = strLog + str(nbMod) + ' modèles à traiter\n'

if nbMod > 0:
  for l in lTrad: # LTRAD
    a = l[0]      # le nom du modèle
    lb = l[1]     # la liste des paramètres
    lParam = []   # Nouvelle liste pour les parametres nommés
    raw1 = rootLang   # initialise les langues
    raw2 = pageLang   # avec paramètres par défaut
    for b in lb:    # PARAMETRES
    # print b ATTENTION API retourne lzh pour chinois mais wikversité utilise zh
      moEq = reEq.search(b)   # cherche symbole egual parm nommés
      if moEq:    # Si symbol
        lParam.append(lb.index(b))   # enregistre son index dans liste lParam
        mol2 = l2.search(b) # Cherche langue2
        if mol2:   # SI langue2
	 spl2 = b.split('=') # split sur symbol=
	 raw2 = spl2[1] # enregistre dans raw2
	 raw2 = raw2.strip() # retire éspaces inutiles
        mol1 = l1.search(b)   # Cherche langue1
        if mol1:   # SI langue1
          spl1 = b.split('=') # split egual
	 raw1 = spl1[1] # stock valeur
	 raw1 = raw1.strip() # enleve espaces
    cdl = raw1+'-'+raw2  # variable cdl = langue1-langue2
    #lb.append(cdl)  # place cdl dans la liste (dernière position # ATTENTION on deplace cdl dans tplParam
    iMaxData = min(lParam) # Calcul dernière donnée = premier paramètre nommé ???
    data = lb[0:iMaxData]   # Calcul la zone de données
    nbCel = len(data)
    tplParam = [cdl, iMaxData, nbCel]
    lb.append(tplParam)
    
    
    if nbCel %2 <> 0:
      lastCel = lb[iMaxData-1]
      print '######'
      print lastCel
      print '#######'
      reSpaces = re.compile('\s\n') # resoud le cas Anglais/Grammaire/Conjugaison/Impératif
      # Attention le problème reste relatif à la 4ème colonne de prononciation
      moSpaces = reSpaces.match(lastCel)
      if lastCel == '':
        print 'DERNIERE CELLULE VIDE A DETRUIRE'
        # resoud le cas de la dernière cellule vide sans espaces ni saut de ligne
        # il reste à supprimer l'element de la liste lb
      if moSpaces:
        print 'Celule vide à détruire'
        print moSpaces.group()
        #lb.remove[lastCel]
        
    if cdl == rootLang + '-' + pageLang and nbCel % 2 == 0: # Si defaut
      for d in data:   # Pour chaque donnée dans dataZone
        if data.index(d) % 2 == 0:   # si son index est paire
	 iTmp = data.index(d)+1 # Calcul index prochaine valeur
	 tmp = data[iTmp] # tmp = prochaine valeur
	 globalDict[d] = tmp # Dictionnaire Global reçoit mot_PT : mot_FR
        else:   #   ce n’est pas une clé
	 pass
    elif cdl == pageLang + '-' + rootLang and nbCel % 2 == 0:   # INVERSE fr-pt
      for d in data:
        if data.index(d) % 2 == 0:   # si son index est paire
	 iTmp = data.index(d) + 1
	 tmp = data[iTmp] # tmp = prochaine valeur
	 globalDict[tmp] = d # On inverse d et tmp dans le dictionnaire
        else: # IMPAIR PASS
          pass
    else:
      errorLog = 'Template error:\nVérifier le nombre de cellules: '
      print errorLog
      print nbCel
      # si nbCel impair alors verifier si dernière cellule vide
      error2 = 'Titres de colonnes: \n'
      print cdl
      print page #Affiche page erronée
      print a
      print data
      # chinois code langue sur 3 caractères tronque le l, lzh devient zh
      #tplErrorLog = unicode(str(page), 'utf-8') +'\n'+ unicode(str(lb), 'utf-8') +'\n'
      #print  tplErrorLog
      #strLog = strLog + errorLog + tplErrorLog
ligd = len(globalDict)
strLog = strLog + str(ligd) + ' lignes dans dictionnaire global\n'

### Traitement des APOSTROPHES et des espaces inutiles
finalDict = {}
for t in globalDict:
  v = globalDict[t]
  t = aposoff(t)
  v = aposoff(v)
  t = t.strip()
  v = v.strip()
  finalDict[t] = v

# On aff¡che le resultat contenu dans tupCleaned
#for g in sorted(tupCleaned):
  #v = tupCleaned[g]
  #print g
  #print v
nbLine = len(finalDict)

wlp = divdict(finalDict)
[tupWord, tupLocution, tupPhrase] = wlp

chkword(tupLocution, tupWord) 

for lang in langPack:
  pack = langPack[lang]
  if lang == rootLang:
    chkarticle(tupLocution, tupWord, pack)
  else:
    print ' Pas de langPack'

words = len(tupWord)
locutions = len(tupLocution)
phrases = len(tupPhrase)
format1Log = str(words) + ' mots, ' + str(locutions) + ' locutions, ' + str(phrases) + ' phrases.\n'
strLog = strLog + format1Log

secW = ''
for k in sorted(tupWord): 
  v = tupWord[k]
  kSplit = k.split()
  kSize = len(kSplit)
  if kSize ==2: # Deux mots dans la clé, l’article est en seconde position
    if ',' in k:
      kCut = k.split(',')   # on split sur la virgule et on cré les liens avec premier element du split
      line = '* [[wikt:' + rootLang +':'+ kCut[0] + '|' + k + ']] : [[wikt:' + kCut[0] + '#'+ rootLang + '|' + v + ']]<br />\n'
      secW = secW +line
    else: # Deux mots sans virgule
      line = u'* [[wikt:' + rootLang +u':'+ kSplit[0] + u'|' + k + u']] : [[wikt:' + kSplit[0] + u'#' + rootLang + u'|' + v + u']]<br />\n'
      secW = secW +line
  else: # Un seul mot dans la clé création des liens wikt
    line = u'* [[wikt:'+ rootLang + u':' + k + u'|' + k + u']] : [[wikt:' + k + u'#' + rootLang + u'|' + v + u']]<br />\n'
    secW = secW +line

secL = linesans(tupLocution)
secP = linesans(tupPhrase)

scriptName = sys.argv[0]
writePack = [scriptName, allFiles, nbMod, nbLine, uArg1, secW, secL, secP]

if nbLine < 5:
  print 'Pas suffisament de données pour créer une page. Minimum 5 lignes.'
  print nbLine
else:
  txtin = writelist(writePack)
  comment = 'Indexation automatique du vocabulaire pour les langues étrangères. Youni Verciti Bot'
  print u'Page à publier:       ' + titleS
  page = pywikibot.Page(site, titleS)
  page.text = txtin
  try:
    page.save(comment)
  except:
    print 'Pas sauvegardé, pas de lien'
  else:
    print 'Beleza muleque, agora vai criar o atalho.'
    print 'Hote du lien à créer:  ' + linkTo
    print link
    print defaultKey

print '### Log: ###'
print strLog

Fonctions principales

#!/usr/bin/python
# -*- coding: latin-1 -*-
import re, urllib, pywikibot

### SHORTLIST
def shortlist(mylist, arg1) :
  shortList = []    # Liste pour les pages à traiter
  subFolder = ['Annexe', 'Exercices', 'Fiche', 'Quiz', 'Travail_pratique'] # LES DOSSIERS DES LEÇONS
  prefix = arg1 + '/'       # declare prefix pour tronquer la première partie
  for page in mylist:   
    for sub in subFolder:
      argSub = arg1 + '/' + sub
      if re.match(argSub, page):   # si la ligne commence par argv1/sub
        shortList.append(page)       # place la page dans la liste
  for page in mylist:
    if re.match(prefix, page):   # on gardera la page racine
      moPlace = re.match(prefix, page)   
      iMoPlace =  moPlace.end()  #index de la fin du prefix
      page = page[iMoPlace : ]    #tronque le prefix
      if '/' in page:   # Si il reste une barre oblique : sous dossier, on ne traitera pas
        pass             # on ne traite pas les sous dossiers
      else:
        shortList.append(arg1 + '/' + page)   # On place la page dans PAGESHORTLIST
  return shortList 

### PATHNAME sépare l'argument initial en élements du path
def pathname(name, srv):
  rqParseWkt = '?action=parse&format=xml&page=%s&prop=wikitext&contentdataZone=wikitext' % name   # REQUETE PARSE Format XML content WIKITEXT
  objf = urllib.urlopen(srv + rqParseWkt)   # Ouvre l'url dans l'objet
  varf = objf.read()              # Lit le contenu dans la variable.
  objf.close()                    # ferme l’objet url
  strfile = str(varf)
  ufile = unicode(varf, 'utf-8')
  reLesson = re.compile('{{[L|l]eçon')   # ATTENTION probleme ecodage unicode sur le ç de leçon
  reChapitre = re.compile('{{[C|c]hapitre')
  splName = name.split('/')
  nbName = len(splName)   ### -2 (rootname et lastname ex: rootname/nSec1/nSec2/lastname)
  rootName = splName[0]
  lastName = splName[nbName -1]
  lSec = []
  for sname in splName[1:splName.index(lastName)]:
    lSec.append(sname)
  lPath = [name, rootName, lastName, nbName, lSec]
  uSec=''
  for sec in lSec:
    uSec = uSec + u'/' + sec
  moLesson = reLesson.search(strfile)
  moChapitre = reChapitre.search(ufile)
  if nbName == 1:
    print ' La cible est un département'
    className = 'Département'
    titleS = rootName + '/Index vocabulaire/vcb-Global'
    linkTo = rootName + '/Leçons par thèmes'
    link = '[['+ titleS + '| Index du vocabulaire]]'
    retplk = ''
    reLink = re.compile(titleS)
    defaultKey = ''
  elif moLesson:
    className = 'Leçon'    
    titleS = rootName + '/Index vocabulaire/vcb-' + lastName
    linkTo = rootName + '/Index vocabulaire/Inventaire des fiches'
    link = '{{F|vcb-'+lastName   # chercher la ligne commençant par {{F|¿?
    retplk = re.compile('[F|f]iche\s*=')
    reLink = re.compile(link)
    defaultKey = 'fiche = '  
    moLink = reLink.search(strfile)
    if moLink:
      print 'Le lien existe: '
      print moLink.group()
    else : 
      motplk = retplk.search(strfile)
      if motplk:
	print 'Attention la leçon contient une fiche: \n'
	print motplk.group()
	print 'Placer le lien dans la leçon manuellement'
      else:
	print 'On peut envisager de créer le lien dans le modèle leçon'
	
  elif moChapitre:
    print moChapitre.group()
    print 'La cible est un chapitre'
    className = 'Chapitre'    
    titleS = rootName + '/Index vocabulaire/vcb-'+ lastName
    linkTo = rootName + '/Index vocabulaire/Inventaire des fiches'
    link = '[[' + rootName + '/Index vocabulaire/vcb-'+ lastName
    retplk = re.compile('page_liée\s*=')
    reLink = re.compile(titleS)
    defaultKey = 'page_liée = '
    moLink = reLink.search(strfile)
    motplk = retplk.search(strfile)
    if moLink:
      print 'Le lien est en place'
      print moLink.group()
    else:
      if motplk:
	print 'Attention une page liée: '
	print motplk.group()
	print 'Etablir le lien manuellement'
      else:
	print 'On peut écrire le lien: '
	print defaultKey + link 
	print 'Le modèle Chapitre est infernal et le paramètre page_liée un cauchemar.'
	print 'cibler la page rootName/Index vocabulaire/Inventaire des fiches'
  else:
    print 'Le type de cible est indéfini, none'
    className = 'none'
    titleS = rootName + '/Index vocabulaire/vcb-' + lastName
    linkTo = rootName + '/Index vocabulaire/Fiches vocabulaire'
    print lSec
    for sec in lSec:
      print sec
    link = titleS
    reLink = re.compile(link)
    retplk=''
    defaultKey=''
  linker = [className, titleS, linkTo, link, reLink, retplk, defaultKey]
  lPath.append(linker)
  #print cible
  return lPath
### PATHNAME FIN

Fonctions de mise en forme des listes

#!/usr/bin/python
# -*- coding: latin-1 -*-
import re, urllib, pywikibot, datetime

### USTR transforme en string puis unicode
def ustr(myvar):
  mystr = str(myvar)
  myu = unicode(mystr, 'utf-8')
  return myu

### DEF APOSOFF
def aposoff(instr): # Apostrophe_Off(Inside_String) enleve les '' et ''' de la chaine
  reAps = re.compile('\'{2,3}')
  nbApo = len(re.findall(reAps, instr))   # nombre d'item
  if nbApo > 0:   # SI apostrophes dans mystr
    filAps = re.finditer(reAps, instr)    # Find Iter List les occurences  regex '' et '''
    iDeb = 0      # debut de la recherche
    cleaned = ''  # initialise la chaîne pour recevoir la clé sans apostrophe de formatage
    n=1           # initialise le compteur de boucle
    for l in filAps:   # POUR CHAQUE mo in fil
      if n < nbApo:       # TANT QUE ce n’est pas le dernier
	clean = instr[iDeb:l.start()] # Calcul le debut sans aps
        cleaned = cleaned + clean       # Ajoute la section debut sans aps à la mystr cleaned
        iDeb = l.end()                  # Position de départ pour le prochain tour de boucle = après le dernier aps
        n=n+1                           # Compteur de tours
      else:               # On arrive au dernier aps
        clean = instr[iDeb:l.start()]   # calcul le debut sans aps
        fin = instr[l.end():]           # calcul la fin sans aps
        cleaned = cleaned + clean + fin # ajoute le début et la fin à la mystr cleaned
        cleaned = cleaned.strip()       # Enleve espace inutile
    instr = cleaned
  else:          # SANS aposoff
    cleaned = instr.strip()   # cleaned est identique à instr
  return cleaned   # Renvoi la version sans apostrophe de instr
### APOSOFF FIN

### DIVDICT Divise le dictionnaire global en 3 
def divdict(myDict):
  tupWord = {} # stockage des mots simples
  tupLocution = {} # stockage des clés de plus de 2 mots
  tupPhrase = {}   # traitement des clés de plus de 5 mot
  wlp = [tupWord, tupLocution, tupPhrase]
  # En premier detecter phrases selon premìere majuscule et dernier point
  # Enlever le couple de tupLesson pour le copier dans tupPhrase
  reMaj = re.compile('[A-Z]')   # Une majuscule alnum
  rePoint = re.compile('\.\Z')    # Un point à la fin de la chaîne
  kToDelete = []           # Liste pour stocker les clé à supprimer de tupLocution
  if len(myDict) > 0:
    for k in myDict:   # Pour chauqe cle dans tupLocution
      moMaj = re.match(reMaj, k)   # Commence par une majuscule alphanumerique
      moPoint = re.search(rePoint, k)  # Termine par un point (ajouter exclamation et interrogation)
    if moMaj and moPoint:   # Si Majuscule début et point final
      tupPhrase[k] = myDict[k]    # copie le couple dans tupPhrase
      kToDelete.append(k)   # Stock k dans liste à supprimer
    for k in kToDelete:
      del myDict[k]    # enlève les phrases courtes du tupLocution
    for k in myDict: # Pour chaque clé
      v = myDict[k]  # definition de sa valeur
      kSplit = k.split()   # découpe la clé en nombre de mots
      kSize = len(kSplit)  # calcul le nombre de mot dans la clé
      if kSize > 5:   # Si plus de 5 mots dans la clé
        tupPhrase[k] = v   # Copie dans tupPhrase
      else:   #SINON
        if kSize > 1: # SI plus que 1 mot dans la clé
          tupLocution[k] = v   # On copie dans tupLocution
        else: # SINON
          tupWord[k] = v   # On copie dans tupWord
    wlp = [tupWord, tupLocution, tupPhrase]
  return wlp
### DIVDICT FIN

### CHECK WORDS
# Certaines occurrences de tupLocution seront re-affectées à tupWord
# Tester si ksize = 2 et virgule ou articles. Si oui affecter à tupWrd
def chkword(locution, word):
  kToDelete = []   # Liste de clés à detruire après déplacement
  for k in locution:    # Chaque clé de tupLocution
    kSplit = k.split()     # Listes les mots
    kSize = len(kSplit)    # Calcul le nbre de mots
    if kSize ==2:      # Si DEUX mots
      if ',' in k:       # Et une virgule
        word[k] = locution[k] # Déplace dans tWord
        kToDelete.append(k)         # Enregistre la clé à detruire
      
  for k in kToDelete:    # Pour chaque clé à supprimer
    del locution[k]      # Enlève les couples article/mots du tupLocution
### Gérer les couples qui commencent par un mot entre parentèses (os)
### Gérer les occurences dont chaque mot est séparé par virgules
### Observer les listes des autres dept
### Tester si article+1mot+virgule


### Lignes sans liens
def linesans(locuPhrase):
  sectionSans = ''
  if len(locuPhrase ) > 0:
    for k in sorted(locuPhrase):
      v = locuPhrase[k]
      lineSans = '* ' + k + ' : '+ v + '<br />\n'
      sectionSans = sectionSans + lineSans
  return sectionSans
### Lignes sans Fin

### ECRITURE DE LA LISTE A PUBLIER
def writelist(dataPack):
  [scriptName, allFiles, nbMod, nbLine, uArg1, secW, secL, secP] = dataPack
  now = datetime.date.today()   # PASSER AU FORMAT FRANÇAIS
  tnow = str(now)               # pour écrire la date 
  head1 = '<small> Liste auto. script: ' + scriptName + ' - Date: ' + tnow + ' - ' + ustr(allFiles) + ' pages - '
  head2 = str(nbMod) + ' modèles - ' + str(nbLine) + ' lignes.</small><br />'
  head2 = unicode(head2, 'utf-8')
  #head2 = unicode(str(nbMod), 'utf-8') + ' modèles - ' + ustr(nbLine) + ' lignes.</small><br />'
  backLink = 'Retour: [[' + uArg1 + ']]\n' # Lien pour retourner à la leçon
  txtin = head1 + head2 + backLink
  if secW <> '':
    section1 = '== Mots ==\n<div style="-moz-column-count:2; column-count:2;">\n'
    txtin = txtin + section1 + secW
  if secL <> '':
    section2 = '</div>\n== Locutions ==\n'
    txtin = txtin + section2 + secL
  if secP <> '':
    section3 = '== Phrases ==\n'
    txtin = txtin + section3 + secP
  #txtin = headDraft+suite+backLnk + section1 + secW + section2 + secL + section3 + secP
  return txtin

Détection des articles, ajout des variables spécifiques à la langue.

#!/usr/bin/python
# -*- coding: latin-1 -*-
import re, urllib, pywikibot, datetime

langPack = {}


### PORTUGAIS: Liste des articles
genre = re.compile('[o|a]\\s') # ATTENTION PARAMETRES REGIONAUX
mplur = re.compile('os\\s') # ATTENTION REMPLACER PAR LES ARTICLES DE LA LANGUE ÉTUDIÉE
fplur = re.compile('as\\s') # ATTENTION
um = re.compile('um\\s') # ATTENTION
uma = re.compile('uma\\s') # ATTENTION
ptPack= [genre, mplur, fplur, um, uma] # Les articles de la langue portugaise
langPack['pt']= ptPack

## Check langPack
def chkarticle(locution, word, pack):
  kToDelete = []
  for k in locution:    # Chaque clé de tupLocution
    kSplit = k.split()     # Listes les mots
    kSize = len(kSplit)    # Calcul le nbre de mots
    if kSize ==2:      # Si DEUX mots
      for article in pack:    # Pour chaque regex article dans...
        moArticle = article.match(k)     # Cherche l’article en debut de chaine
        if moArticle:              # Si la clé commence par un article
          newKey = kSplit[1] + ' (' +kSplit[0] + ')'   # newKey déplace l’article après le nom
          word[newKey] = locution[k]             # tupWord reçoit newKey
          kToDelete.append(k)                          # On enregistre la clé à supprimer
        else: # pas d’article à gérer
          pass
    #
  for k in kToDelete:    # Pour chaque clé à supprimer
    del locution[k]      # Enlève les couples article/mots du tupLocution