Utilisateur:Youni Verciti Bot/Scripts old

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
#!/usr/bin/python
# -*- coding: latin-1 -*-

import urllib, re, datetime, sys # bibliotheque d'instructions de base, sys pour le nom du script et sys.argv ; datetime pour la date du jour
srv="https://fr.wikiversity.org/w/api.php" # Adresse du serveur API
arg1 = sys.argv[1] # Argument de la ligne de commande _arg1

### LISTE DES PAGES À TRAITER
urlPlace = arg1 # Place in wikiversity 
rq = '?action=query&list=allpages&format=xml&apprefix=%s&aplimit=100' % arg1 # REQUETE on à augmenté aplimit à 100 pour ne pas avoir besoin de gérer apcontinue
# ATTENTION générer un message si CONTINUE c-a-d si plus de 100 pages dans la reponse
fullurl = srv + rq
objl = urllib.urlopen(fullurl) # Ouvre l'objet
varl = objl.read() # Lit le contenu dans la variable.
objl.close() # Ferme l'objet
strl = str(varl) # convertit la variable en string texte

### CHERCHE LASTNAME, ROOTNAME DANS L'URL
urlist = urlPlace.split('/') # découpe l'url dans _urlist
iLastName = len(urlist) - 1 # Calcul la valeur de indice.max via len
lastName = urlist[iLastName] # Extrait la dernière valeur de la liste soit le nom de la leçon ou du chapitre
nameLog = lastName + 'log' # Déclare le nom du fichier log
log = open(nameLog, 'w') #Ouverure d'un fichier local pour journaliser
strLog = '' # Variable texte pour journal Log

### RECHERCHE LANGUE1 & LANGUE2
rqLang = '?action=query&prop=info&format=xml&titles=/%s' % arg1
askLang = srv + rqLang
objLang = urllib.urlopen(askLang)
readLAng = objLang.read()
strLang = str(readLAng)
reLang = re.compile('pagelanguage="\S*"')
moLang = reLang.search(strLang)
ch0 = moLang.group()
pageLang = ch0[ 14 : len(ch0)-1 ]
rootName = urlist[0] # pas de / au début
rqRootLang = '?action=languagesearch&format=xml&search=%s' % rootName
askRootLang = srv + rqRootLang
objr = urllib.urlopen(askRootLang)
varf = objr.read()
strl1 = str(varf)
reRootLang = re.compile('languagesearch":{"\w*"')
moRootLang = reRootLang.search(strl1)
ch1 = moRootLang.group()
rootLang = ch1[ 18 : len(ch1)-1 ]
print rootLang + '-' + pageLang 

### SHORTLIST
lFile = strl.split('\"') # liste de fichiers de la leçon passée en argument 1
pageShortList = [arg1,] # 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 f in lFile: 
  for sub in subFolder:
    argSub = arg1 + '/' + sub
    if re.match(argSub, f):   # si la ligne commence par argv1/sub
      pageShortList.append(f)       # place la page dans la liste
for page in lFile:
  if re.match(prefix, page):   # on gardera la page racine
    moPlace = re.match(prefix, page)   
    iMoPlace =  moPlace.end()  #index de la fin du prefix
    ch0 = page[iMoPlace : ]    #tronque le prefix
    if '/' in ch0:   # Si il reste une barre oblique : sous dossier, on ne traitera pas
      pass             # on ne traite pas les sous dossiers
    else:
      pageShortList.append(arg1 + '/' + ch0)   # On place la page dans PAGESHORTLIST
pagesLog = '### La liste des pages à traiter est prête ### - Nombre de page(s): ' + str(len(pageShortList)) + '\n'
strLog = strLog + pagesLog

