Utilisateur:JackBot/formatage.py

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
#!/usr/bin/env python
# coding: utf-8
# Ce script formate les pages de la Wikiversité :
# 1) Il retire les clés de tri devenues inutiles.
# 2) Il complète les modèles {{Chapitre}} à partir des {{Leçon}}.
# 3) Ajoute {{Bas de page}}.
# Reste à faire :
# 4) Remplir les {{Département}} à remplir à partir des {{Leçon}}.
# 5) Compléter les {{Bas de page}} existants.

# Importation des modules
import catlib, pagegenerators, os, codecs, urllib, re, hyperlynx
from wikipedia import *

# Déclaration
language = "fr"
family = "wikiversity"
mynick = "JackBot"
site = getSite(language,family)
debogage = False
CorrigerModeles = False
sizeT = 3
sizeP = 12

temp = range(1, sizeT)
Ttemp = range(1, sizeT)
temp[1] = u'numero'
Ttemp[1] = u'numéro'

# Modèle:Chapitre
param = range(1, sizeP)
param[1] = u'titre ' # espace pour disambiguiser
param[2] = u'idfaculté'
param[3] = u' leçon'
param[4] = u'page'
param[5] = u'numero'
param[6] = u'précédent'
param[7] = u'suivant'
param[8] = u'align'
param[9] = u'niveau'
param[10] = u'titre_leçon'

