Difference between revisions 12555161 and 13869130 on frwiktionary

< previous diff
next diff >
Utilisateur:JackBot/RemiseEnForme.py
[[Catégorie:JackBot]]
<source lang=python>
#!/usr/bin/env python
# coding: utf-8

# Ce script formate les pages du Wiktionnaire, tous les jours après minuit depuis le Toolserver :
# 1) Retire certains doublons.
# 2) Ajoute les clés de tris, prononciations vides, et certains liens vers les conjugaisons.
# 3) Met à jour les liens vers les traductions (modèles trad, trad+, trad-, trad-début et trad-fin), et les classe par ordre alphabétique.
# 4) Ajoute les codes langues appropriés dans les modèles du Wiktionnaire du namespace 0 et paragraphes appropriés.
# 5) Complète les flexions de verbes à vérifier.
# 6) Traduit les importations de en.wikt.
# 7) Gestion des modèles {{voir}} en début de page.

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

# Déclaration
language = "fr"
family = "wiktionary"
mynick = "JackBot"
site = getSite(language,family)⏎
summary = u'[[Wiktionnaire:Structure des articles|Autoformatage]]'

# Modèles du site à traiter
limit6=9146
Modele = range(1, limit6+1)
# http://fr.wiktionary.org/wiki/Cat%C3%A9gorie:Mod%C3%A8les_de_type_de_mot_du_Wiktionnaire
Modele[1] = u'-adj-'
Modele[2] = u'-flex-adj-indéf-'
Modele[3] = u'-adj-dém-'
Modele[4] = u'-adj-excl-'
Modele[5] = u'-adj-indéf-'
(contracted; show full)Modele[774] = u'déverbal'
Modele[775] = u'superlatif'
Modele[776] = u'combat'
Modele[777] = u'sports de combat'
Modele[778] = u'capoeira'
Modele[779] = u'aïkido'
Modele[780] = u'karaté'

Modele[781] = u'argot militaire'
Modele[782] = u'argot polytechnicien'⏎
limit5 = 7813
# non traités
#Modele[] = u'spécialement' 
#Modele[] = u'T'

# Modèles régionaux, pb du nocat pour les prononciations
Modele[782] = u'Acadie'
Modele[783] = u'Afrique'⏎
Modele[784] = u'Afrique du Sud'
Modele[785] = u'Algérie'
Modele[786] = u'Allemagne'
Modele[787] = u'Alsace'
Modele[788] = u'Amérique centrale'
Modele[789] = u'Amérique du Nord'
Modele[790] = u'Amérique du Sud'
Modele[791] = u'Amérique latine'
(contracted; show full)Modele[905] = u'CA'
Modele[906] = u'US'
Modele[907] = u'USA'
Modele[908] = u'UK'
Modele[909] = u'GB'
Modele[910] = u'AU'
Modele[911] = u'NZ'
Modele[912] = u'IE'
⏎
Modele[913] = u'Acadie'
Modele[914] = u'Afrique'

# Modèles des autres Wiktionnaires à convertir
LimitTemplate = 66
Template = range(1, LimitTemplate+1)
TemplateFR = range(1, LimitTemplate+1)
Template[1] = u'===Adjective==='
TemplateFR[1] = u'{{-adj-}}'
(contracted; show full)Template[64] = u'{{figuratively '
TemplateFR[64] = u'{{figuré'
Template[65] = u'{{trans-see'
TemplateFR[65] = u'{{cf'

# Modification du wiki
def modification(PageHS):
	