###### Seconde partie : TRAITEMENT DES PAGES
### REGEX pour recherche et analyse de modèle
l1 = re.compile('langue1.*') # First raw
reEgual = re.compile('=') # Symbol egual =
l2 = re.compile('langue2.*') # Second raw
ret = re.compile('[T|t]itre\w*') # French title
ref = re.compile('en-tête\w*') # find a best re for this
rea = re.compile('align=\w*') # param pour aligner traductions
rei = re.compile('noindex') # param pour empecher indexation
param = [l1, l2, ret, ref, rea, rei] # Liste des parametres
rePron = re.compile('{{[P|p]rononciation\w*') # Regex modèle Traductions 
reTrad = re.compile('{{[T|t]raduction\w*')    # Regex modèle Prononciationd
closeTag = re.compile('}}') # patern fin du modèle
reSep = re.compile('\\|') # patern du separateur
modIn = re.compile('{{') # Pour vérifier l'absence de modèle ouvrant entre les bornes de notre modèle.
oLnk = re.compile('\\[\\[') # Open Link
cLnk = re.compile('\\]\\]') # Close Link
tupLesson = {} # Tuple de la leçon alimenté par les pages 
now = datetime.date.today() # date d'execution du script VOIR SI CURENTTIME RESOLVE
tnow = str(now) # pour écrire la date dans le log
totalMod = 0

### DEFINITION DES FONCTIONS ###
# FLIM defini les bornes du modèle
def flim(itor):
  for i in itor:
    iStart = i.start()
    iLabel = i.end()
    moClose = closeTag.search(strf, iStart)
    iClose = moClose.start() 
    lParam = [iLabel, iClose]
    model = strf[iLabel : iClose]
    mocmi = modIn.search(model)  # 
    if mocmi:   # Si model inside
      print '###################################'
      modlInsideLog = 'Detection de modèle à linterieur, ce modèle n\'est pas pris en compte'
      print modlInsideLog
      print model
      print '###################################'
    else:   # SANS Model inside
      iParList = []
      for p in param:        # Pour chaque parametre
	mop = p.search(model) # Cherche Regex dans modèle answer to MatchObject mop
	if mop:
	 iParam = mop.end() # indexer la position à la fin du parametre
	 iParList.append(iParam)
      # Sortie de boucle
      if len(iParList) == 0:
	zeroParamLog = 'Aucun parametre ou probleme de detection voir saut de ligne dans param. iHEad prend la valeur de iLabel.'
	print zeroParamLog
	iHead = iLabel
	print model
      else:
	lastParam = max(iParList)
        iHead = iLabel + lastParam
      lParam.append(iHead)
      tMod[iStart] = lParam
      dataZone = strf[iHead:iClose]
      #print dataZone
      mol2 = l2.search(model) # Match Object langue2 dans le modèle answer to _mol2
      if mol2:
        ch2 = mol2.group()   # placer la reponse dans raw2 (colonne2)
        moEgual = reEgual.search(ch2)
        nextSep = reSep.search(ch2)
        if nextSep:
	 iNext = nextSep.start()
	else :
	 iNext = mol2.end()
        if moEgual:
	 i = moEgual.end()
	 raw2 = ch2[i:iNext] # Tronque à partir du symbol =
	 raw2 = raw2.strip()
	else:
	 noeql2Log = 'Ne trouve pas le signe = dans langue2' + model
	 strLog = strLog + noeql2Log
      else:   # Pas de parametre langue2
        raw2 = pageLang      # Si le param n’est pas defini on utilise pageLang
      mol1 = l1.search(model)   # Cherche langue1
      if mol1:             # Si parametre
        ch1 = mol1.group()   # Place sa valeur dans raw1
        moEgual = reEgual.search(ch1)
        nextSep = reSep.search(ch1)
        if nextSep:
	 iNext = nextSep.start()
	else :
	 iNext = mol1.end()
        if moEgual:
	 i = moEgual.end()
	 raw1 = ch1[i:iNext] # tronque à partir du symbol egual langueX= extrait la variable
	 raw1 = raw1.strip()
	else:
	 noeql1Log = ' Pas de symbol egual dans la variable langue1 - ROOTLANG OFF'
	 print mol1.group()
	 print model
	 strLog = strLog + noeql1Log + page
	 
      else:                # Pas de parametre l1 dans le model
	nol1 = 'ATTENTION: Paramètre Langue1 manquant, rootLang off'
	strLog = strLog + nol1 + page
      lParam.append(raw1)   # ajoute raw1 à la liste des paramètres
      lParam.append(raw2)   # ajoute raw2 à la liste des paramètres
    # Condition Sana Modele Inside sortie
  # for i in itor # Sortie de boucle