# Modification du wiki
def modification(PageHS):
	summary = u'[[Aide:Syntaxe|Autoformatage]]'
	PageEnd = "" # On sauvegarde la partie traitée d'une page provisoire dans une page finale jusqu'à disparition de la première
	page = Page(site,PageHS)
	print(PageHS.encode(config.console_encoding, 'replace'))
	if page.exists():
		try:
			PageBegin = page.get()
		except wikipedia.NoPage:
			print "NoPage"
			return
		except wikipedia.IsRedirectPage:
			print "Redirect page"
			return
		except wikipedia.LockedPage:
			print "Locked/protected page"
			return
	else:
		print u'Page inexistante'
		return
	PageTemp = PageBegin
	
	# Clés de tri
	sizeR = 7
	regex = range(1, sizeR+1)
	regex[1] = ur'()\n{{[Cc]lé de tri[^}]*}}'
	regex[2] = ur'({{[Cc]hapitre[^}]*)\| *clé *=[^}\|]*'
	regex[3] = ur'({{[Ll]eçon[^}]*)\| *clé *=[^}\|]*'
	regex[4] = ur'({{[Cc]ours[^}]*)\| *clé *=[^}\|]*'
	regex[5] = ur'({{[Dd]épartement[^}]*)\| *clé *=[^}\|]*'
	regex[6] = ur'({{[Ff]aculté[^}]*)\| *clé *=[^}\|]*'
	
	for p in range(1,sizeR-1):
		if re.search(regex[p], PageTemp):
			PageTemp = re.sub(regex[p], ur'\1', PageTemp)
			if summary.find(u'clé de tri') == -1: summary = summary + u', retrait de la clé de tri'

	# Remplacements consensuels
	#if page.namespace() != 0 and page.namespace() != 106 and page.namespace() != 108 and page.title() != u'Utilisateur:JackBot/test' and page.title() != u'Utilisateur:JackBot/test/test2': 
	#	return
	
	for p in range(1,sizeT-1):
		if PageTemp.find(u'{{' + temp[p] + u'|') != -1 or PageTemp.find(u'{{' + temp[p] + u'}}') != -1:
			PageTemp = PageTemp[0:PageTemp.find(temp[p])] + Ttemp[p] + PageTemp[PageTemp.find(temp[p])+len(temp[p]):len(PageTemp)]
		#p=p+1
		
	# http://fr.wikiversity.org/wiki/Catégorie:Modèle_mal_utilisé
	if CorrigerModeles == True:
		if PageTemp.find('{Chapitre') != -1 or PageTemp.find('{chapitre') != -1:
			''' Bug du modèle tronqué :
			if re.compile('{Chapitre').search(PageTemp):
				if re.compile('{Chapitre[.\n]*(\n.*align.*=.*\n)').search(PageTemp):
					i1 = re.search(u'{{Chapitre[.\n]*(\n.*align.*=.*\n)',PageTemp).end()
					i2 = re.search(u'(\n.*align.*=.*\n)',PageTemp[:i1]).start()
					PageTemp = PageTemp[:i2] + u'\n' + PageTemp[i1:]
				PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
				PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
			elif re.compile('{chapitre').search(PageTemp):
				if re.compile('{chapitre[.\n]*(\n.*align.*=.*\n)').search(PageTemp):
					i1 = re.search(u'{{chapitre[.\n]*(\n.*align.*=.*\n)',PageTemp).end()
					i2 = re.search(u'(\n.*align.*=.*\n)',PageTemp[:i1]).start()
					PageTemp = PageTemp[:i2] + u'\n' + PageTemp[i1:]
				PageEnd = PageTemp[0:PageTemp.find(u'{{chapitre')+len(u'{{chapitre')]
				PageTemp = PageTemp[PageTemp.find(u'{{chapitre')+len(u'{{chapitre'):len(PageTemp)]
				
				if re.compile('{{Chapitre[\n.]*(\n.*leçon.*=.*\n)').search(PageTemp):
					print "leçon1"
				if re.compile('{{Chapitre.*\n.*\n.*(\n.*leçon.*=.*\n)').search(PageTemp):
					print "leçon2"
				if re.compile('{{Chapitre.*\n.*\n.*\n.*(\n.*leçon.*=.*\n)').search(PageTemp):
					print "leçon3"
				if re.compile('{{Chapitre[.\n]*(\n.*niveau.*=.*\n)').search(PageTemp):
					print "niveau"
					print re.compile('{{Chapitre[.\n]*(\n.*niveau.*=.*\n)').search(PageTemp)
				if re.compile('{{Chapitre[.\n]*(\n.*précédent.*=.*\n)').search(PageTemp):
					print "précédent"
				if re.compile('{{Chapitre[.\n]*(\n.*suivant.*=.*\n)').search(PageTemp):
					print "suivant"
			else: # Pas de modèle chapitre
				print u'Pas de chapitre dans :'
				print (PageHS.encode(config.console_encoding, 'replace'))
				return
			raw_input (PageTemp.encode(config.console_encoding, 'replace'))'''

			Lecon = u''
			# Majuscule
			if PageTemp.find(u'Leçon') != -1 and PageTemp.find(u'Leçon') < 100:
				PageTemp2 = PageTemp[PageTemp.find(u'Leçon'):len(PageTemp)]
				Lecon = Valeur(u'Leçon',PageTemp)
			# Minuscule
			elif PageTemp.find(u'leçon') != -1 and PageTemp.find(u'leçon') < 100:
				PageTemp2 = PageTemp[PageTemp.find(u'leçon'):len(PageTemp)]
				Lecon = Valeur(u'leçon',PageTemp)
			#raw_input (Lecon.encode(config.console_encoding, 'replace'))
			
			if Lecon.find(u'|') != -1:
				Lecon = Lecon[0:Lecon.find(u'|')]
			while Lecon[0:1] == u'[':
				Lecon = Lecon[1:len(Lecon)]
			while Lecon[len(Lecon)-1:len(Lecon)] == u']':
				Lecon = Lecon[0:len(Lecon)-1]
			if (Lecon == u'../' or Lecon == u'') and PageHS.find(u'/') != -1:
				Lecon = PageHS[0:PageHS.rfind(u'/')]
			#raw_input (Lecon.encode(config.console_encoding, 'replace'))
			
			if Lecon != u'' and Lecon.find(u'.') == -1: 
				page2 = Page(site,Lecon)
				if page2.exists():
					if page2.namespace() != 0 and page2.title() != u'Utilisateur:JackBot/test': 
						return
					else:
						try:
							PageLecon = page2.get()
						except wikipedia.NoPage:
							print "NoPage"
							return
						except wikipedia.IsRedirectPage:
							PageLecon = page2.getRedirectTarget().get()
						except wikipedia.LockedPage:
							print "Locked/protected page"
							return
					#raw_input (PageLecon.encode(config.console_encoding, 'replace'))
					
					# Majuscule
					if PageLecon.find(u'{{Leçon') != -1:
						if Valeur(u'Leçon',PageTemp) == u'':
							if PageTemp.find(u'Leçon') < PageTemp.find(u'}}') or PageTemp.find(u'Leçon') < PageTemp.find(u'}}'):
								if Valeur(u'Leçon',PageTemp) == u'':
									PageTemp2 = PageTemp[PageTemp.find(u'Leçon')+len(u'Leçon'):len(PageTemp)]
									PageTemp2 = PageTemp2[0:PageTemp2.find(u'\n')]
									while PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == u' ' or PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == u'\t':
										PageTemp2 = PageTemp2[0:len(PageTemp2)-1]
									if PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == u'=':
										PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'Leçon')+len(u'Leçon')+PageTemp2.find(u'=')+1] + page2.title()
										PageTemp = PageTemp[PageTemp.find(u'Leçon')+len(u'Leçon')+PageTemp2.find(u'=')+1:len(PageTemp)]
									else:
										print u'Signe égal manquant dans :'
										print PageTemp2[len(PageTemp2)-1:len(PageTemp2)]
							else:
								PageEnd = PageEnd + u'\n|Leçon=' + page2.title()
						PageEnd = PageEnd + PageTemp
						if PageLecon.find(u'niveau') != -1:
							PageTemp = PageLecon[PageLecon.find(u'niveau'):len(PageLecon)]
							if PageTemp.find(u'=') < PageTemp.find(u'\n') and PageTemp.find(u'=') != -1:
								if Valeur(u'niveau',PageLecon) != -1:
									PageTemp = PageEnd
									if PageTemp.find(u'{{Chapitre') != -1:
										PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
										PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
									elif PageTemp.find(u'{{chapitre') != -1:
										PageEnd = PageTemp[0:PageTemp.find(u'{{chapitre')+len(u'{{chapitre')]
										PageTemp = PageTemp[PageTemp.find(u'{{chapitre')+len(u'{{chapitre'):len(PageTemp)]
									else: return
									if PageTemp.find(u'niveau') < PageTemp.find(u'}}') and PageTemp.find(u'niveau') != -1:
										PageTemp2 = PageTemp[PageTemp.find(u'niveau')+len(u'niveau'):len(PageTemp)]
										while PageTemp2[0:1] == " " or PageTemp2[0:1] == "=":
											PageTemp2 = PageTemp2[1:len(PageTemp2)]
										if PageTemp2[0:PageTemp2.find(u'\n')] == u'':
											PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'niveau')+len(u'niveau')] + "=" + Valeur(u'niveau',PageLecon)
											PageTemp = PageTemp2
										elif Valeur(u'niveau',PageLecon) != PageTemp2[0:PageTemp2.find(u'\n')]:
											if debogage == True: 
												print u'Différence de niveau dans ' + PageHS.encode(config.console_encoding, 'replace') + u' : '
												print Valeur(u'niveau',PageLecon)
												print PageTemp2[0:PageTemp2.find(u'\n')].encode(config.console_encoding, 'replace')
									else:
										PageEnd = PageEnd + u'\n  | niveau      = ' + Valeur(u'niveau',PageLecon)
									#print (PageEnd.encode(config.console_encoding, 'replace'))
									#raw_input (PageTemp.encode(config.console_encoding, 'replace'))
					# Minuscule
					elif PageLecon.find(u'{{leçon') != -1:
						if Valeur(u'leçon',PageTemp) == u'':
							if PageTemp.find(u'leçon') < PageTemp.find(u'}}') or PageTemp.find(u'leçon') < PageTemp.find(u'}}'):
								if Valeur(u'leçon',PageTemp) == u'':
									PageTemp2 = PageTemp[PageTemp.find(u'leçon')+len(u'leçon'):len(PageTemp)]
									PageTemp2 = PageTemp2[0:PageTemp2.find(u'\n')]
									while PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == u' ' or PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == u'\t':
										PageTemp2 = PageTemp2[0:len(PageTemp2)-1]
									if PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == u'=':
										PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'leçon')+len(u'leçon')+PageTemp2.find(u'=')+1] + page2.title()
										PageTemp = PageTemp[PageTemp.find(u'leçon')+len(u'leçon')+PageTemp2.find(u'=')+1:len(PageTemp)]
									else:
										print u'Signe égal manquant dans :'
										print PageTemp2[len(PageTemp2)-1:len(PageTemp2)]
							else:
								PageEnd = PageEnd + u'\n|leçon=' + page2.title()
						PageEnd = PageEnd + PageTemp
						PageTemp = u''
						if PageLecon.find(u'niveau') != -1:
							niveauLecon = Valeur(u'niveau',PageLecon)
							print niveauLecon
							PageTemp = PageLecon[PageLecon.find(u'niveau'):len(PageLecon)]
							if PageTemp.find(u'=') < PageTemp.find(u'\n') and PageTemp.find(u'=') != -1:
								if niveauLecon != -1:
									PageTemp = PageEnd
									if PageTemp.find(u'{{Chapitre') != -1:
										PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
										PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
									elif PageTemp.find(u'{{chapitre') != -1:
										PageEnd = PageTemp[0:PageTemp.find(u'{{chapitre')+len(u'{{chapitre')]
										PageTemp = PageTemp[PageTemp.find(u'{{chapitre')+len(u'{{chapitre'):len(PageTemp)]
									else: return
									if PageTemp.find(u'niveau') < PageTemp.find(u'}}') and PageTemp.find(u'niveau') != -1:
										PageTemp2 = PageTemp[PageTemp.find(u'niveau')+len(u'niveau'):len(PageTemp)]
										while PageTemp2[0:1] == " " or PageTemp2[0:1] == "=":
											PageTemp2 = PageTemp2[1:len(PageTemp2)]
										niveauChapitre = PageTemp2[0:PageTemp2.find(u'\n')]
										if niveauChapitre == u'':
											PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'niveau')+len(u'niveau')] + "=" + niveauLecon
											PageTemp = PageTemp2
										elif niveauChapitre != niveauLecon:
											print u'Niveau du chapitre différent de celui de la leçon dans ' + PageHS.encode(config.console_encoding, 'replace')
									else:
										PageEnd = PageEnd + u'\n|niveau=' + niveauLecon
										
					PageEnd = PageEnd + PageTemp
					PageTemp = u''
					#raw_input (PageEnd.encode(config.console_encoding, 'replace'))
					
					'''print Valeur(u'niveau',PageEnd)
					print u'********************************************'
					print Valeur(u'numéro',PageEnd)
					print u'********************************************'
					print Valeur(u'précédent',PageEnd)
					print u'********************************************'
					print Valeur(u'suivant',PageEnd)
					raw_input(u'Fin de paramètres')'''
					NumLecon = u''
					PageTemp2 = u''
					if Valeur(u'numéro',PageEnd) == u'' or Valeur(u'précédent',PageEnd) == u'' or Valeur(u'suivant',PageEnd) == u'':
						if PageLecon.find(PageHS) != -1:
							PageTemp2 = PageLecon[0:PageLecon.find(PageHS)]	# Nécessite que le département ait un nom déifférent et que les leçons soient bien nommées différemment
						elif PageLecon.find(PageHS[PageHS.rfind(u'/')+1:len(PageHS)]) != -1:
							PageTemp2 = PageLecon[0:PageLecon.find(PageHS[PageHS.rfind(u'/')+1:len(PageHS)])]
						if PageTemp2 != u'':
							while PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == " " or PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == "=" or PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == "[" or PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == "{" or PageTemp2[len(PageTemp2)-1:len(PageTemp2)] == "|" or PageTemp2[len(PageTemp2)-2:len(PageTemp2)] == "{C" or PageTemp2[len(PageTemp2)-2:len(PageTemp2)] == "{c" or PageTemp2[len(PageTemp2)-2:len(PageTemp2)] == "{L" or PageTemp2[len(PageTemp2)-2:len(PageTemp2)] == "{l":
								PageTemp2 = PageTemp2[0:len(PageTemp2)-1]
							if PageTemp2.rfind(u' ') > PageTemp2.rfind(u'|'):
								NumLecon = PageTemp2[PageTemp2.rfind(u' ')+1:len(PageTemp2)]
							else:
								NumLecon = PageTemp2[PageTemp2.rfind(u'|')+1:len(PageTemp2)]
							#print (PageTemp2.encode(config.console_encoding, 'replace'))				
							if NumLecon != u'' and NumLecon != u'département':
								# Le numéro de la leçon permet de remplir les champs : |numéro=, |précédent=, |suivant=
								if Valeur(u'numéro',PageEnd) == u'':
									if PageEnd.find(u'numéro') == -1:
										PageTemp = PageEnd
										PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
										PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
										if PageTemp.find(u'numéro') < PageTemp.find(u'}}') and PageTemp.find(u'numéro') != -1:
											PageTemp2 = PageTemp[PageTemp.find(u'numéro')+len(u'numéro'):len(PageTemp)]
											while PageTemp2[0:1] == " " or PageTemp2[0:1] == "=":
												PageTemp2 = PageTemp2[1:len(PageTemp2)]
											PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'numéro')+len(u'numéro')] + "=" + NumLecon
											PageTemp = PageTemp2
										else:
											PageEnd = PageEnd + u'\n|numéro=' + NumLecon
										PageEnd = PageEnd + PageTemp
										PageTemp = u''
								if Valeur(u'précédent',PageEnd) == u'' and NumLecon	== 1:
									PageTemp = PageEnd
									PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
									PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
									if PageTemp.find(u'précédent') < PageTemp.find(u'}}') and PageTemp.find(u'précédent') != -1:
										PageTemp2 = PageTemp[PageTemp.find(u'précédent')+len(u'précédent'):len(PageTemp)]
										while PageTemp2[0:1] == " " or PageTemp2[0:1] == "=":
											PageTemp2 = PageTemp2[1:len(PageTemp2)]
										PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'précédent')+len(u'précédent')] + "=" + NumLecon
										PageTemp = PageTemp2
									else:
										PageEnd = PageEnd + u'\n|précédent=' + NumLecon
									PageEnd = PageEnd + PageTemp
									PageTemp = u''								
								elif Valeur(u'précédent',PageEnd) == u'' and Valeur(str(int(NumLecon)-1),PageLecon) != u'':
									PageTemp = PageEnd
									PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
									PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
									if PageTemp.find(u'précédent') < PageTemp.find(u'}}') and PageTemp.find(u'précédent') != -1:
										PageTemp2 = PageTemp[PageTemp.find(u'précédent')+len(u'précédent'):len(PageTemp)]
										while PageTemp2[0:1] == " " or PageTemp2[0:1] == "=":
											PageTemp2 = PageTemp2[1:len(PageTemp2)]
										PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'précédent')+len(u'précédent')] + "=" + Valeur(str(int(NumLecon)-1),PageLecon)
										PageTemp = PageTemp2
									else:
										PageEnd = PageEnd + u'\n|précédent=' + Valeur(str(int(NumLecon)-1),PageLecon)
									PageEnd = PageEnd + PageTemp
									PageTemp = u''
								if Valeur(u'suivant',PageEnd) == u'' and Valeur(str(int(NumLecon)+1),PageLecon) != u'':					
									PageTemp = PageEnd
									PageEnd = PageTemp[0:PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre')]
									PageTemp = PageTemp[PageTemp.find(u'{{Chapitre')+len(u'{{Chapitre'):len(PageTemp)]
									if PageTemp.find(u'suivant') < PageTemp.find(u'}}') and PageTemp.find(u'suivant') != -1:
										PageTemp2 = PageTemp[PageTemp.find(u'suivant')+len(u'suivant'):len(PageTemp)]
										while PageTemp2[0:1] == " " or PageTemp2[0:1] == "=":
											PageTemp2 = PageTemp2[1:len(PageTemp2)]
										PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'suivant')+len(u'suivant')] + "=" + Valeur(str(int(NumLecon)+1),PageLecon)
										PageTemp = PageTemp2
									else:
										if PageTemp.find(u'précédent') != -1:
											PageTemp2 = PageTemp[PageTemp.find(u'précédent'):len(PageTemp)]
											PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'précédent')+PageTemp2.find(u'\n')] + u'\n|suivant=' + Valeur(str(int(NumLecon)+1),PageLecon)
											PageTemp = PageTemp[PageTemp.find(u'précédent')+PageTemp2.find(u'\n'):len(PageTemp)]
										else:
											PageEnd = PageEnd + u'\n|suivant=' + Valeur(str(int(NumLecon)+1),PageLecon)
									PageEnd = PageEnd + PageTemp
									PageTemp = u''
				else: # Pas de leçon
					print u'Pas de leçon : '
					print (Lecon.encode(config.console_encoding, 'replace'))
					print u'dans : '
					print (PageHS.encode(config.console_encoding, 'replace'))
					#raw_input ('Attente')
				PageEnd = PageEnd + PageTemp
				PageTemp = u''
		elif PageTemp.find(u'{Leçon') != -1 or PageTemp.find(u'{leçon') != -1:
			# Evaluations
			page2 = Page(site,u'Discussion:' + PageHS)
			if page2.exists():
				try:
					PageDisc = page2.get()
				except wikipedia.NoPage:
					print "NoPage"
					return
				except wikipedia.IsRedirectPage:
					print "Redirect page"
					return
				except wikipedia.LockedPage:
					print "Locked/protected page"
					return
			else: 
				PageDisc = u''
			if PageDisc.find(u'{{Évaluation') == -1 and PageDisc.find(u'{{évaluation') == -1: sauvegarde(page2, u'{{Évaluation|idfaculté=' + Valeur(u'idfaculté',PageTemp) + u'|avancement=?}}\n' + PageDisc, u'Ajout d\'évaluation inconnue')	
							
			# Synchronisations avec les niveaux des départements, et les évaluations des onglets Discussion:
			#...
		PageEnd = PageEnd + PageTemp
		
		# Bas de page
		if (PageEnd.find(u'{{Chapitre') != -1 or PageEnd.find(u'{{chapitre') != -1) and PageEnd.find(u'{{Bas de page') == -1 and PageEnd.find(u'{{bas de page') == -1:
			idfaculte = u''
			precedent = u''
			suivant = u''
			if PageEnd.find(u'idfaculté') != -1:
				PageTemp = PageEnd[PageEnd.find(u'idfaculté'):len(PageEnd)]
				idfaculte = PageTemp[0:PageTemp.find(u'\n')]	# pb si tout sur la même ligne, faire max(0,min(PageTemp.find(u'\n'),?))
				if PageEnd.find(u'précédent') != -1:
					PageTemp = PageEnd[PageEnd.find(u'précédent'):len(PageEnd)]
					precedent = PageTemp[0:PageTemp.find(u'\n')]
				if PageEnd.find(u'suivant') != -1:
					PageTemp = PageEnd[PageEnd.find(u'suivant'):len(PageEnd)]
					suivant = PageTemp[0:PageTemp.find(u'\n')]
				PageEnd = PageEnd + u'\n\n{{Bas de page|' + idfaculte + u'\n|' + precedent + u'\n|' + suivant + u'}}'
		
		# Exercices (pb [[Spécial:diff/354352]])
		'''PageTemp = PageEnd
		PageEnd = u''
		while PageEnd.find(u'{{CfExo') != -1 or PageEnd.find(u'{{cfExo') != -1:
			PageTemp = PageEnd[
			if 
			|exercice=[[
			/Exercices/
			/quiz/
		PageEnd = PageEnd + PageTemp'''
	
	PageEnd = PageEnd + PageTemp
	PageTemp = u''
	
	# Test des URL
	if debogage == True: print u'Test des URL'
	PageEnd = hyperlynx.hyperlynx(PageEnd)
	if debogage == True: raw_input (u'--------------------------------------------------------------------------------------------')
	
	if PageBegin != PageEnd: sauvegarde(page, PageEnd, summary)