#summary = u'[[Wiktionnaire:Structure des articles|Autoformatage]]'⏎
	print(PageHS.encode(config.console_encoding, 'replace'))
	PageEnd = u''⏎
	page = Page(site,PageHS)
	if page.exists():
		if page.namespace() !=0 and PageHS != u'Utilisateur:JackBot/test':
			return
		else:
			try:
				PageBegin = page.get()
			except wikipedia.NoPage:  ⏎
				print "NoPage l 1109"⏎
				return
			except wikipedia.IsRedirectPage: ⏎
				print "IsRedirect l 1112"⏎
				return
			except wikipedia.LockedPage: return
	else:⏎
				print "Locked l 1115"
				return
	else:
		print "NoPage l 1118"
		return
	PageTemp = PageBegin
	while PageTemp.find(u'{{ ') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{ ')+2] + PageTemp[PageTemp.find(u'{{ ')+3:len(PageTemp)]
		
	if PageTemp.find(u'{{formater') != -1 or PageTemp.find(u'{{supp') != -1:  ⏎
		print "Page en suppression"⏎
		return
	# Traductions des modèles des autres Wiktionnaires
	for p in range(1,LimitTemplate):
		while PageTemp.find(Template[p]) != -1: PageTemp = PageTemp[0:PageTemp.find(Template[p])] + TemplateFR[p] + PageTemp[PageTemp.find(Template[p])+len(Template[p]):len(PageTemp)]
	# Ajout des {{voir}}
	if PageTemp.find(u'{{voir|') == -1 and PageTemp.find(u'{{voir/') == -1:
		PageVoir = u''
		# Liste de toutes les pages potentiellement "à voir"
(contracted; show full)
					PageTempMod = PageTempModBegin
					if PageTempMod.find(PageHS) == -1: PageTempMod = PageTempMod[0:PageTempMod.find(u'}}')] + u'|' + PageHS + PageTempMod[PageTempMod.find(u'}}'):len(PageTempMod)]
					if PageTempMod.find(PageVoir) == -1: PageTempMod = PageTempMod[0:PageTempMod.find(u'}}')] + u'|' + PageVoir + PageTempMod[PageTempMod.find(u'}}'):len(PageTempMod)]
					if PageTempMod != PageTempModBegin: sauvegarde(pageMod,PageTempMod
, summary)
					PagesCleRestant = u''
					break	
		# Filtre des doublons
		if PagesVoir != u'':
			PagesVoir = PagesVoir + u'|'
			while PagesVoir.find(u'|') != -1:
				if PagesCleTotal.find(PagesVoir[0:PagesVoir.find(u'|')]) == -1: PagesCleTotal = PagesCleTotal + u'|' + PagesVoir[0:PagesVoir.find(u'|')]
				PagesVoir = PagesVoir[PagesVoir.find(u'|')+1:len(PagesVoir)]
		#raw_input(PagesCleTotal.encode(config.console_encoding, 'replace'))	
		# Balayage de toutes les pages "à voir"
		if PagesCleTotal != u'':
			while PagesCleTotal[0:1] == u'|': PagesCleTotal = PagesCleTotal[1:len(PagesCleTotal)]
		if PagesCleTotal != PageHS:
			PagesCleRestant = PagesCleTotal + u'|'
			while PagesCleRestant.find(u'|') != -1:
				HS = u'False'
				PageCourante = PagesCleRestant[0:PagesCleRestant.find(u'|')]
				if PageCourante == u'': break
				PagesCleRestant = PagesCleRestant[PagesCleRestant.find(u'|')+1:len(PagesCleRestant)]
				PageCle = Page(site,PageCourante)
				try:
					PageTempCleBegin = PageCle.get()
				except wikipedia.NoPage:
					HS = u'True'
				except wikipedia.IsRedirectPage:
					HS = u'True'⏎
				if HS == u'False':
					PageTempCle = PageTempCleBegin
					if PageTempCle.find(u'{{voir|') != -1:
						if PagesCleTotal.find(u'|' + PageCourante) != -1:
							PageTempCle2 = PageTempCle[PageTempCle.find(u'{{voir|')+len(u'{{voir|'):len(PageTempCle)]
							PageTempCle = PageTempCle[0:PageTempCle.find(u'{{voir|')+len(u'{{voir|')] + PagesCleTotal[0:PagesCleTotal.find(u'|' + PageCourante)] + PagesCleTotal[PagesCleTotal.find(u'|' + PageCourante)+len(u'|' + PageCourante):len(PagesCleTotal)] + PageTempCle[PageTempCle.find(u'{{voir|')+len(u'{{voir|')+PageTempCle2.find(u'}}'):len(PageTempCle)]
						else:	# Cas du premier
							PageTempCle2 = PageTempCle[PageTempCle.find(u'{{voir|')+len(u'{{voir'):len(PageTempCle)]
							PageTempCle = PageTempCle[0:PageTempCle.find(u'{{voir|')+len(u'{{voir|')] + PagesCleTotal[len(PageCourante):len(PagesCleTotal)] + PageTempCle[PageTempCle.find(u'{{voir|')+len(u'{{voir')+PageTempCle2.find(u'}}'):len(PageTempCle)]
						if PageTempCle != PageTempCleBegin:
							if PageCourante == PageHS:
								PageTemp = PageTempCle
							else:
								sauvegarde(PageCle,PageTempCle, summary)
					else:
						if PagesCleTotal.find(u'|' + PageCourante) != -1:
							PageTempCle = u'{{voir|' + PagesCleTotal[0:PagesCleTotal.find(u'|' + PageCourante)] + PagesCleTotal[PagesCleTotal.find(u'|' + PageCourante)+len(u'|' + PageCourante):len(PagesCleTotal)] + u'}}\n' + PageTempCle
						else:	# Cas du premier
							PageTempCle = u'{{voir' + PagesCleTotal[len(PageCourante):len(PagesCleTotal)] + u'}}\n' + PageTempCle
						if PageCourante == PageHS:
							PageTemp = PageTempCle
						else:							
							sauvegarde(PageCle,PageTempCle, summary)
	
	elif PageTemp.find(u'{{voir|') != -1:
		PageTemp2 = PageTemp[PageTemp.find(u'{{voir|'):len(PageTemp)]
		if PageTemp2.find(u'|' + PageHS + u'|') != -1 and PageTemp2.find(u'|' + PageHS + u'|') < PageTemp2.find(u'}}'):
			PageTemp = PageTemp[0:PageTemp.find(u'{{voir|') + PageTemp2.find(u'|' + PageHS + u'|')] + PageTemp[PageTemp.find(u'{{voir|') + PageTemp2.find(u'|' + PageHS + u'|')+len(u'|' + PageHS):len(PageTemp)]
		if PageTemp2.find(u'|' + PageHS + u'}') != -1 and PageTemp2.find(u'|' + PageHS + u'}') < PageTemp2.find(u'}}'):
			PageTemp = PageTemp[0:PageTemp.find(u'{{voir|') + PageTemp2.find(u'|' + PageHS + u'}')] + PageTemp[PageTemp.find(u'{{voir|') + PageTemp2.find(u'|' + PageHS + u'}')+len(u'|' + PageHS):len(PageTemp)]

	# Nettoyage
	if PageTemp.find(u'{{voir}}\n') != -1: PageTemp = PageTemp[0:PageTemp.find(u'{{voir}}\n')] + PageTemp[PageTemp.find(u'{{voir}}\n')+len(u'{{voir}}\n'):len(PageTemp)]
	if PageTemp.find(u'{{voir}}') != -1: PageTemp = PageTemp[0:PageTemp.find(u'{{voir}}')] + PageTemp[PageTemp.find(u'{{voir}}')+len(u'{{voir}}'):len(PageTemp)]
	
	# Clés de tri
	if PageTemp.find(u'{{clé de tri') == -1 and PageTemp.find(u'{{clef de tri') == -1:
		ClePage = CleDeTri(PageHS)
		if ClePage != u'' and ClePage != PageHS:
			if PageTemp.find(u'[[Catégorie:') != -1:
				PageTemp = PageTemp[0:PageTemp.find(u'[[Catégorie:')] + u'\n{{clé de tri|' + ClePage + u'}}\n' + PageTemp[PageTemp.find(u'[[Catégorie:'):len(PageTemp)]
			elif PageTemp.find(u'[[Category:') != -1:
(contracted; show full)
		if CleDeTri(PageHS) != ClePage:
			print (u'Fausse clé de tri dans :')
			print (PageHS.encode(config.console_encoding, 'replace'))
			print (ClePage.encode(config.console_encoding, 'replace'))
	if PageTemp.find(u'{{clé de tri}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{clé de tri}}')] + PageTemp[PageTemp.find(u'{{clé de tri}}')+len(u'{{clé de tri}}'):len(PageTemp)]

		summary = summary + u', {{clé de tri}} inutile'⏎
	if PageTemp.find(u'{{clé de tri|' + PageHS.lower() + u'}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{clé de tri|' + PageHS.lower() + u'}}')] + PageTemp[PageTemp.find(u'{{clé de tri|' + PageHS.lower() + u'}}')+len(u'{{clé de tri|' + PageHS.lower() + u'}}'):len(PageTemp)]
		⏎
	# Nettoyage des doublons
	while PageTemp.find(u'{{R:DAF8}}\n{{Import:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{R:DAF8}}\n{{Import:DAF8}}')] + PageTemp[PageTemp.find(u'{{R:DAF8}}\n{{Import:DAF8}}')+len(u'{{R:DAF8}}\n'):len(PageTemp)]
	while PageTemp.find(u'{{Import:DAF8}}\n{{R:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:DAF8}}\n{{R:DAF8}}')+len(u'{{Import:DAF8}}')] + PageTemp[PageTemp.find(u'{{Import:DAF8}}\n{{R:DAF8}}')+len(u'{{Import:DAF8}}\n{{R:DAF8}}'):len(PageTemp)]
	while PageTemp.find(u'{{R:Littré}}\n{{Import:Littré}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{R:Littré}}\n{{Import:Littré}}')] + PageTemp[PageTemp.find(u'{{R:Littré}}\n{{Import:Littré}}')+len(u'{{R:Littré}}\n'):len(PageTemp)]
	while PageTemp.find(u'{{Import:Littré}}\n{{R:Littré}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:Littré}}\n{{R:Littré}}')+len(u'{{Import:Littré}}')] + PageTemp[PageTemp.find(u'{{Import:Littré}}\n{{R:Littré}}')+len(u'{{Import:Littré}}\n{{R:Littré}}'):len(PageTemp)]⏎