# FLIM FIN

# DEF CHKLNK
def chkLnk(intuple): # Fonction pour repérer les liens et gerer le separateur
  for t in tMod:
    iStart = t
    lParam = tMod[t]
    iLabel, iClose, iHead, raw1, raw2 = lParam
    dataZone = strf[iHead : iClose]
    lSep=[]          # Dećlaration liste sep
    moSep = reSep.finditer(dataZone)  # Cheche les sep dans dataZone
    for m in moSep:    # Pour chaque sep
      iSep = m.start() # Calcul son index
      lSep.append(iSep)   # Enregistre son index dans lSep
    loLnk = oLnk.finditer(dataZone) # Cherche lien ouvrant [[
    lNoSep = []   # initialise la liste des non separateur de cellule
    for l in loLnk: # Chaque debut de lien
      i = l.start() # index du debut
      short = dataZone[i:] # filtre la chaine à partir de i
      closePos = cLnk.search(short)  # Cherche la position fermant
      endLink = closePos.start()     # Calcul la position fermant
      link = dataZone[i : i+endLink] # Chaine du lien
      # print link # DEBUG
      moLnk = reSep.search(link)     # Cherche separateur dans lien
      if moLnk:  # Si un separateur dans le lien
	noSep = moLnk.start() # enregistre sa position dans le lien
	iNoSep = i + noSep # calculer la position relative aux bornes de dataZone
	lSep.remove(iNoSep) # Enleve le non-sep de la liste
      #Chaque debut de lien
    # Chaque model
    lParam.append(lSep)   # Enregistre la liste dans lParam
    tMod[iStart] = lParam # Enregistre lParam dans tMod
  # print tMod # Sortie de boucle
# CHKLNK FIN
# 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   # cleaned est identique à instr
  return cleaned   # Renvoi la version sans apostrophe de instr
# APOSOFF FIN

# LISTOTUP lModWord to tupMod
def listotup(liste):
  #print raw1
  #print raw2
  if raw1 == rootLang and raw2 == pageLang:   # Si les titres de colonnes ont la valeur attendue
    for l in liste:
      if liste.index(l) % 2 == 0:    # Si son index est paire
	iNext = liste.index(l)+1 # Calcul l'index prochain dans _nextWord
        v = liste[iNext]
	#print l + ' DATA clé l'
        #print v + '  valeur du prochain'
        tupMod[l] = v  # On entre dans tupMod la clé avec index paire et mot suivant comme value
      else:
	pass # l est une valeur
  elif raw1 == pageLang and raw2 == rootLang: # Inverse langue1 & 2
    for l in liste:
      if liste.index(l) % 2 == 0:    # Si son index est paire c’est une valeur
        ik = liste.index(l)-1   # Calcul l'index de la clé
        k = liste[ik]   # La clé est le mot précedent dans la liste
        #print k + '  DATA clé k'
        #print l + '  Valeur l'
        tupMod[k] = l # On place la clé k, et l comme valeur dans _tupMod
      else:
        pass # l est une valeur
  else: # LOG 
    badRawTitle = 'Les colonnes ont des titres inatendus: \n' + str(raw1) + '\n' + str(raw2) + '\n'
    #strLog = strLog + badRawTitle