# Permet à tout le monde de stopper le bot en lui écrivant
def ArretDUrgence():
        arrettitle = ''.join(u'Discussion utilisateur:JackBot')
        arretpage = pywikibot.Page(pywikibot.getSite(), arrettitle)
        gen = iter([arretpage])
        arret = arretpage.get()
        if arret != u"{{/Stop}}":
                pywikibot.output(u"\n*** \03{lightyellow}Arrêt d'urgence demandé\03{default} ***")
                exit(0)

def Valeur(Mot,Page):
	#raw_input(u'Bug http://fr.wikiversity.org/w/index.php?title=Initiation_à_l%27arithmétique/PGCD&diff=prev&oldid=386685')
	if re.search(u'\n *' + Mot + u' *=', Page):
		niveau = re.sub(u'\n *' + Mot + u' *=()[\n|\||}|{]', ur'$1', Page)
		if debogage == True: raw_input(niveau)
		#return
	'''
	if Page.find(u' ' + Mot) != Page.find(Mot)-1 and Page.find(u'|' + Mot) != Page.find(Mot)-1: # Pb du titre_leçon
		PageTemp2 = Page[Page.find(Mot)+len(Mot):len(Page)]
	else:
		PageTemp2 = Page
	if PageTemp2.find(Mot) == -1:
		return u''
	else:
		PageTemp2 = PageTemp2[PageTemp2.find(Mot)+len(Mot):len(PageTemp2)]
		PageTemp2 = PageTemp2[0:PageTemp2.find(u'\n')]
		if PageTemp2.find (u'{{C|') != -1:		
			PageTemp2 = PageTemp2[PageTemp2.find (u'{{C|')+4:len(PageTemp2)]
			PageTemp2 = u'[[../' + PageTemp2[0:PageTemp2.find (u'|')] + u'/]]'
		while PageTemp2[0:1] == u' ' or PageTemp2[0:1] == u'\t' or PageTemp2[0:1] == u'=':
			PageTemp2 = PageTemp2[1:len(PageTemp2)]
		if PageTemp2[0:3] == u'[[/':		
			PageTemp2 = u'[[..' + PageTemp2[2:len(PageTemp2)]
		return PageTemp2
	'''			

