Difference between revisions 15170926 and 15195624 on frwiktionary

[[Catégorie:JackBot|{{SUBPAGENAME}}]]
<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 de modèles et d'espaces.
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 (dont "nocat=1" si une catégorie le justifie).
5) Complète les flexions de verbes en français à vérifier.
6) Traduit les importations de en.wikt.
7) Gère des modèles {{voir}} en début de page.
8) Ajoute les anagrammes (pour les mots de sept lettres ou moinpetits mots)
9) Teste les URL et indique si elles sont brisées avec {{lien brisé}}, et les transforme en modèle s'il existe pour leur site
10) Remplace les modèles catégorisés comme obsolètes
11) Créer des liens absents : http://fr.wiktionary.org/w/index.php?title=radiateur&diff=prev&oldid=14443668
12) Détecte les modèles à ajouter : http://fr.wiktionary.org/w/index.php?title=cl%C3%A9&diff=prev&oldid=14443625
13) Crée les redirection d'apostrophe dactylographique vers apostrophe typographique
Testé ici : http://fr.wiktionary.org/w/index.php?title=Utilisateur%3AJackBot%2Ftest&diff=14533806&oldid=14533695
'''

# Importation des modules
import catlib, pagegenerators, os, codecs, urllib, re, collections, socket
import hyperlynx, CleDeTri, HTMLUnicode		# Faits maison
from wikipedia import *

# Déclaration
language = "fr"
family = "wiktionary"
mynick = "JackBot"
site = getSite(language,family)
debogage = False
debogageLent = False
TailleAnagramme = 75 # sinon trop long : 5 > 5 min, 8 > 1 h par page)

# Modèles du site à traiter
limit6=9848
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[74] = u'-nom-'
Modele[75] = u'-nom-fam-'
Modele[76] = u'-nom-ni-'
Modele[77] = u'-nom-nu-'
Modele[79] = u'-nom-nn-'
Modele[79] = u'-nom-npl-'
Modele[80] = u'-nom-pr-'
Modele[81] = u'-nom-
sciencespropre-'
Modele[82] = u'-numér-'
Modele[83] = u'-part-'
Modele[84] = u'-post-'
Modele[85] = u'-préf-'
Modele[87] = u'-prép-'
Modele[88] = u'-pronom-'
Modele[89] = u'-pronom-adj-'
Modele[90] = u'-pronom-dém-'
Modele[91] = u'-pronom-indéf-'
Modele[92] = u'-pronom-int-'
Modele[93] = u'-pronom-pers-'
Modele[94] = u'-pronom-pos-'
Modele[95] = u'-pronom-rel-'
Modele[96] = u'-prov-'
Modele[97] = u'-racine-'
Modele[98] = u'-radical-'
Modele[99] = u'-rimes-'
Modele[100] = u'-sigle-'
Modele[101] = u'-signe-'
Modele[102] = u'-subst-pron-pers-'
Modele[103] = u'-suf-'
Modele[104] = u'-flex-suf-'
Modele[105] = u'-var-typo-'
Modele[106] = u'-verb-'
Modele[107] = u'-verb-pr-'
Modele[108] = u'-verbe-'
Modele[109] = u'-adjectif-'
Modele[110] = u'-adverbe-'
Modele[111] = u'-locution-'
Modele[112] = u'-préfixe-'
Modele[113] = u'-suffixe-'
Modele[114] = u'-symb-'
Modele[115] = u'-inf-'
Modele[116] = u'-onoma-'
Modele[117] = u'-onoma-'
Modele[118] = u'-flex-loc-verbe-'
Modele[119] = u'-class-'
Modele[120] = u'-sinogramme-'
Modele[121] = u'-prénom-'
Modele[122] = u'-flex-prénom-'
Modele[123] = u'-num-'
Modele[124] = u'-nom-sciences-'⏎
limit1 = 1245 # Paragraphes avec modèle catégorisant

# http://fr.wiktionary.org/wiki/Cat%C3%A9gorie:Mod%C3%A8les_de_contexte
Modele[124] = u'-exp-'⏎
Modele[125] = u'-faux-amis-'
Modele[126] = u'-gent-'
Modele[127] = u'-hist-'
Modele[128] = u'-holo-'
Modele[129] = u'-homo-'
Modele[130] = u'-hyper-'
Modele[131] = u'-hypo-'
Modele[132] = u'-image-'
Modele[133] = u'-méro-'
Modele[134] = u'-note-'	#notes
Modele[135] = u'-var-ortho-'
Modele[136] = u'-ortho-arch-'
Modele[137] = u'-paro-'
Modele[138] = u'-vidéo-'
Modele[139] = u'-q-syn-'
Modele[140] = u'-réf-'
Modele[141] = u'-sino-dico-'
Modele[142] = u'-sous-esp-'
Modele[143] = u'-syll-'
Modele[144] = u'-syn-'
Modele[145] = u'-noms-vern-'
Modele[146] = u'-tran-'
Modele[147] = u'-trans-'
Modele[148] = u'-translit-'
Modele[149] = u'-tropo-'
Modele[150] = u'-var-'
Modele[151] = u'-voc-'
Modele[152] = u'-voir-'
Modele[153] = u'-pron-'
Modele[154] = u'-abrév-'
Modele[155] = u'-anagr-'
Modele[156] = u'-ant-'
Modele[157] = u'-apr-'
Modele[158] = u'-cit-'
Modele[159] = u'-compos-'
Modele[160] = u'-conjug-'
Modele[161] = u'-décl-'
Modele[162] = u'-dial-'
Modele[163] = u'-trad-'
Modele[164] = u'-drv-int-'
Modele[165] = u'-étym-'
Modele[166] = u'-abréviation-'
Modele[167] = u'-dimin-'
Modele[168] = u'-drv-'⏎
Modele[169] = u'-exp-'

limit2 = 16970 # Paragraphes sans modèle catégorisant, {{voir| et {{voir/ sont gérés individuellement
Modele[169] = u'PàS'⏎
Modele[170] = u'vérifier'
Modele[171] = u'voir'	
Modele[172] = u'('
Modele[173] = u')'
Modele[174] = u'trad-début'
Modele[175] = u'trad-fin'
Modele[176] = u'titre alt'
Modele[177] = u'titre mis en forme'
Modele[178] = u'trad'
Modele[179] = u'trad+'
Modele[180] = u'trad-'
Modele[181] = u'trad--'
Modele[182] = u'préciser'
Modele[183] = u'?'
Modele[184] = u'doute'
Modele[185] = u'm'
Modele[186] = u'f'
Modele[187] = u'titre incorrect'
Modele[188] = u'formater'
Modele[189] = u'suppression'
Modele[190] = u'supp'
Modele[191] = u'SI'
Modele[192] = u'supprimer ?'⏎
⏎
limit25 = 193
Modele[193] = u'moins courant'PàS'

limit25 = 194
Modele[194] = u'plus rare'
Modele[195] = u'beaucoup plus courant'
Modele[196] = u'beaucoup moins courant'
Modele[197] = u'pl-cour'
Modele[198] = u'm-cour'
Modele[199] = u'pl-rare'
Modele[200] = u'b-pl-cour'
Modele[201] = u'b-m-cour'
Modele[202] = u'n'
Modele[203] = u'c'
Modele[204] = u'mf'
Modele[205] = u'mf?'
Modele[206] = u'fm ?'
Modele[207] = u'plus courant'⏎
Modele[208] = u'moins courant'

limit3 = 2089 # Paragraphes sans modèle catégorisant pouvant contenir des modèles
# http://fr.wiktionary.org/wiki/Cat%C3%A9gorie:Mod%C3%A8les_de_domaine_d%E2%80%99utilisation
Modele[208] = u'joaillerie'⏎
Modele[209] = u'informel'
Modele[210] = u'injurieux'
Modele[211] = u'interjection'
Modele[212] = u'ironique'
Modele[213] = u'litote'
Modele[214] = u'littéraire'
Modele[215] = u'péjoratif'
Modele[216] = u'mélioratif'
Modele[217] = u'métaphore'
Modele[218] = u'métonymie'
Modele[219] = u'mot-valise'
Modele[220] = u'néologisme'
Modele[221] = u'néol litt'
Modele[222] = u'anglicisme'
Modele[223] = u'antiquité'
Modele[224] = u'ordinal'
Modele[225] = u'palindrome'
Modele[226] = u'archaïque'
Modele[227] = u'poissons'
Modele[228] = u'virologie'
Modele[229] = u'viticulture'
Modele[230] = u'zoologie'
Modele[231] = u'plaisanterie'
Modele[232] = u'poétique'
Modele[233] = u'populaire'
Modele[234] = u'propre'
Modele[235] = u'proverbial'
Modele[236] = u'rare'
Modele[237] = u'sigle'
Modele[238] = u'soutenu'
Modele[239] = u'désuet'
Modele[240] = u'saccusatifinsecte'
Modele[241] = u'sdatifpoisson'
Modele[242] = u'très familier'
Modele[243] = u'vieilli'
Modele[244] = u'vulgaire'
Modele[245] = u'wiki'
Modele[246] = u'popu'
Modele[247] = u'vx'
Modele[248] = u'dés'
(contracted; show full)Modele[830] = u'bouddhisme'
Modele[831] = u'hindouisme'
Modele[832] = u'marbrerie'
Modele[833] = u'miroiterie'
Modele[834] = u'fontainerie'
Modele[835] = u'phonétique'
Modele[836] = u'apiculture'
Modele[837] = u'
insecteélectoraux'
Modele[838] = u'poissonjoaillerie'
Modele[839] = u'électoraux'

limit4 = 840	# code langue quoi qu'il arrivesaccusatif'
Modele[840] = u'ébauche-étymsdatif'
Modele[841] = u'ébauche-pronsinstrumental'
Modele[842] = u'ébauche'
Modele[843] = u'ébauche-exe'généralement indénombrable'
Modele[843] = u'bibliothéconomie'

limit4 = 844	# code langue quoi qu'il arrive
Modele[844] = u'ébauche-pron'
Modele[845] = u'ébauche-syn'
Modele[846] = u'note-gentilé'
Modele[847] = u'ébauche-étym-nom-scientifique'
Modele[848] = u'ébauche-trans'
Modele[849] = u'ébauche-déf'
Modele[850] = u'ébauche-étym'
Modele[851] = u'ébauche-pron'
Modele[852] = u'ébauche'
Modele[853] = u'ébauche-exe'⏎
'''
# non traités
Modele[] = u'spécialement' 
Modele[] = u'T'
Modele[] = u'région'
Modele[] = u'régio'
Modele[] = u'régional'
'''
# Modèles régionaux, pb du nocat pour les prononciations
limit5 = 850
Modele[850] = u'Lyonnais'
Modele[851] = u'Madagascar'
Modele[852] = u'Maghreb'
Modele[853] = u'Mali'4
Modele[854] = u'Maroc'
Modele[855] = u'Marseille'
Modele[856] = u'Maurice'
Modele[857] = u'Mayotte'
Modele[858] = u'Mexique'
Modele[859] = u'Midi'
Modele[860] = u'Midi toulousain'
(contracted; show full)Modele[975] = u'Jamaïque'
Modele[976] = u'Languedoc-Roussillon'
Modele[977] = u'Le Mans'
Modele[978] = u'Liban'
Modele[979] = u'Liechtenstein'
Modele[980] = u'Limousin'
Modele[981] = u'Louisiane'

Modele[982] = u'Lyonnais'
Modele[983] = u'Madagascar'
Modele[984] = u'Maghreb'
Modele[985] = u'Mali'⏎
# Modèles de pronociation à synchroniser
Modele[9826] = u'en-conj-rég'
#Modele[] = u'fr-rég'
#Modele[] = u'fr-inv'
 
# Modèles des autres Wiktionnaires à convertir
LimitTemplate = 82
Template = range(1, LimitTemplate+1)
TemplateFR = range(1, LimitTemplate+1)
(contracted; show full)
		PageTemp = PageTemp.replace(u'\n* {{SAMPA}} :\n', u'\n')
		PageTemp = PageTemp.replace(u'{{Massorète}}:', u'{{Massorète}} :')
		PageTemp = PageTemp.replace(u'{{pron||hbo}}:', u'API :')
		PageTemp = PageTemp.replace(u'{{SAMPA}}:', u'{{SAMPA}} :')
		PageTemp = PageTemp.replace(u'{{sexua|', u'{{sexe|')
		PageTemp = PageTemp.replace(u'{{conj-hbo}}', u'{{conjugaison|hbo}}')

		PageTemp = PageTemp.replace(u'{{conj-fro}}', u'{{conjugaison|fro}}')
		PageTemp = PageTemp.replace(u'{{conj-frm}}', u'{{conjugaison|frm}}')
		PageTemp = PageTemp.replace(u'{{conj-fr}}', u'{{conjugaison|fr}}')
		PageTemp = PageTemp.replace(u'{{conj-en}}', u'{{conjugaison|en}}')
		PageTemp = PageTemp.replace(u'{{conj-es}}', u'{{conjugaison|es}}')
		PageTemp = PageTemp.replace(u'{{conj-de}}', u'{{conjugaison|de}}')⏎
		PageTemp = PageTemp.replace(u'{{-trad-}}\n{{trad-début}}\n{{trad-fin}}', u'') # trait gris
		PageTemp = PageTemp.replace(u'{|\n|}', u'')
		PageTemp = PageTemp.replace(u'{{auxiliaire être}}', u'{{note-auxiliaire|fr|être}}')
		PageTemp = PageTemp.replace(u'myt=scandinave', u'myt=nordique')
		PageTemp = PageTemp.replace(u'religion|rel=chrétienne', u'christianisme')
(contracted; show full)				PageEnd = PageEnd + PageTemp
				PageTemp = u''
			#print(PageEnd.encode(config.console_encoding, 'replace'))
			#print(PageTemp.encode(config.console_encoding, 'replace'))
		PageTemp = PageEnd + PageTemp
		PageEnd = u''"""
		

		# Ajout des anagrammes francophones (prévoir si {{lien|}} pour les autres)
		if debogage == True: print u'Anagrammes'
		if debogage == False and socket.gethostname() != "willow" and socket.gethostname() != "yarrow" and socket.gethostname() != "nightshade" and PageHS != u'six' and PageTemp.find(u'-erreur-') == -1:
			if PageTemp.find(u'{{-anagr-}}') == -1 and PageHS.find(u' ') == -1 and PageTemp.find(u'{{langue|fr}}') != -1 and len(PageHS) < TailleAnagramme: 
				#print socket.gethostname()
				anagrammes = anagram(PageHS)
				ListeAnagrammes = u''
				for anagramme in anagrammes:
					if anagramme != PageHS:
						pageAnagr = Page(site,anagramme)
						#print anagramme.encode(config.console_encoding, 'replace')
						if pageAnagr.exists():
							if pageAnagr.namespace() !=0 and anagramme != u'Utilisateur:JackBot/test':
								return
							else:
								try:
									PageTempAnagr = pageAnagr.get()
								except wikipedia.NoPage: return
								except wikipedia.IsRedirectPage: return
								except wikipedia.LockedPage: return
							if PageTempAnagr.find(u'{{langue|fr}}') != -1:
								ListeAnagrammes = ListeAnagrammes + u'* [[' + anagramme + u']]\n'
				if ListeAnagrammes != u'':
					position = PageTemp.find(u'{{langue|fr}}')+len(u'{{langue|fr}}')
					PageTemp2 = PageTemp[position:len(PageTemp)]
					if PageTemp2.find(u'{{-voir-}}') != -1 and ((PageTemp2.find(u'{{langue|') != -1 and PageTemp2.find(u'{{-voir-}}') < PageTemp2.find(u'{{langue|')) or PageTemp2.find(u'{{langue|') == -1):
						PageTemp = PageTemp[0:position+PageTemp2.find(u'{{-voir-}}')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'{{-voir-}}'):len(PageTemp)]
					elif PageTemp2.find(u'{{-réf-}}') != -1 and ((PageTemp2.find(u'{{langue|') != -1 and PageTemp2.find(u'{{-réf-}}') < PageTemp2.find(u'{{langue|')) or PageTemp2.find(u'{{langue|') == -1):
						PageTemp = PageTemp[0:position+PageTemp2.find(u'{{-réf-}}')] +  u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'{{-réf-}}'):len(PageTemp)]
					elif PageTemp2.find(u'== {{langue|') != -1 and ((PageTemp2.find(u'[[Catégorie:') != -1 and PageTemp2.find(u'== {{langue|') < PageTemp2.find(u'[[Catégorie:')) or PageTemp2.find(u'[[Catégorie:') == -1):
						PageTemp = PageTemp[0:position+PageTemp2.find(u'== {{langue|')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'== {{langue|'):len(PageTemp)]
					elif PageTemp2.find(u'=={{langue|') != -1 and ((PageTemp2.find(u'[[Catégorie:') != -1 and PageTemp2.find(u'=={{langue|') < PageTemp2.find(u'[[Catégorie:')) or PageTemp2.find(u'[[Catégorie:') == -1):
						PageTemp = PageTemp[0:position+PageTemp2.find(u'=={{langue|')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'=={{langue|'):len(PageTemp)]								
					elif PageTemp2.find(u'{{clé de tri') != -1:
						PageTemp = PageTemp[0:position+PageTemp2.find(u'{{clé de tri')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'{{clé de tri'):len(PageTemp)]
					elif PageTemp2.find(u'[[Catégorie:') != -1:
						PageTemp = PageTemp[0:position+PageTemp2.find(u'[[Catégorie:')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'[[Catégorie:'):len(PageTemp)]
					else:	# Avant interwikis
						if PageTemp.find(u'[[en:') or PageTemp.find(u'[[ko:') or PageTemp.find(u'[[vi:') != -1:
							regex = ur'\[\[(.+?)(?:\]\]\n)'		# copié de pywikipedia mais pas infaillible, d'où le [[en:...
							if re.compile(regex).search(PageTemp):
								try:
									PageTemp = PageTemp[0:re.search(regex,PageTemp).end()] + u'\n{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[re.search(regex,PageTemp).end():len(PageTemp)]
								except:
									print u'pb regex interwiki'
							else:
								PageTemp = PageTemp + u'\n\n{{-anagr-}}\n' + ListeAnagrammes
						else:
							PageTemp = PageTemp + u'\n\n{{-anagr-}}\n' + ListeAnagrammes
					if PageTemp.find(u'<!-- pas d’{{-anagr-}} -->\n') != -1: PageTemp = PageTemp[0:PageTemp.find(u'<!-- pas d’{{-anagr-}} -->\n')] + PageTemp[PageTemp.find(u'<!-- pas d’{{-anagr-}} -->\n')+len(u'<!-- pas d’{{-anagr-}} -->\n'):len(PageTemp)]⏎
					⏎
		# Remplacement des codes langues
		if debogage == True: print u'Remplacement des anciens codes langue'
		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, 13)
		NouveauModele = range(1, 13)
		AncienModele[1] = u'ko-hanja'
		NouveauModele[1] = u'ko-Hani'
(contracted; show full)
		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)]
							
		# Ajouts des codes langues
		if debogage == True: print (u'Gestion des codes langues dans les modèles')
		EstCodeLangue = u'false'

		if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
		trad = u'false'
		codelangue = None
		position = 1
		p = 1
		while position > -1:	# On sauvegarde la partie traitée d'une page provisoire dans une page finale jusqu'à disparition de la première
			#print(PageEnd.encode(config.console_encoding, 'replace')[0:1000])
			#print(PageTemp.encode(config.console_encoding, 'replace')[0:1000])
			if debogageLent == True:
(contracted; show full)			
			# Recherche de chaque modèle
			position = PageTemp.find(u'{{')
			if position < 0: break
			if position == PageTemp.find(u'{{caractère}}'):
				codelangue = u'conv'
				EstCodeLangue = u'false'

				if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
			elif position == PageTemp.find(u'{{='):
				PageTemp2 = PageTemp[position+3:len(PageTemp)]
				if PageTemp2.find("}}") < PageTemp2.find("|") or PageTemp2.find("|") == -1:
					if PageTemp.find("{{=") < PageTemp.find("=}}"):
						codelangue = PageTemp[PageTemp.find("{{=")+3:PageTemp.find("=}}")]
						# RegexCodeLangue = ur'[a-b]+\-*[a-b]*'
						if codelangue.find(u'=') != -1:
							PageEnd = u'{{formater|Code langue inexistant : ' + codelangue + u'}}\n' + PageBegin
							summary = u'Page à formater manuellement'
							sauvegarde(page, PageEnd, summary)
							return
						EstCodeLangue = u'true'
						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
						if codelangue == u'fr':
							# Nettoyage de la ponctuation en français
							if PageTemp.find(u'{{langue|') != -1:
								while PageTemp.find(u' ,') != -1 and PageTemp.find(u' ,') < PageTemp.find(u'{{langue|'):
									PageTemp = PageTemp[0:PageTemp.find(u' ,')] + PageTemp[PageTemp.find(u' ,')+1:len(PageTemp)]
								while PageTemp.find(u' .') != -1 and PageTemp.find(u' ,') < PageTemp.find(u'{{langue|'):
									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'
					if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
				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'))
				if debogage == True: print u'Nouveau code langue'⏎
				PageTemp2 = PageTemp[position+len(u'{{langue|'):]
				if PageTemp2.find("}}") < PageTemp2.find("|") or PageTemp2.find("|") == -1:
					if PageTemp.find(u'{{langue|') < PageTemp.find(u'}}'):
						if debogage == True: print u'Nouveau code langue simple'
						codelangue = PageTemp[PageTemp.find(u'{{langue|')+len(u'{{langue|'):PageTemp.find("}}")]
						EstCodeLangue = u'true'
						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
					else:
						if debogage == True: print u'Nouveau code langue après fin de modèle(s) (imbriqués)'
						PageTemp2 = PageTemp[PageTemp.find(u'{{langue|')+len(u'{{langue|'):]
						codelangue = PageTemp2[:PageTemp2.find(u'}}')]
						EstCodeLangue = u'true'
						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
				else:
					if debogage == True: print u'Nouveau code langue multi-paramètres'
					codelangue = PageTemp[PageTemp.find(u'{{langue|')+len(u'{{langue|'):PageTemp.find(u'{{langue|')+len(u'{{langue|')+PageTemp2.find("}}")]
					EstCodeLangue = u'true'
					if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
					position = PageTemp.find("{{")
				if debogage == True: print u'Nouveau code langue trouvé : ' + codelangue
				if codelangue.find(u'=') != -1:
					PageEnd = u'{{formater|Code langue inexistant : ' + codelangue + u'}}\n' + PageBegin
					summary = u'Page à formater manuellement'
					sauvegarde(page, PageEnd, summary)
					return
					⏎
				# Ajout des anagrammes pour cette nouvelle langue détectée
				if debogage == True: print u' Anagrammes pour ' + codelangue
				if debogageLent == True: print socket.gethostname()
				if socket.gethostname() != "willow" and socket.gethostname() != "yarrow" and socket.gethostname() != "nightshade" and PageTemp.find(u'-erreur-') == -1 and PageHS != u'six':
					if PageTemp.find(u'{{-anagr-}}') == -1 and PageHS.find(u' ') == -1 and len(PageHS) < TailleAnagramme: 
						anagrammes = anagram(PageHS)
						ListeAnagrammes = u''
						for anagramme in anagrammes:
							if anagramme != PageHS:
								if debogage == True: print anagramme.encode(config.console_encoding, 'replace')
								pageAnagr = Page(site,anagramme)
								if pageAnagr.exists():
									if pageAnagr.namespace() !=0 and anagramme != u'Utilisateur:JackBot/test':
										return
									else:
										try:
											PageTempAnagr = pageAnagr.get()
										except wikipedia.NoPage: return
										except wikipedia.IsRedirectPage: return
										except wikipedia.LockedPage: return
									if PageTempAnagr.find(u'{{langue|' + codelangue + u'}}') != -1:
										ListeAnagrammes = ListeAnagrammes + u'* {{lien|' + anagramme + u'|' + codelangue + u'}}\n'
										if debogage == True: print u' trouvé'
						if ListeAnagrammes != u'':
							position = PageTemp.find(u'{{langue|' + codelangue + u'}}')+len(u'{{langue|' + codelangue + u'}}')
							PageTemp2 = PageTemp[position:len(PageTemp)]
							if PageTemp2.find(u'{{-voir-}}') != -1 and ((PageTemp2.find(u'{{langue|') != -1 and PageTemp2.find(u'{{-voir-}}') < PageTemp2.find(u'{{langue|')) or PageTemp2.find(u'{{langue|') == -1):
								PageTemp = PageTemp[0:position+PageTemp2.find(u'{{-voir-}}')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'{{-voir-}}'):len(PageTemp)]
							elif PageTemp2.find(u'{{-réf-}}') != -1 and ((PageTemp2.find(u'{{langue|') != -1 and PageTemp2.find(u'{{-réf-}}') < PageTemp2.find(u'{{langue|')) or PageTemp2.find(u'{{langue|') == -1):
								PageTemp = PageTemp[0:position+PageTemp2.find(u'{{-réf-}}')] +  u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'{{-réf-}}'):len(PageTemp)]
							elif PageTemp2.find(u'== {{langue|') != -1 and ((PageTemp2.find(u'[[Catégorie:') != -1 and PageTemp2.find(u'== {{langue|') < PageTemp2.find(u'[[Catégorie:')) or PageTemp2.find(u'[[Catégorie:') == -1):
								PageTemp = PageTemp[0:position+PageTemp2.find(u'== {{langue|')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'== {{langue|'):len(PageTemp)]
							elif PageTemp2.find(u'=={{langue|') != -1 and ((PageTemp2.find(u'[[Catégorie:') != -1 and PageTemp2.find(u'=={{langue|') < PageTemp2.find(u'[[Catégorie:')) or PageTemp2.find(u'[[Catégorie:') == -1):
								PageTemp = PageTemp[0:position+PageTemp2.find(u'=={{langue|')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'=={{langue|'):len(PageTemp)]								
							elif PageTemp2.find(u'{{clé de tri') != -1:
								PageTemp = PageTemp[0:position+PageTemp2.find(u'{{clé de tri')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'{{clé de tri'):len(PageTemp)]
							elif PageTemp2.find(u'[[Catégorie:') != -1:
								PageTemp = PageTemp[0:position+PageTemp2.find(u'[[Catégorie:')] + u'{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[position+PageTemp2.find(u'[[Catégorie:'):len(PageTemp)]
							else:	# Avant interwikis
								if PageTemp.find(u'[[en:') or PageTemp.find(u'[[ko:') or PageTemp.find(u'[[vi:') != -1:
									regex = ur'\[\[(.+?)(?:\]\]\n)'		# copié de pywikipedia mais pas infaillible, d'où le [[en:...
									if re.compile(regex).search(PageTemp):
										try:
											PageTemp = PageTemp[0:re.search(regex,PageTemp).end()] + u'\n{{-anagr-}}\n' + ListeAnagrammes + u'\n' + PageTemp[re.search(regex,PageTemp).end():len(PageTemp)]
										except:
											print u'pb regex interwiki'
									else:
										PageTemp = PageTemp + u'\n\n{{-anagr-}}\n' + ListeAnagrammes
								else:
									PageTemp = PageTemp + u'\n\n{{-anagr-}}\n' + ListeAnagrammes
							if PageTemp.find(u'<!-- pas d’{{-anagr-}} -->\n') != -1: PageTemp = PageTemp[0:PageTemp.find(u'<!-- pas d’{{-anagr-}} -->\n')] + PageTemp[PageTemp.find(u'<!-- pas d’{{-anagr-}} -->\n')+len(u'<!-- pas d’{{-anagr-}} -->\n'):len(PageTemp)]⏎
							⏎
			elif position == PageTemp.find(u'{{langue}}'):
				# Recherche d'un codelangue à préciser
				PageTemp2 = PageTemp[PageTemp.find(u'}}')+2:len(PageTemp)]
				PageTemp2 = PageTemp[PageTemp.find(u'{{')+2:len(PageTemp)]
				PageTemp2 = PageTemp[0:PageTemp.find(u'}}')]
				if PageTemp2.find("|") != -1:
					codelangue = PageTemp2[PageTemp2.find("|")+1:len(PageTemp2)]
					EstCodeLangue = u'true'
					if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
					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)]
			
			# Fin du nom du modèle
(contracted; show full)
							return
					PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]
					PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
					#break	# pb https://fr.wiktionary.org/w/index.php?title=ordre&curid=343&diff=14727763&oldid=14725107'''
						
					# 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) and Modele[p] != u'ébauche':

						# pb -nom-|fro}}
						#	'''hazard''' {{pron||fro}} {{m}}
						#	# {{variante de|hazart|fro}}.⏎
						PageEnd = u'{{formater|Code langue manquant dans ' + Modele[p] + u' après le caractère ' + str(len(PageEnd)) + u'}}\n' + PageBegin
						summary = u'Page à formater manuellement'
						sauvegarde(page, PageEnd, summary)
						return
					⏎
					if Modele[p] == u'-nom-' and (codelangue == 'fr' or codelangue == 'es' or codelangue == 'pt' or codelangue == 'it' or codelangue == 'de'):
						if debogage == True: print u'Recherche du genre manquant'
						if PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'') != -1 and PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'') < 100:
							PageTemp2 = PageTemp[PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'')+len(u'\n\'\'\'' + PageHS + u'\'\'\''):]
							if (PageTemp2.find(u'{{genre') > PageTemp2.find(u'\n') or PageTemp2.find(u'{{genre') == -1) and (PageTemp2.find(u'{{m') > PageTemp2.find(u'\n') or PageTemp2.find(u'{{m') == -1) and (PageTemp2.find(u'{{f') > PageTemp2.find(u'\n') or PageTemp2.find(u'{{f') == -1) and (PageTemp2.find(u'{{n') > PageTemp2.find(u'\n') or PageTemp2.find(u'{{n') == -1):
								PageTemp = PageTemp[:PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'')+len(u'\n\'\'\'' + PageHS + u'\'\'\'')+PageTemp2.find(u'\n')] + u' {{genre|' + codelangue + u'}}' + PageTemp[PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'')+len(u'\n\'\'\'' + PageHS + u'\'\'\'')+PageTemp2.find(u'\n'):]⏎
							
					if Modele[p] == u'term' or Modele[p] == u'terme' or Modele[p] == u'term_lien' 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":