### TRAITEMENT DES PAGES
for page in pageShortList: # POUR CHAQUE PAGE
  rqparse='?action=parse&format=xml&page=%s&prop=wikitext&contentmodel=wikitext' % page   # REQUETE PARSE Format XML content WIKITEXT
  objf = urllib.urlopen(srv+rqparse)   # Ouvre l'url dans l'objet
  varf = objf.read()              # Lit le contenu dans la variable.
  objf.close()                    # ferme l’objet url
  strf = str(varf)                # convertit la variable en string texte _strf
  #log.write(page + '\n')      # PAGE LOG INFO
  print page                  # Affiche le nom de la page traitée
  strLog = strLog + page + '\n'   ### Tentative de concatener tous les log message dans la mème chaine
  tMod = {}    # Tuple de la page pour position debut et fin de chaque modèle
  limit1 = rePron.finditer(strf)  # Cherche modèles Prononciation
  limit2 = reTrad.finditer(strf)  # Cherche modèles Traduction
  tupPage = {}  
  flim(limit1) # La fonction Limites sur Pron
  flim(limit2) # La fonction Limites sur Trad
  nbMod = len(tMod) # Le nombre de modèle sur la page
  if nbMod > 0:   # Si presence de modele dans page
    print str(nbMod) + ' ###'
  chkLnk(tMod) # La fonction Check link sur tMod
  lWord = []   # La liste des mots
  lPronunc = []   # La liste pour fichiers audio
  if nbMod > 0:
    strLog = strLog + 'Nb Modèle Page: ' + str(nbMod) +'\n' #n+ 'Nb Sep' + str(len(lSep))
  for t in tMod: # Pour chaque  Modele
    iStart = t
    iLabel, iClose, iHead, raw1, raw2, lSep = tMod[t]
    model = strf[iStart:iClose]
    dataZone = strf[iHead:iClose]
    label = strf[iStart:iLabel]
    nbSep = len(lSep)
    tupMod = {}
    if rePron.match(label):   # Si modèle PRONONCIATION
      lModWord = []
      if nbSep % 3 == 0:
        count = 1   # Compteur de cellules
        for sep in lSep:
	 if count < nbSep: # Tant que ce n’est pas le dernier
	 nextSep = lSep[count] # Calcul position du prochain separateur, FIN
	 nxt = sep+1 # Calcul la position suivante, DEBUT
	 thisWord = dataZone[ nxt : nextSep ] # Calcul le mot
	 thisWord = thisWord.strip() # retire ESPACES INUTILES
	 # print thisWord DEBUG
	 if count % 3 == 0: # Si multiple de trois
	 lPronunc.append(thisWord) # Place dans la liste audio
	 else : # Sinon c’est une clé ou une valeur
	 lModWord.append(thisWord) # On place dans lWord
	 count = count + 1 	 # Incrémente le compteur
	 else: # Dernière cellule
	 lastWord = dataZone[ sep + 1 : len(dataZone) ] # On filtre defini lastWord
	 # print lastWord DEBUG
	 lastWord = lastWord.strip() # retire ESPACES INUTILES
	 lPronunc.append(lastWord) # Le denier est forcément multiple de trois on place dans lPronunc 
	listotup(lModWord) # La fonction ordonne les clé/valeur dans tupMod
	for t in tupMod:
	 tupPage[t] = tupMod[t] # on copie dans tupPage
      else:
	chkMod = 'Le modèle Prononciation contient un nombre de cellules incompatible\n' + model
	strLog = strLog + chkMod
    elif reTrad.match(label):   # TRADUCTION
      lModWord = []
      if nbSep % 2 == 0:   # Nombre de cellules valide
	c = 1
	for sep in lSep:
	 if c < nbSep: #
	 nextSep = lSep[c] # position du prochain sep
	 nxt = sep+1 #e position suivant
	 thisWord = dataZone[ nxt : nextSep ]
	 thisWord = thisWord.strip() # retire ESPACES INUTILES fonction intégrée
	 # print thisWord #DEBUG
	 lModWord.append(thisWord)
	 c=c+1
	 else:
	 lastWord = dataZone[ sep + 1 : len(dataZone) ] # On filtre data dans chlast avec index s+1 et _dataMax
	 # print lastWord # DEBUG
	 lastWord = lastWord.strip() # retire ESPACES INUTILES fonction intégrée
	 lModWord.append(lastWord) 
        listotup(lModWord) # La fonction ordonne les clé / valeur dans tupMod
        for t in tupMod:
	 tupPage[t] = tupMod[t] # On copie dans tupPage
      else:# LOG print 'Probleme nb cel'
	badNbSep = label + ' Le nombre de cellule: ' + str(nbSep) + '\n' + model + '\n'
	strLog = strLog + badNbSep
    else:  # LOG
      modInside = ' ATTENTION, un modèle dont le label ne correspond ni à Pron, ni à Trad.\n' + model
      strLog = strLog + modInside
    # print tupMod # DEBUG FIN MODELE
  for t in tupPage:
    tupLesson[t] = tupPage[t] # On copie TupPage dans tupLesson
  # LOG FIN DE PAGE
  totalMod = totalMod + nbMod   # Total des modèles trouvés
  if nbMod > 0:
    pageLog = 'Nb Model: ' + str(nbMod) + ' sur ' + str(totalMod) + ' Nb de lignes: ' + str(len(tupLesson)) + ' Audio: ' + str(len(lPronunc)) + '\n'
    strLog = strLog + pageLog