# Lecture du fichier articles_list.txt (au même format que pour replace.py)
def crawlerFile(source):
	if source:
		PagesHS = open(source, 'r')
		while 1:
			PageHS = PagesHS.readline()
			fin = PageHS.find("\t")
			PageHS = PageHS[0:fin]
			if PageHS == '': break
			if PageHS.find(u'[[') != -1:
				PageHS = PageHS[PageHS.find(u'[[')+2:len(PageHS)]
			if PageHS.find(u']]') != -1:
				PageHS = PageHS[0:PageHS.find(u']]')]
			# Conversion ASCII => Unicode (pour les .txt)
			modification(HTMLUnicode.HTMLUnicode(PageHS))
		PagesHS.close()

# Traitement d'une catégorie
def crawlerCat(category,recursif,apres):
	modifier = u'False'
	cat = catlib.Category(site, category)
	pages = cat.articlesList(False)
	gen =  pagegenerators.NamespaceFilterPageGenerator(pages, [0])
	for Page in pagegenerators.PreloadingGenerator(gen,100):
		if not apres or apres == u'' or modifier == u'True':
			modification(Page.title()) #crawlerLink(Page.title())
		elif Page.title() == apres:
			modifier = u'True'
	if recursif == True:
		subcat = cat.subcategories(recurse = True)
		for subcategory in subcat:
			pages = subcategory.articlesList(False)
			for Page in pagegenerators.PreloadingGenerator(pages,100):
				modification(Page.title())