summary = summary + u', {{clé de tri}} inutile'⏎
		
	# Remplacements consensuels
	while PageTemp.find(u'&#32;') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'&#32;')] + u'&nbsp;' + PageTemp[PageTemp.find(u'&#32;')+len(u'&#32;'):len(PageTemp)]
	while PageTemp.find(u'&#224;') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'&#224;')] + u'à' + PageTemp[PageTemp.find(u'&#224;')+len(u'&#224;'):len(PageTemp)]
(contracted; show full)
	while PageTemp.find(u'— {{source|') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'— {{source|')] + PageTemp[PageTemp.find(u'— {{source|')+2:len(PageTemp)]
	while PageTemp.find(u'
\n#*') != -1 and PageTemp.find(u'—') != -1:
		PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'\n#*')+len(u'\n#*')]
		PageTemp =  PageTemp[PageTemp.find(u'\n#*')+len(u'\n#*'):len(PageTemp)]
		'''if PageTemp.find(u'—') !=-1 and PageTemp.find(u'—') < PageTemp.find(u'\n'):
			PageTemp2 = PageTemp[0:PageTemp.find(u'—')]
			if PageTemp2.rfind(u'{{langue|') != PageTemp2.rfind(u'{{langue|fr'):
				PageTemp2 = PageTemp[PageTemp.find(u'—')+1:len(PageTemp)]
				if PageTemp2.find(u'{{') < PageTemp2.find(u'}}'):
					while PageTemp2.find(u'\'\'') != -1 and PageTemp2.find(u'\'\'') < PageTemp2.find(u'{') and PageTemp2.find(u'\'\'') < PageTemp2.find(u'#*'):
						PageTemp = PageTemp[0:PageTemp.find(u'—')+1+PageTemp2.find(u'\'\'')] + PageTemp[PageTemp.find(u'—')+1+PageTemp2.find(u'\'\'')+2:len(PageTemp)]
						PageTemp2 = PageTemp[PageTemp.find(u'—')+1:len(PageTemp2)]
					while PageTemp[PageTemp.find(u'—')+1:PageTemp.find(u'—')+2] == u' ':
						PageTemp = PageTemp[0:PageTemp.find(u'—')+1] + PageTemp[PageTemp.find(u'—')+2:len(PageTemp)]
						PageTemp2 = PageTemp[PageTemp.find(u'—')+1:len(PageTemp2)]
					PageTemp =  PageTemp[0:PageTemp.find(u'—')] + u'\n#*:' + PageTemp[PageTemp.find(u'—')+1:PageTemp.find(u'—')+2].upper() + PageTemp[PageTemp.find(u'—')+2:len(PageTemp)]'''

	PageTemp = PageEnd + PageTemp
	PageEnd = u''

	#raw_input(PageTemp.encode(config.console_encoding, 'replace')[0:1000]){{PAGENAME}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{PAGENAME}}')] + u'{{subst:PAGENAME}}' + PageTemp[PageTemp.find(u'{{PAGENAME}}')+len(u'{{PAGENAME}}'):len(PageTemp)]
		summary = summary + u', {{subst:PAGENAME}}'
	while PageTemp.find(u'Catégorie:Villes') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'Catégorie:Villes')] + u'Catégorie:Localités' + PageTemp[PageTemp.find(u'Catégorie:Villes')+len(u'Catégorie:Villes'):len(PageTemp)]
	while PageTemp.find(u'\n{{WP') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'\n{{WP')+1] + u'*' + PageTemp[PageTemp.find(u'\n{{WP')+1:len(PageTemp)]