print '----------Fin du traitement des pages-----------' ### Afficher le nbre de page scané
totaLine = len(tupLesson) # LOG INFO nb line in lesson tuple
endLog = 'TOTAL Model: ' + str(totalMod) + ' TOTAL de lignes: ' + str(totaLine) + ' Audio: ' + str(len(lPronunc))
strLog = strLog + endLog
print strLog

###### PRESENTATION DES DONNEES avant publication
## Enleve les apostrophes de tupLesson dans tupCleaned
tupCleaned = {}
for t in tupLesson:
  v = tupLesson[t]
  t = aposoff(t)
  v = aposoff(v)
  tupCleaned[t] = v
## On divise tupCleaned en trois: tupWord, tupLocution, tupPhrase pour editer 3 listes différentes
tupPhrase = {} # traitement des clés de plus de 5 mot
tupLocution = {} # stockage des clés de plus de 2 mots
tupWord = {} # stockage des mots simples
# En premier detecter phrases selon premìere majuscule et dernier point
# Enlever le couple de tupLesson pour le copier dans tupPhrases
re1 = re.compile('[A-Z]') # Une majuscule alnum
re2 = re.compile('\.\Z') # Un point à la fin de la chaîne
kToDelete = [] # Liste pour stocker les clé à supprimer de tupLocution
for k in tupCleaned: # Pour chauqe cle dans tupLocution
  mo1 = re.match(re1, k)   # Commence par une majuscule alphanumerique
  mo2 = re.search(re2, k)  # Termine par un point (ajouter exclamation et interrogation)
  if mo1 and mo2:   # Si Majuscule début et point final
    tupPhrase[k] = tupCleaned[k]    # copie le couple dans tupPhrase
    kToDelete.append(k)   # Stock k dans liste à supprimer
for k in kToDelete:
  del tupCleaned[k]    # enlève les phrases courtes du tupLocution