# Traitement des pages liées
def crawlerLink(pagename,apres):
	modifier = u'False'
	#pagename = unicode(arg[len('-links:'):], 'utf-8')
	page = wikipedia.Page(site, pagename)
	gen = pagegenerators.ReferringPageGenerator(page)
	gen =  pagegenerators.NamespaceFilterPageGenerator(gen, [0])
	for Page in pagegenerators.PreloadingGenerator(gen,100):
		#print(Page.title().encode(config.console_encoding, 'replace'))
		if not apres or apres == u'' or modifier == u'True':
			modification(Page.title()) #crawlerLink(Page.title())
		elif Page.title() == apres:
			modifier = u'True'

# Traitement des pages liées des entrées d'une catégorie
def crawlerCatLink(pagename,apres):
	modifier = u'False'
	cat = catlib.Category(site, pagename)
	pages = cat.articlesList(False)
	for Page in pagegenerators.PreloadingGenerator(pages,100):
		page = wikipedia.Page(site, Page.title())
		gen = pagegenerators.ReferringPageGenerator(page)
		gen =  pagegenerators.NamespaceFilterPageGenerator(gen, [0])
		for PageLiee in pagegenerators.PreloadingGenerator(gen,100):
			#print(Page.title().encode(config.console_encoding, 'replace'))
			if not apres or apres == u'' or modifier == u'True':
				modification(PageLiee.title()) #crawlerLink(Page.title())
			elif PageLiee.title() == apres:
				modifier = u'True'
				