(contracted; show full)
	while PageTemp.find(u'{{figuré|fr}} {{métaphore|fr}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{figuré|fr}} {{métaphore|fr}}')] + u'{{figuré|fr}}' + PageTemp[PageTemp.find(u'{{figuré|fr}} {{métaphore|fr}}')+len(u'{{figuré|fr}} {{métaphore|fr}}'):len(PageTemp)]

	while PageTemp.find(u'{{PAGENAME}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{PAGENAME}}')] + u'{{subst:PAGENAME}}' + PageTemp[PageTemp.find(u'{{PAGENAME}}')+len(u'{{PAGENAME}}'):len(PageTemp)]⏎
	while PageTemp.find(u'{{trad/zh') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{trad/zh')] + u'{{trad/défaut' + PageTemp[PageTemp.find(u'{{trad/zh')+len(u'{{trad/zh'):len(PageTemp)]
	while PageTemp.find(u'{{{{T|trad') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{{{T|trad')+2] + PageTemp[PageTemp.find(u'{{{{T|trad')+6:len(PageTemp)]
	while PageTemp.find(u'|type=du nom') != -1:
(contracted; show full)
	while PageTemp.find(u'{{-car-}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{-car-}}')] + u'{{caractère}}' + PageTemp[PageTemp.find(u'{{-car-}}')+len(u'{{-car-}}'):len(PageTemp)]
	while PageTemp.find(u'{{-note-|s=s}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{-note-|s=s}}')] + u'{{-notes-}}' + PageTemp[PageTemp.find(u'{{-note-|s=s}}')+len(u'{{-note-|s=s}}'):len(PageTemp)]

	⏎
	⏎
	# Codes langues
	while PageTemp.find(u'=prv=') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'=prv=')] + u'langue|oc' + PageTemp[PageTemp.find(u'=prv=')+len(u'=prv='):len(PageTemp)]
	AncienModele = range(1, 113)
	NouveauModele = range(1, 113)
	AncienModele[1] = u'ko-hanja'
	NouveauModele[1] = u'ko-Hani'
	AncienModele[2] = u'be-x-old'
	NouveauModele[2] = u'be-tarask'
	AncienModele[3] = u'zh-min-nan'
	NouveauModele[3] = u'nan'
	AncienModele[4] = u'lsf'
	NouveauModele[4] = u'fsl'
	AncienModele[5] = u'arg'
	NouveauModele[5] = u'an'
	AncienModele[6] = u'nav'
	NouveauModele[6] = u'nv'
	AncienModele[7] = u'prv'
	NouveauModele[7] = u'oc'
	AncienModele[8] = u'nds-NL'
	NouveauModele[8] = u'nds-nl'	
	AncienModele[9] = u'gsw-FR'
	NouveauModele[9] = u'gsw-fr'
	for p in range(1,10AncienModele[10] = u'zh-sc'
	NouveauModele[10] = u'zh-Hans'
	AncienModele[11] = u'roa-rup'
	NouveauModele[11] = u'rup'
	for p in range(1,12):
		while PageTemp.find(u'|' + AncienModele[p] + u'|') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'|' + AncienModele[p] + u'|')+1] + NouveauModele[p] + PageTemp[PageTemp.find(u'|' + AncienModele[p] + u'|')+len(u'|' + AncienModele[p] + u'|')-1:len(PageTemp)]
		while PageTemp.find(u'|' + AncienModele[p] + u'}') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'|' + AncienModele[p] + u'}')+1] + NouveauModele[p] + PageTemp[PageTemp.find(u'|' + AncienModele[p] + u'}')+len(u'|' + AncienModele[p] + u'}')-1:len(PageTemp)]
		while PageTemp.find(u'{' + AncienModele[p] + u'|') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'{' + AncienModele[p] + u'|')+1] + NouveauModele[p] + PageTemp[PageTemp.find(u'{' + AncienModele[p] + u'|')+len(u'{' + AncienModele[p] + u'|')-1:len(PageTemp)]
		while PageTemp.find(u'{' + AncienModele[p] + u'}') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'{' + AncienModele[p] + u'}')+1] + NouveauModele[p] + PageTemp[PageTemp.find(u'{' + AncienModele[p] + u'}')+len(u'{' + AncienModele[p] + u'}')-1:len(PageTemp)]
	while PageTemp.find(u'lang=sgs') != -1:	# {{WP|lang=
		PageTemp = PageTemp[0:PageTemp.find(u'lang=sgs')] + u'lang=bat-smg' + PageTemp[PageTemp.find(u'lang=sgs')+len(u'lang=sgs'):len(PageTemp)]
	# URL de références
	while PageTemp.find(u'{{-réf-}}\n{{R:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{R:DAF8}}')] + u'*' + PageTemp[PageTemp.find(u'{{R:DAF8}}'):len(PageTemp)]
	while PageTemp.find(u'{{-réf-}}\n{{Import:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:DAF8}}')] + u'*' + PageTemp[PageTemp.find(u'{{Import:DAF8}}'):len(PageTemp)]
	while PageTemp.find(u'{{-réf-}}\n{{Import:Littré}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:Littré}}')] + u'*' + PageTemp[PageTemp.find(u'{{Import:Littré}}'):len(PageTemp)]	while PageTemp.find(u'=' + AncienModele[p] + u'}') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'=' + AncienModele[p] + u'}')+1] + NouveauModele[p] + PageTemp[PageTemp.find(u'=' + AncienModele[p] + u'}')+len(u'=' + AncienModele[p] + u'}')-1:len(PageTemp)]
	while PageTemp.find(u'{{WP|lang=sgs') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{WP|lang=sgs')] + u'{{WP|lang=bat-smg' + PageTemp[PageTemp.find(u'{{WP|lang=sgs')+len(u'{{WP|lang=sgs'):len(PageTemp)]
	
	# URL de références : elles ne contiennent pas les diacritiques des {{PAGENAME}}
	while PageTemp.find(u'[http://www.sil.org/iso639-3/documentation.asp?id=') != -1:
		PageTemp2 = PageTemp[PageTemp.find(u'[http://www.sil.org/iso639-3/documentation.asp?id=')+len(u'[http://www.sil.org/iso639-3/documentation.asp?id='):len(PageTemp)]
		PageTemp = PageTemp[0:PageTemp.find(u'[http://www.sil.org/iso639-3/documentation.asp?id=')] + u'{{R:SIL|' + PageTemp2[0:PageTemp2.find(u' ')] + u'}}' + PageTemp2[PageTemp2.find(u']')+1:len(PageTemp2)]
		summary = summary + u', ajout de {{R:SIL}}'⏎
	while PageTemp.find(u'[http://www.cnrtl.fr/definition/') != -1:
		PageTemp2 = PageTemp[PageTemp.find(u'[http://www.cnrtl.fr/definition/')+len(u'[http://www.cnrtl.fr/definition/'):len(PageTemp)]
		PageTemp = PageTemp[0:PageTemp.find(u'[http://www.cnrtl.fr/definition/')] + u'{{R:TLFi|' + PageTemp2[0:PageTemp2.find(u' ')] + u'}}' + PageTemp2[PageTemp2.find(u']')+1:len(PageTemp2)]
	⏎
	PageTemp = PageEnd + PageTemp
	PageEnd = u''	summary = summary + u', ajout de {{R:TLFi}}'
	while PageTemp.find(u'[http://www.mediadico.com/dictionnaire/definition/') != -1:
		PageTemp2 = PageTemp[PageTemp.find(u'[http://www.mediadico.com/dictionnaire/definition/')+len(u'[http://www.mediadico.com/dictionnaire/definition/'):len(PageTemp)]
		PageTemp = PageTemp[0:PageTemp.find(u'[http://www.mediadico.com/dictionnaire/definition/')] + u'{{R:Mediadico|' + PageTemp2[0:PageTemp2.find(u'/1')] + u'}}' + PageTemp2[PageTemp2.find(u']')+1:len(PageTemp2)]
		summary = summary + u', ajout de {{R:Mediadico}}'
	while PageTemp.find(u'{{R:DAF8}}\n{{Import:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{R:DAF8}}\n{{Import:DAF8}}')] + PageTemp[PageTemp.find(u'{{R:DAF8}}\n{{Import:DAF8}}')+len(u'{{R:DAF8}}\n'):len(PageTemp)]
		summary = summary + u', doublon {{R:DAF8}}'
	while PageTemp.find(u'{{Import:DAF8}}\n{{R:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:DAF8}}\n{{R:DAF8}}')+len(u'{{Import:DAF8}}')] + PageTemp[PageTemp.find(u'{{Import:DAF8}}\n{{R:DAF8}}')+len(u'{{Import:DAF8}}\n{{R:DAF8}}'):len(PageTemp)]
		summary = summary + u', doublon {{R:DAF8}}'
	while PageTemp.find(u'{{R:Littré}}\n{{Import:Littré}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{R:Littré}}\n{{Import:Littré}}')] + PageTemp[PageTemp.find(u'{{R:Littré}}\n{{Import:Littré}}')+len(u'{{R:Littré}}\n'):len(PageTemp)]
		summary = summary + u', doublon {{R:Littré}}'
	while PageTemp.find(u'{{Import:Littré}}\n{{R:Littré}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:Littré}}\n{{R:Littré}}')+len(u'{{Import:Littré}}')] + PageTemp[PageTemp.find(u'{{Import:Littré}}\n{{R:Littré}}')+len(u'{{Import:Littré}}\n{{R:Littré}}'):len(PageTemp)]
		summary = summary + u', doublon {{R:Littré}}'
	while PageTemp.find(u'{{-réf-}}\n{{R:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{R:DAF8}}')] + u'*' + PageTemp[PageTemp.find(u'{{R:DAF8}}'):len(PageTemp)]
	while PageTemp.find(u'{{-réf-}}\n{{Import:DAF8}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:DAF8}}')] + u'*' + PageTemp[PageTemp.find(u'{{Import:DAF8}}'):len(PageTemp)]
	while PageTemp.find(u'{{-réf-}}\n{{Import:Littré}}') != -1:
		PageTemp = PageTemp[0:PageTemp.find(u'{{Import:Littré}}')] + u'*' + PageTemp[PageTemp.find(u'{{Import:Littré}}'):len(PageTemp)]⏎
		
	# Classement des traductions
	PageEnd = u''⏎
	while PageTemp.find(u'{{T|') != -1:
		PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'{{T|')]
		PageTemp = PageTemp[PageTemp.find(u'{{T|'):len(PageTemp)]
		# Rangement de la ligne de la traduction par ordre alphabétique de la langue dans PageEnd
		langue1 = PageTemp[PageTemp.find(u'{{T|')+4:PageTemp.find(u'}')]
		if langue1.find(u'|') != -1: langue1 = langue1[0:langue1.find(u'|')]
		if langue1 != u'':
			Langue1 = Page(site,u'Modèle:' + langue1)
			try: PageTemp2 = Langue1.get()
			except wikipedia.NoPage: return
			except wikipedia.IsRedirectPage: return
			except wikipedia.ServerError: return
			except wikipedia.BadTitle: ⏎
				print "NoPage l 1521 : " + langue1
				return
			except wikipedia.IsRedirectPage:
				PageTemp2 = Langue1.getRedirectTarget().title() + u'<noinclude>'
			except wikipedia.ServerError:
				print "ServerError l 1527 : " + langue1
				return
			except wikipedia.BadTitle:
				print "BadTitle l 1530 : " + langue1⏎
				return
			if PageTemp2.find(u'<noinclude>') != -1:
				langue = CleDeTri(PageTemp2[0:PageTemp2.find(u'<noinclude>')])
				langue2 = u'zzz'
				TradCourante = PageEnd[PageEnd.rfind(u'\n'):len(PageEnd)] + PageTemp[0:PageTemp.find(u'\n')]
				TradSuivantes = u''
				PageEnd = PageEnd[0:PageEnd.rfind(u'\n')]
				PageTemp = PageTemp[PageTemp.find(u'\n'):len(PageTemp)]
				while PageEnd.rfind(u'{{') != PageEnd.rfind(u'{{-trad-') and PageEnd.rfind(u'{{') != PageEnd.rfind(u'{{trad-début') and PageEnd.rfind(u'{{') != PageEnd.rfind(u'{{trad-fin') and PageEnd.rfind(u'{{') != PageEnd.rfind(u'{{trad-trier') and langue2 > langue and PageEnd.rfind(u'{{T') != PageEnd.rfind(u'{{T|conv') and PageEnd.rfind(u'{{') != PageEnd.rfind(u'{{(') and (PageEnd.rfind(u'{{') > PageEnd.rfind(u'|nocat') or PageEnd.rfind(u'|nocat') == -1):
					langue2 = PageEnd[PageEnd.rfind(u'{{T|')+len(u'{{T|'):len(PageEnd)]
					langue2 = langue2[0:langue2.find(u'}}')]
					if langue2.find(u'|') != -1: langue2 = langue2[0:langue2.find(u'|')]
					Langue2 = Page(site,u'Modèle:' + langue2)
					try: PageTemp3 = Langue2.get()
					except wikipedia.NoPage: return
					except wikipedia.ServerError: return
					except wikipedia.IsRedirectPage:
						print u'Redirection de⏎
						print "NoPage l 1546 : " + langue2
						return
					except wikipedia.ServerError: 
						print "ServerError l 1549 : " + langue2
						return
					except wikipedia.IsRedirectPage:
						print u'Redirection l 1552 : ' + langue2
						return
					if PageTemp3.find(u'<noinclude>') != -1:
						langue2 = CleDeTri(PageTemp3[0:PageTemp3.find(u'<noinclude>')])
						if langue2 > langue:
							summary = summary + ', traduction ' + langue2 + u'>' + langue⏎
							#print langue2 + u' > ' + langue
							if PageEnd.rfind(u'\n') > PageEnd.rfind(u'trad-début'):
								TradSuivantes = PageEnd[PageEnd.rfind(u'\n'):len(PageEnd)] + TradSuivantes
								PageEnd = PageEnd[0:PageEnd.rfind(u'\n')]
							else:
								# Cas de la première de la liste
								TradCourante = PageEnd[PageEnd.rfind(u'\n'):len(PageEnd)] + TradCourante
								PageEnd = PageEnd[0:PageEnd.rfind(u'\n')]