# Ensuite on divise le reste selon le nbre de mots dans word, locut ou phrase
for k in tupCleaned: # Pour chaque clé
  v = tupCleaned[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
# Certaines occurrences de tupLocution seront re-affectées à tupWord
# Tester si ksize = 2 et virgule ou articles. Si oui affecter à tupWrd
genre = re.compile('[o|a]\\s') # ATTENTION PARAMETRES EGIONAUX
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
artigos = [genre, mplur, fplur, um, uma] # Les articles de la langue portugaise
kToDelete = [] # Liste de clés à detruire après déplacement
for k in tupLocution: # Chaque clé de tupLocution
  kSplit = k.split()     # Listes les mots
  kSize = len(kSplit)    # Calcul le nbre de mot
  if kSize ==2:      # Si DEUX mots
    if ',' in k:       # Et une virgule
      tupWord[k] = tupLocution[k] # Déplace dans tWord
      kToDelete.append(k)         # Enregistre la clé à detruire
    for a in artigos:    # Pour chaque regex article
      mo = a.match(k)     # Cherche l’article en debut de chaine
      if mo:              # Si la clé commence par un article
	newKey = kSplit[1] + ' (' +kSplit[0] + ')' # newKey déplace l’article après le nom
	tupWord[newKey] = tupLocution[k] # tupWord reçoit newKey
	kToDelete.append(k) # On enregistre la clé à supprimer
for k in kToDelete: # Pour chaque clé à supprimer
  del tupLocution[k]      # Enlève les couples article/mots du tupLocution
### Tester si article+1mot+virgule

### ECRITURE DU BROUILLON
## En-tête
draftFile = lastName + '-draft'
draft = open(draftFile, 'w') #Ouverure d'un fichier local pour écrire le brouillon
draft.write('<small> Liste auto. script: ') 
draft.write(sys.argv[0]) # nom du script
draft.write(' - Date: ' + tnow + ' - ')
draft.write(str(len(pageShortList)) + ' pages - ' + str(totalMod) + ' modèles - ') # nombre de pages, de modèle traité
draft.write(str(totaLine) + ' lignes </small><br />') # nbLigne dans le tuple de la leçon
draft.write('Retour à la leçon: [[' + arg1 + ']]\n') # Lien pour retourner à la leçon
draft.write('== Mots ==\n')
draft.write('<div style="-moz-column-count:2; column-count:2;">\n')
## Liste des mots
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
      draft.write('* [[wikt:' + rootLang +':'+ kCut[0] + '|' + k + ']] : [[wikt:' + kCut[0] + '#'+ rootLang + '|' + v + ']]<br />\n')
    else: # Deux mots sans virgule
     draft.write('* [[wikt:' + rootLang +':'+ kSplit[0] + '|' + k + ']] : [[wikt:' + kSplit[0] + '#' + rootLang + '|' + v + ']]<br />\n')
  else: # Un seul mot dans la clé création des liens wikt
    draft.write('* [[wikt:'+ rootLang + ':'+k +'|' + k + ']] : [[wikt:'+ k + '#'+ rootLang + '|' + v + ']]<br />\n')
draft.write('</div>\n')
## Liste des locutions
draft.write('== Locutions ==\n')
for k in sorted(tupLocution):
  v = tupLocution[k]
  kList = k.split()
  draft.write('* ' + k + ' : '+ v + '<br />\n')
    ### Il reste des ameliorations (retrais des (s) et (x...))
## Liste des phrases
draft.write('== Phrases ==\n')
for k in sorted(tupPhrase): 
  v = tupPhrase[k]
  draft.write('* ' + k + ' : '+ v + '<br />\n')
draft.close()
### Check les nombres de lignes dans les Dictionnaires
print ' Verifier nbre de ligne dans tupLesson et tupCleaned:'
print len(tupLesson)
print len(tupCleaned)
print 'Vérifier nbre de ligne dans Word, locut et phrase et total:'
print 'Mots: ' + str(len(tupWord)) + ' - Locutions: ' + str(len(tupLocution)) + ' - Prases: ' + str(len(tupPhrase))
totalTup= len(tupWord) + len(tupLocution) + len(tupPhrase)
print totalTup
# Créer un lien dans /Vocabulaire/Index classé en fonction du chemin d'accès à la leçon
# Niveau1/Niv2/Page avec NiveauX=TitreX
# Chercher modèle Leçon dans la page passée en argument
# Chercher variable fiche dans {{Leçon
# Chercher string vcb-Leçon dans {{Leçon
## Créer le lien vers fiche ./vcb_Leçon
## Créer la page ./vcb_Leçon
### Rediriger vcb-Leçon vers ./Vocabulaire/Index/vcb-Leçon


## Verifier les données dans le log 
## Executer zedit.py qui va ecrire le contenu du log, fichier local
## dans une page du type Département/Vocabulaire/vcb-Leçon

Le second sript ecrit le brouillon dans la page

#!/usr/bin/python
# -*- coding: utf-8 -*-
import pywikibot, codecs, sys
site = pywikibot.Site('fr', u'wikiversity') # The site we want to run our bot on
draftFile = unicode(sys.argv[1], 'utf-8')
title = u'Portugais/Vocabulaire/Index/vcb-' + draftFile # ATTENTION vous allez écrire ce fichier
#title2 = 'Utilisateur:Youni Verciti/Newfile'

page = pywikibot.Page(site, title)
text = page.text
myfile = open(draftFile + '-draft', 'r') # ATTENTION u'nomdulog'
myvar = myfile.read()
myfile.close()
mytxt = str(myvar)
uni = unicode(mytxt, 'utf-8') # UNICODE

comment = 'Premiers tests du robot Youni Veciti Bot'
test = u"Difficile d\'écrire avec un robot!"

page.text = uni
page.save(comment)