# Traitement d'une recherche
def crawlerSearch(pagename):
	gen = pagegenerators.SearchPageGenerator(pagename, site = site, namespaces = "0")
	for Page in pagegenerators.PreloadingGenerator(gen,100):
		modification(Page.title())

# Traitement des modifications récentes
def crawlerRC_last_day(site=site, nobots=True, namespace='0'):
    # Génère les modifications récentes de la dernière journée
	ecart_last_edit = 30 # minutes
	
	date_now = datetime.datetime.utcnow()
	# Date de la plus récente modification à récupérer
	date_start = date_now - datetime.timedelta(minutes=ecart_last_edit)
	# Date d'un jour plus tôt
	date_end = date_start - datetime.timedelta(1)
	
	start_timestamp = date_start.strftime('%Y%m%d%H%M%S')
	end_timestamp = date_end.strftime('%Y%m%d%H%M%S')

	for item in site.recentchanges(number=5000, rcstart=start_timestamp, rcend=end_timestamp, rcshow=None,
					rcdir='older', rctype='edit|new', namespace=namespace,
					includeredirects=True, repeat=False, user=None,
					returndict=False, nobots=nobots):
		yield item[0]
		
def crawlerRC():
	gen = pagegenerators.RecentchangesPageGenerator(site = site)
	ecart_minimal_requis = 30 # min
	for Page in pagegenerators.PreloadingGenerator(gen,100):
		#print str(ecart_last_edit(Page)) + ' =? ' + str(ecart_minimal_requis)
		if ecart_last_edit(Page) > ecart_minimal_requis:
			modification(Page.title())