(contracted; show full)

	) or (PageTemp.find(u'Catégorie:Plantes imaginaires'
	) != -1 and (PageTemp.find(u':Catégorie:Plantes imaginaires') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Plantes imaginaires') + 1 != PageTemp.rfind(u'Catégorie:Plantes imaginaires'))


	) or (PageTemp.find(u'Catégorie:Créatures'
	) != -1 and (PageTemp.find(u':Catégorie:Créatures') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Créatures') + 1 != PageTemp.rfind(u'Catégorie:Créatures'))⏎
	⏎
	) or (PageTemp.find(u'Catégorie:Divinités'
	) != -1 and (PageTemp.find(u':Catégorie:Divinités') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Divinités') + 1 != PageTemp.rfind(u'Catégorie:Divinités'))):
									PageEnd = PageEnd + Modele[p] + u'|nocat=1|' + PageTemp[PageTemp.find(param):PageTemp.find(u'}}')+2]
(contracted; show full)								# Présence d'un {{{2}}}, à ne pas retirer
								PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]
								PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
								break
						if param != u'':
							if PageTemp.find(param) > position+1: # rel= est après le code langue
								if (EstCodeLangue == "false"

								⏎
	) or (PageTemp.find(u'Catégorie:Édifices religieux'
	) != -1 and (PageTemp.find(u':Catégorie:Édifices religieux') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Édifices religieux') + 1 != PageTemp.rfind(u'Catégorie:Édifices religieux'))⏎
	⏎
	) or (PageTemp.find(u'Catégorie:Divinités'
	) != -1 and (PageTemp.find(u':Catégorie:Divinités') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Divinités') + 1 != PageTemp.rfind(u'Catégorie:Divinités'))):
									PageEnd = PageEnd + Modele[p] + u'|nocat=1|' + PageTemp[PageTemp.find(param):PageTemp.find(u'}}')+2]
(contracted; show full)
	) and (PageTemp.find(u':Catégorie:Jeux') + 1 != PageTemp.rfind(u'Catégorie:Jeux'))):
							PageEnd = PageEnd + PageTemp[0:position] + "|nocat=1}}"
						else:
							PageEnd = PageEnd + PageTemp[0:position] + "|" + codelangue + "}}"
						PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
						break


					elif Modele[p] == u'architecture' or Modele[p] == u'archi' or Modele[p] == u'fortification':
						if (EstCodeLangue == "false"
	) or (PageTemp.find(u'Catégorie:Édifices'
	) != -1 and (PageTemp.find(u':Catégorie:Édifices') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Édifices') + 1 != PageTemp.rfind(u'Catégorie:Édifices'))):
							PageEnd = PageEnd + PageTemp[0:position] + "|nocat=1}}"
						else:
							PageEnd = PageEnd + PageTemp[0:position] + "|" + codelangue + "}}"
						PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
						break⏎
						⏎
					elif Modele[p] == u'réseaux' or Modele[p] == u'réseaux informatiques':
						if (EstCodeLangue == "false"
	) or (PageTemp.find(u'Catégorie:Protocoles réseau'
	) != -1 and (PageTemp.find(u':Catégorie:Protocoles réseau') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
(contracted; show full)
		) and (PageTemp.find(u':Catégorie:Océans') + 1 != PageTemp.rfind(u'Catégorie:Océans'))

		) or (PageTemp.find(u'Catégorie:Rivières'
		) != -1 and (PageTemp.find(u':Catégorie:Rivières') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
		) and (PageTemp.find(u':Catégorie:Rivières') + 1 != PageTemp.rfind(u'Catégorie:Rivières'))


		) or (PageTemp.find(u'Catégorie:Cours d’eau'
		) != -1 and (PageTemp.find(u':Catégorie:Cours d’eau') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
		) and (PageTemp.find(u':Catégorie:Cours d’eau') + 1 != PageTemp.rfind(u'Catégorie:Cours d’eau'))⏎
⏎
	) or (PageTemp.find(u'Catégorie:Îles'
	) != -1 and (PageTemp.find(u':Catégorie:Îles') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Îles') + 1 != PageTemp.rfind(u'Catégorie:Îles'))

	) or (PageTemp.find(u'Catégorie:Localités'
(contracted; show full)
						if (EstCodeLangue == "false"
	) or (PageTemp.find(u'Catégorie:Éléments chimique'
	) != -1 and (PageTemp.find(u'Catégorie:Éléments chimique') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Éléments chimique') + 1 != PageTemp.rfind(u'Catégorie:Éléments chimique'))


	) or (PageTemp.find(u'Catégorie:Symboles des éléments chimiques'
	) != -1 and (PageTemp.find(u'Catégorie:Symboles des éléments chimiques') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Symboles des éléments chimiques') + 1 != PageTemp.rfind(u'Catégorie:Symboles des éléments chimiques'))⏎
	⏎
	) or (PageTemp.find(u'Catégorie:Métaux'
	) != -1 and (PageTemp.find(u'Catégorie:Métaux') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Métaux') + 1 != PageTemp.rfind(u'Catégorie:Métaux'))

	) or (PageTemp.find(u'Catégorie:Alliages'
(contracted; show full)							PageEnd = PageEnd + PageTemp[0:position] + "|nocat=1}}"
						else:
							PageEnd = PageEnd + PageTemp[0:position] + "|" + codelangue + "}}"
						PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
						break
					elif Modele[p] == u'-trad-':
						EstCodeLangue = u'false'

						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
						trad = u'true'
						PageEnd = PageEnd + Modele[p] + u'}}'
						PageTemp = PageTemp[PageTemp.find(u'}}')+2:len(PageTemp)]
						# Ajout de {{trad-début}} si {{T| en français
						if PageTemp.find(u'{{') == PageTemp.find(u'{{T|') and codelangue == 'fr':
							PageTemp = u'\n{{trad-début}}' + PageTemp
							PageTemp2 = PageTemp[PageTemp.find(u'{{trad-début}}\n')+len(u'{{trad-début}}\n'):]
(contracted; show full)							PageEnd = PageEnd + u'trad-fin'
						else:
							PageEnd = PageEnd + u')'
						PageTemp = PageTemp[position:len(PageTemp)]
						break
					if p < limit1:	# Si on est dans le paragraphe définition
						EstCodeLangue = "true"

						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
						# Tous ces modèles peuvent facultativement contenir |clé= et |num=, les prénoms et -flex-prénom- |genre=
						if position == PageTemp.find(u'}'): PageTemp = PageTemp[0:position] + u'|' + codelangue + PageTemp[position:len(PageTemp)]
						PageTemp2 = PageTemp[position+1:len(PageTemp)]
						position2 = 0

						while PageTemp2.find(u'|') != -1 and PageTemp2.find(u'|') < PageTemp2.find(u'}}'):
(contracted; show full)								PageTemp = PageTemp[0:PageTemp.find(u'}}')] + u'|clé=' + TitreTemp + PageTemp[PageTemp.find(u'}}'):len(PageTemp)]
							
						PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]

					elif p < limit2:	# Paragraphe sans code langue
						if debogage == True: print "limit2"
						EstCodeLangue = "false"

						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
						trad = u'false'
						PageEnd = PageEnd + PageTemp[0:position] + "}}"
					elif p < limit25:	# Paragraphe sans code langue contenant un texte
						if debogage == True: print "limit25"
						EstCodeLangue = "false"
						if debogage == True: print " EstCodeLangue = " + EstCodeLangue⏎
						#trad = u'false'
						if PageTemp.find(u'}}') > PageTemp.find(u'{{') and PageTemp.find(u'{{') != -1:
							PageTemp2 = PageTemp[PageTemp.find(u'}}')+2:len(PageTemp)]
							PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2+PageTemp2.find(u'}}')+2]
							PageTemp = PageTemp[PageTemp.find(u'}}')+2+PageTemp2.find(u'}}')+2:len(PageTemp)]
							break
						else:
(contracted; show full)			print "BadTitle en sauvegarde"
			return
		except AttributeError:
			print "AttributeError en sauvegarde"
			return
			
# Lancement

#TraitementCategorie = crawlerCat(u'Catégorie:Noms communs en italien',False,u'affondamento')
#TraitementCategorie = crawlerCat(u'Catégorie:Noms communs en portugais',False,u'aglomeração')
#TraitementCategorie = crawlerCat(u'Catégorie:Noms communs en allemand',False,u'Auswahl')
#TraitementCategorie = crawlerCat(u'Catégorie:Noms communs en français',False,u'')⏎
⏎
# Quotidiennement :
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Codes langue manquants',True,u'')
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Flexions à vérifier',True,u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects:fr-verbe-flexion incomplet',False,u'')
TraitementLiens = crawlerLink(u'Modèle:trad',u'')
(contracted; show full)
TraitementLiens = crawlerLink(u'Modèle:pluri',u'')
TraitementLiens = crawlerLink(u'Modèle:=langue=',u'')
'''
TraitementLiens = crawlerLink(u'Modèle:trad-',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Conjugaisons manquantes en français',True,u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects:pron conv',True,u'')
⏎
TraitementCategorie = crawlerCat(u'Lexique en français de la mythologie',False,u'')
TraitementCategorie = crawlerCat(u'Lexique en français de la religion',False,u'')

# Modèles
TraitementPage = modification(u'Utilisateur:JackBot/test')
TraitementFile = crawlerFile('articles_WTin.txt')
TraitementLiens = crawlerLink(u'Modèle:terme',u'')
TraitementLiens = crawlerLink(u'Modèle:R:DAF8',u'')
TraitementLiens = crawlerLink(u'Modèle:Import:DAF8',u'')
TraitementLiensCategorie = crawlerCatLink(u'Modèles de code langue',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects',True,u'')
TraitementRecherche = crawlerSearch(u'clé de tri')
TraitementUtilisateur = crawlerUser(u'Utilisateur:JackBot')
TraitementRedirections = crawlerRedirects()
TraitementTout = crawlerAll(u'')
while 1:
	TraitementRC = crawlerRC()
# python delete.py -lang:fr -family:wiktionary -file:articles_WTin.txt⏎
'''
</source>