Utilisateur:Youni Verciti Bot/Scripts old
#!/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'exécution 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 éditer 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 élément 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 écrit 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)