def ecart_last_edit(page):
	# Timestamp au format MediaWiki de la dernière version
	time_last_edit = page.getVersionHistory()[0][1]
	match_time = re.match(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})', time_last_edit)
	# Mise au format "datetime" du timestamp de la dernière version
	datetime_last_edit = datetime.datetime(int(match_time.group(1)), int(match_time.group(2)), int(match_time.group(3)),
		int(match_time.group(4)), int(match_time.group(5)), int(match_time.group(6)))
	datetime_now = datetime.datetime.utcnow()
	diff_last_edit_time = datetime_now - datetime_last_edit
 
	# Ecart en minutes entre l'horodotage actuelle et l'horodotage de la dernière version
	return diff_last_edit_time.seconds/60 + diff_last_edit_time.days*24*60
	
# Traitement des modifications d'un compte
def crawlerUser(username,jusqua):
	compteur = 0
	gen = pagegenerators.UserContributionsGenerator(username)
	for Page in pagegenerators.PreloadingGenerator(gen,100):
		modification(Page.title())
		compteur = compteur + 1
		if compteur > jusqua: break

# Toutes les redirections
def crawlerRedirects():
	for Page in site.allpages(start=u'', namespace=0, includeredirects='only'):
		modification(Page.title())	
										
# Traitement de toutes les pages du site
def crawlerAll(start):
	gen = pagegenerators.AllpagesPageGenerator(start,namespace=0,includeredirects=False)
	for Page in pagegenerators.PreloadingGenerator(gen,100):
		#print (Page.title().encode(config.console_encoding, 'replace'))
		modification(Page.title())