(contracted; show full);\'\', {{f}} : \'\'\'' + PageHS + u'te]], {{fplur}} : \'\'\'' + PageHS + u'tes]])')+len(u'({{p}} : \'\'\'' + PageHS + u's\'\'\', {{f}} : \'\'\'' + PageHS + u'te]], {{fplur}} : \'\'\'' + PageHS + u'tes]])')+1:len(PageTemp)]

	''' Anagrammes beaucoup trop long ( > 1 h par page), tester if len(PageHS) < 5 dans les vraies pages
  :
	# Ajout des anagrammes francophones (prévoir si {{lien|}} pour les autres)
	if PageTemp.find(u'{{-anagr-}}') == -1 and PageHS.find(u' ') == -1 and PageTemp.find(u'{{langue|fr}}') != -1:
		anagrammes = anagram(PageHS)
		ListeAnagrammes = u''
		for anagramme in anagrammes:
			print anagramme
			pageAnagr = Page(site,anagramme)
(contracted; show full)
								PageTemp = PageTemp[0:PageTemp.find(u' .')] + PageTemp[PageTemp.find(u' .')+1:len(PageTemp)]
						else:
							while PageTemp.find(u' ,') != -1:
								PageTemp = PageTemp[0:PageTemp.find(u' ,')] + PageTemp[PageTemp.find(u' ,')+1:len(PageTemp)]
							while PageTemp.find(u' .') != -1:
								PageTemp = PageTemp[0:PageTemp.find(u' .')] + PageTemp[PageTemp.find(u' .')+1:len(PageTemp)]
														
				else:
					print u'Problème de section dans ' + PageHS.encode(config.console_encoding, 'replace')
					return
			else:
				codelangue = PageTemp[PageTemp.find("{{=")+3:PageTemp.find("{{=")+3+PageTemp2.find("=|")]
				EstCodeLangue = u'true'
			PageTemp = PageTemp[0:position+2] + u'langue|' + codelangue + PageTemp[position+3+PageTemp2.find("}}"):len(PageTemp)]
			summary = summary + ', {{=' + codelangue + u'=}} -> {{langue|' + codelangue + u'}}'⏎
			position = PageTemp.find("}}")
		elif position == PageTemp.find(u'{{langue|'):
			#print (PageEnd.encode(config.console_encoding, 'replace')[0:1000])
			#raw_input (PageTemp[0:position].encode(config.console_encoding, 'replace'))
			PageTemp2 = PageTemp[position+len(u'{{langue|'):len(PageTemp)]
			if PageTemp2.find("}}") < PageTemp2.find("|") or PageTemp2.find("|") == -1:
(contracted; show full)
			PageTemp2 = PageTemp[0:PageTemp.find(u'}}')]
			if PageTemp2.find("|") != -1:
				codelangue = PageTemp2[PageTemp2.find("|")+1:len(PageTemp2)]
				EstCodeLangue = u'true'
				PageTemp = PageTemp[0:PageTemp.find(u'{{langue}}')] + u'{{langue|' + codelangue + u'}}' + PageTemp[PageTemp.find(u'{{langue}}')+len(u'{{langue}}'):len(PageTemp)]
				position = PageTemp.find("}}")

		⏎
		⏎
		position = position + 2
		PageEnd = PageEnd + PageTemp[0:position]		# Transfert vers la page finale de l'article jusqu'au modèle en traitement exclu
		PageTemp = PageTemp[position:len(PageTemp)]
		while PageTemp.find(" }}") < PageTemp.find("}}") and PageTemp.find(" }}") != -1:
			PageTemp = PageTemp[0:PageTemp.find(" }}")] + PageTemp[PageTemp.find(" }}")+1:len(PageTemp)]
		# Modèles imbriqués
(contracted; show full)				
			#print (PageEnd.encode(config.console_encoding, 'replace')[0:1000])
			#print (PageTemp[0:position].encode(config.console_encoding, 'replace'))
			# Comparaison avec chaque modèle connu dans Modele[p]
			for p in range(1,limit6):
				if Modele[p] == PageTemp[0:position]:
					#print (Modele[p].encode(config.console_encoding, 'replace'))
					# 
Modèles spéciaux
					if not codelangue:
						if p < limit1 or p >= limit3:
							PageEnd = u'{{formater|Code langue manquant dans ' + Modele[p] + u'}}\n' + PageBegin
							sauvegarde(page,PageEnd)⏎
	Si on est dans un modèle spécial, le traiter, sinon par catégorie de génériques
					if not codelangue and  (p < limit1 or p >= limit3):
						PageEnd = u'{{formater|Code langue manquant dans ' + Modele[p] + u'}}\n' + PageBegin
						summary = u'Page à formater manuellement'
						sauvegarde(page,PageEnd, summary)⏎
						return

					if Modele[p] == u'term' or Modele[p] == u'terme' or Modele[p] == u'régio' or Modele[p] == u'région':
						ModeleT = PageTemp[PageTemp.find("|")+1:PageTemp.find("}}")]
						for p2 in range(1,limit6):
							if Modele[p2] == ModeleT or Modele[p2] == ModeleT[0:1].lower() + ModeleT[1:len(ModeleT)]:
								if EstCodeLangue == "false":
									PageEnd = PageEnd + Modele[p2] + "|nocat=1}}"
(contracted; show full)
						elif PageTemp2[0:PageTemp2.find(u'|')] == u'ko-hanja':
							PageTemp = PageTemp[0:PageTemp.find(u'ko-hanja')] + u'ko' + PageTemp[PageTemp.find(u'ko-hanja')+len(u'ko-hanja'):len(PageTemp)]
						elif PageTemp2[0:PageTemp2.find(u'|')] == u'ko-Hani':
							PageTemp = PageTemp[0:PageTemp.find(u'ko-Hani')] + u'ko' + PageTemp[PageTemp.find(u'ko-Hani')+len(u'ko-Hani'):len(PageTemp)]

						elif PageTemp2[0:PageTemp2.find(u'|')] == u'yue':
							PageTemp = PageTemp[0:PageTemp.find(u'yue')] + u'zh-yue' + PageTemp[PageTemp.find(u'yue')+len(u'yue'):len(PageTemp)]⏎
						
						if PageTemp2[0:PageTemp2.find(u'|')] == u'mo': break # Bug du site fermé, voir [[chat]]
						# Connexions aux Wiktionnaires des traductions
						PageTemp2 = PageTemp[position+1:len(PageTemp)]
						PageTemp3 = PageTemp2[PageTemp2.find(u'|')+1:len(PageTemp2)]
						if PageTemp2[0:PageTemp2.find(u'|')] == "": break
						elif PageTemp3.find(u'}}') == "" or not PageTemp3.find(u'}}'): break
(contracted; show full)
	'''# Recherche de bug
	if PageEnd.find(u'{{trad-début|{{') != -1:		
		txtfile = codecs.open(u'articles_listed.txt', 'a', 'utf-8')
		txtfile.write(u'* [[' + PageHS + u']]\n')
		txtfile.close()'''
	if PageEnd != PageBegin: sauvegarde(page,PageEnd
, summary)

def CleDeTri(PageTitre):
	PageT = u''
	key = "false"
	for lettre in range(0,len(PageTitre)):
		# Latin
		if PageTitre[lettre:lettre+1] == u'à' or PageTitre[lettre:lettre+1] == u'Á' or PageTitre[lettre:lettre+1] == u'á' or PageTitre[lettre:lettre+1] == u'â' or PageTitre[lettre:lettre+1] == u'ä' or PageTitre[lettre:lettre+1] == u'ā' or PageTitre[lettre:lettre+1] == u'ă' or PageTitre[lettre:lettre+1] == u'ą' (contracted; show full)tre:lettre+1] == u'Ȍ' or PageTitre[lettre:lettre+1] == u'Ȏ' or PageTitre[lettre:lettre+1] == u'Ȫ' or PageTitre[lettre:lettre+1] == u'Ȭ' or PageTitre[lettre:lettre+1] == u'Ȯ' or PageTitre[lettre:lettre+1] == u'Ȱ' or PageTitre[lettre:lettre+1] == u'ɔ' or PageTitre[lettre:lettre+1] == u'ở' or PageTitre[lettre:lettre+1] == u'Ở' or PageTitre[lettre:lettre+1] == u'ợ' or PageTitre[lettre:lettre+1] == u'Ợ'
 or PageTitre[lettre:lettre+1] == u'ò' or PageTitre[lettre:lettre+1] == u'ó':
			PageT = PageT + "o"
			key = "yes"
		elif PageTitre[lettre:lettre+1] == u'œ' or PageTitre[lettre:lettre+1] == u'Œ':
			PageT = PageT + "oe"
			key = "yes"
		elif PageTitre[lettre:lettre+1] == u'ƥ' or PageTitre[lettre:lettre+1] == u'Ƥ':
			PageT = PageT + "p"
(contracted; show full)			except wikipedia.ServerError: return
			except wikipedia.BadTitle: return
			except pywikibot.EditConflict: return
			if PageTemp != u"{{/Stop}}":
				pywikibot.output (u"\n*** \03{lightyellow}Arrêt d'urgence demandé\03{default} ***")
				exit(0)

def sauvegarde(PageCourante, Contenu
, summary):
	ArretDUrgence()
	result = "ok"
	#print(Contenu.encode(config.console_encoding, 'replace')[0:4000])	#[len(Contenu)-2000:len(Contenu)]) #
	#result = raw_input("Sauvegarder ? (o/n)")
	if result != "n" and result != "no" and result != "non":
		try:
			PageCourante.put(Contenu, summary)
		except wikipedia.NoPage: return
		except wikipedia.IsRedirectPage: return
		except wikipedia.LockedPage: return
		except pywikibot.EditConflict: return
		except wikipedia.ServerError: return
		except wikipedia.BadTitle: return
	
# Lancement
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Codes langue manquants',True,u'')
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Flexions à vérifier',True,u'')
TraitementLiens = crawlerLink(u'Modèle:1ergroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:2egroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:3egroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:trad',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects:fr-verbe-flexion incomplet',False,u'')
TraitementLiensCategorie = crawlerCatLink(u'Modèles de code langue',u'')
'''
TraitementLiens = crawlerLink(u'Modèle:(',u'éclipser')
TraitementLiens = crawlerLink(u'Modèle:-flex-nom-',u'')
TraitementLiens = crawlerLink(u'Modèle:clé de tri',u'')
TraitementLiens = crawlerLink(u'Modèle:trad-début',u'')
#TraitementLiens = crawlerLink(u'Modèle:prv',u'')
#TraitementLiens = crawlerLink(u'Modèle:gsw-FR',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Codes langue manquants',True,u'')
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Flexions à vérifier',True,u'')
TraitementLiens = crawlerLink(u'Modèle:1ergroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:2egroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:3egroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:trad',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects:fr-verbe-flexion incomplet',False,u'')⏎
if not summary: summary = u'[[Wiktionnaire:Structure des articles|Autoformatage]]'
		try:
			PageCourante.put(Contenu, summary)
		except wikipedia.NoPage: 
			print "NoPage l 3784"
			return
		except wikipedia.IsRedirectPage: 
			print "NoPage l 3787"
			return
		except wikipedia.LockedPage: 
			print "NoPage l 3790"
			return
		except pywikibot.EditConflict: 
			print "NoPage l 3793"
			return
		except wikipedia.ServerError: 
			print "NoPage l 3796"
			return
		except wikipedia.BadTitle: 
			print "NoPage l 3799"
			return
	
# Lancement
TraitementPage = modification(u'déferlable')
'''
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Codes langue manquants',True,u'')
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Flexions à vérifier',True,u'')
TraitementLiens = crawlerLink(u'Modèle:1ergroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:2egroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:3egroupe',u'')
TraitementLiens = crawlerLink(u'Modèle:trad',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects:fr-verbe-flexion incomplet',False,u'')
TraitementLiens = crawlerLink(u'Modèle:=langue=',u'')

TraitementLiens = crawlerLink(u'Modèle:(',u'')
TraitementLiens = crawlerLink(u'Modèle:-flex-nom-',u'')
TraitementLiens = crawlerLink(u'Modèle:trad-début',u'')
TraitementLiens = crawlerLink(u'Modèle:clé de tri',u'')

TraitementLiensCategorie = crawlerCatLink(u'Modèles de code langue',u'')
TraitementPage = modification(u'Utilisateur:JackBot/test')
TraitementFichier = crawlerFile('articles_list.txt')
TraitementUtilisateur = crawlerUser(u'User:JackBot')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects',True)
TraitementRecherche = crawlerSearch(u'chinois')
TraitementUtilisateur = crawlerUser(u'Utilisateur:JackBot')
TraitementTout = crawlerAll(u'')
while 1:
	TraitementRC = crawlerRC()
'''
</source>