def sauvegarde(PageCourante, Contenu, summary):
	result = "ok"
	if debogage:
		if len(Contenu) < 6000:
			print(Contenu.encode(config.console_encoding, 'replace'))
		else:
			taille = 3000
			print(Contenu[:taille].encode(config.console_encoding, 'replace'))
			print u'\n[...]\n'
			print(Contenu[len(Contenu)-taille:].encode(config.console_encoding, 'replace'))
		result = raw_input("Sauvegarder ? (o/n) ")
	if result != "n" and result != "no" and result != "non":
		if PageCourante.title().find(u'Utilisateur:JackBot/') == -1: ArretDUrgence()
		if not summary: summary = u'[[Wiktionnaire:Structure des articles|Autoformatage]]'
		try:
			PageCourante.put(Contenu, summary)
		except wikipedia.NoPage: 
			print "NoPage en sauvegarde"
			return
		except wikipedia.IsRedirectPage: 
			print "IsRedirectPage en sauvegarde"
			return
		except wikipedia.LockedPage: 
			print "LockedPage en sauvegarde"
			return
		except pywikibot.EditConflict: 
			print "EditConflict en sauvegarde"
			return
		except wikipedia.ServerError: 
			print "ServerError en sauvegarde"
			return
		except wikipedia.BadTitle: 
			print "BadTitle en sauvegarde"
			return
		except AttributeError:
			print "AttributeError en sauvegarde"
			return
			
# Lancement
if len(sys.argv) > 1:
	if sys.argv[1] == u'test':
		TraitementPage = modification(u'User:' + mynick + u'/test')
	elif sys.argv[1] == u'txt':
		TraitementFichier = crawlerFile(u'articles_' + language + u'_' + family + u'.txt')
	elif sys.argv[1] == u'cat':
		TraitementCategorie = crawlerCat(u'Catégorie:SPARQL Protocol and RDF Query Language',False,u"SPARQL Protocol and RDF Query Language/Système d'implication")
	elif sys.argv[1] == u'lien':
		TraitementLiens = crawlerLink(u'Modèle:cite book',u'')
	else:
		TraitementPage = modification(sys.argv[1])	# Format http://tools.wmflabs.org/jackbot/xtools/public_html/unicode-HTML.php
else:
	TraitementCategory = crawlerCat(u'Modèle mal utilisé')
'''
TraitementLiens = crawlerLink(u'Modèle:Chapitre')
TraitementLiens = crawlerLink(u'Modèle:CfExo')
TraitementUtilisateur = crawlerUser(u'Utilisateur:JackBot')
TraitementRecherche = crawlerSearch(u'chinois')
while 1:
	TraitementRC = crawlerRC()
'''