Difference between revisions 14576425 and 14672679 on frwiktionary

[[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 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
9) Teste les URL et indique si elles sont brisées
10) Remplace les modèles 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

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, hyperlynx
from wikipedia import *

# Déclaration
language = "fr"
family = "wiktionary"
mynick = "JackBot"
site = getSite(language,family)
debogage = TruFalse

# Modèles du site à traiter
limit6=95360
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[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-'⏎
⏎
limit2 = 1668 # Paragraphes sans modèle catégorisant, {{voir| et {{voir/ sont gérés individuellement
Modele[166] = u'formater'
Modele[167] = u'suppression'⏎
Modele[168] = u'supp'
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'
limit25 = 188⏎
Modele[188] = u'cformater'
Modele[189] = u'mf'suppression'
limit25 = 190
Modele[190] = u'mf?'
Modele[191] = u'fm ?'
Modele[192] = u'plus courant'
Modele[193] = u'moins courant'
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'⏎
limit3 = 2035 # 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[203] = u'hispanisme'
Modele[204] = u'humour'⏎
Modele[205] = u'hyperbole'
Modele[206] = u'idiotisme'
Modele[207] = u'indéfini'
Modele[208] = u'joaillerie'
Modele[209] = u'informel'
Modele[210] = u'injurieux'
Modele[211] = u'interjection'
Modele[212] = u'ironique'
(contracted; show full)Modele[583] = u'exag'
Modele[584] = u'métaph'
Modele[585] = u'cour'
Modele[586] = u'sout'
Modele[587] = u'prov'
Modele[588] = u'phon'
Modele[589] = u'pron'
Modele[590] = u'
termpron-rég'
Modele[591] = u'terme'
Modele[592] = u'zoolterme'
Modele[593] = u'poét'
Modele[594] = u'antiq'
Modele[595] = u'litt'
Modele[596] = u'mythol'
Modele[597] = u'opti'
Modele[598] = u'geogzool'
Modele[599] = u'hyperb'
Modele[600] = u'gastron'
Modele[601] = u'didactique'
Modele[602] = u'auxiliaire'
Modele[603] = u'td'
Modele[604] = u'tr-dir'
Modele[605] = u'tr-indir'
(contracted; show full)Modele[797] = u'figuré'
Modele[798] = u'formel'
Modele[799] = u'gallicisme'
Modele[800] = u'abréviation'
Modele[801] = u'par ellipse'
Modele[802] = u'mélio'
Modele[803] = u'hapax'
Modele[804] = u'
infographieaccord genre ?'
Modele[805] = u'accord genre ?dépendant'
Modele[806] = u'dépendanthumour'
Modele[807] = u'argot scolaire'
Modele[808] = u'argot policier'
⏎
limit4 = 809	# ébauchesModele[809] = u'hispanisme'
Modele[810] = u'ébauche-transplanche à neige'
Modele[811] = u'ébauche-défplanche à roulettes'
Modele[812] = u'ébauche-étymvolcanologie'
Modele[813] = u'ébauche-proninfographie'
Modele[814] = u'ébauchefootball américain'
Modele[815] = u'ébauche-exefootball canadien'
Modele[816] = u'geog'	# à remplacer ?

limit4 = 817	# ébauche-pron's
Modele[817] = u'ébauche-syn'
Modele[818] = u'ébauche-étym-nom-scientifique'
'''
# non traitésModele[819] = u'ébauche-trans'
Modele[820] = u'spécialement' ébauche-déf'
Modele[821] = u'Tébauche-étym'
Modele[822] = u'régiébauche-pron'
Modele[823] = u'régioébauche'
Modele[824] = u'régional'
'''
# ébauche-exe'⏎
Modèeles régionaux, pb du nocat pour les prononciations
limit5 = 819[825] = u'ébauche-pron'
'''
# non traités
Modele[820] = u'Congo-Kinshasa'spécialement' 
Modele[821] = u'CorseT'
Modele[822] = u'Corée du Nordrégion'
Modele[823] = u'Corée du Sudrégio'
Modele[824] = u'Costa Rica'⏎
régional'
'''
# Modeèle[825] = u'Côte d’Ivoire'
Modele[826] = u'Cuba's régionaux, pb du nocat pour les prononciations
limit5 = 826
Modele[827] = u'Écosse'
Modele[828] = u'Espagne'
Modele[829] = u'États-Unis'
Modele[830] = u'Europe'
Modele[831] = u'France'
Modele[832] = u'Franche-Comté'
Modele[833] = u'Gascogne'
(contracted; show full)Modele[944] = u'Catalogne'
Modele[945] = u'Champagne'
Modele[946] = u'Chili'
Modele[947] = u'Chine'
Modele[948] = u'Colombie'
Modele[949] = u'Commonwealth'
Modele[950] = u'Congo'
Modele[951] = u'Congo-Brazzaville'
⏎
Modele[952] = u'Congo-Kinshasa'
Modele[953] = u'Corse'
Modele[954] = u'Corée du Nord'
Modele[955] = u'Corée du Sud'
Modele[956] = u'Costa Rica'
Modele[957] = u'Côte d’Ivoire'
Modele[958] = u'Cuba'

# Modèles de pronociation à synchroniser
Modele[9529] = 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)
			if PagesCleTotal.find(u'-' + PageHS[0:1].lower() + PageHS[1:len(PageHS)]) == -1: PagesCleTotal = PagesCleTotal + u'|-' + PageHS[0:1].lower() + PageHS[1:len(PageHS)]
			if PagesCleTotal.find(PageHS[0:1].lower() + PageHS[1:len(PageHS)] + u'-') == -1: PagesCleTotal = PagesCleTotal + u'|' + PageHS[0:1].lower() + PageHS[1:len(PageHS)] + u'-'

			if PagesCleTotal.find(u'-') != -1: PagesCleTotal = PagesCleTotal + u'|' + PagesCleTotal.replace(u'-',u'')⏎
			if PageHS.find(u'e') != -1: PagesCleTotal = PagesCleTotal + u'|' + PageHS[0:PageHS.find(u'e')] + u'é' + PageHS[PageHS.find(u'e')+1:len(PageHS)] + u'|' + PageHS[0:PageHS.find(u'e')] + u'è' + PageHS[PageHS.find(u'e')+1:len(PageHS)]
			if PageHS.find(u'é') != -1: PagesCleTotal = PagesCleTotal + u'|' + PageHS[0:PageHS.find(u'é')] + u'e' + PageHS[PageHS.find(u'é')+1:len(PageHS)]
			if PageHS.find(u'è') != -1: PagesCleTotal = PagesCleTotal + u'|' + PageHS[0:PageHS.find(u'è')] + u'e' + PageHS[PageHS.find(u'è')+1:len(PageHS)]
			if PagesCleTotal.find(CleDeTri(PageHS)) == -1 and PageTemp.find(u'{{langue|eo}}') == -1: PagesCleTotal = PagesCleTotal + u'|' + CleDeTri(PageHS)	# exception ? and PageTemp.find(u'{{langue|eo}}') == -1
			# Filtre des pages de la liste "à voir"
			PagesCleRestant = PagesCleTotal + u'|'
			PagesCleTotal = u''
			PagesVoir = u''
			while PagesCleRestant != u'':
				HS = u'False'
				PageCourante = PagesCleRestant[0:PagesCleRestant.find(u'|')]
(contracted; show full)
		while PageTemp.find(u'\n{{trad-milieu}}') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'\n{{trad-milieu}}')] + PageTemp[PageTemp.find(u'\n{{trad-milieu}}')+len(u'\n{{trad-milieu}}'):len(PageTemp)]
		while PageTemp.find(u'-ortho-alt-') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'-ortho-alt-')] + u'-var-ortho-' + PageTemp[PageTemp.find(u'-ortho-alt-')+len(u'-ortho-alt-'):len(PageTemp)]
		
		
⏎
		while PageTemp.find(u'\n={{-nom-|ja}}=') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'\n={{-nom-|ja}}=')] + u'\n;\'\'Nom\'\'' + PageTemp[PageTemp.find(u'\n={{-nom-|ja}}=')+len(u'\n={{-nom-|ja}}='):len(PageTemp)]
		while PageTemp.find(u'\n={{caractère}}=') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'\n={{caractère}}=')] + u'\n;\'\'Caractère\'\'' + PageTemp[PageTemp.find(u'\n={{caractère}}=')+len(u'\n={{caractère}}='):len(PageTemp)]
		while PageTemp.find(u'Carractère') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'Carractère')] + u'Caractère' + PageTemp[PageTemp.find(u'Carractère')+len(u'Carractère'):len(PageTemp)]

		ModRegion = range(1, 8)
		ModRegion[1] = u'AU'
		ModRegion[2] = u'BE'
		ModRegion[3] = u'CA'
		ModRegion[4] = u'QC'
		ModRegion[5] = u'UK'
		ModRegion[6] = u'US'
		for m in range(1, 7LimiteReg = 13
		ModRegion = range(1, LimiteReg)
		ModRegion[1] = u'AU'
		ModRegion[2] = u'AR'
		ModRegion[3] = u'AT'
		ModRegion[4] = u'BE'
		ModRegion[5] = u'BR'
		ModRegion[6] = u'CA'
		ModRegion[7] = u'MX'
		ModRegion[8] = u'PT'
		ModRegion[9] = u'QC'
		ModRegion[10] = u'UK'
		ModRegion[11] = u'US'
		for m in range(1, LimiteReg-1):
			while PageTemp.find(u'{{pron-rég|' + ModRegion[m] + u'|') != -1:
				PageTemp = PageTemp[:PageTemp.find(u'{{pron-rég|' + ModRegion[m] + u'|')+len('{{pron-rég|')-1] + u'{{' + ModRegion[m] + u'|nocat=1}}' + PageTemp[PageTemp.find(u'{{pron-rég|' + ModRegion[m] + u'|')+len(u'{{pron-rég|' + ModRegion[m]):]

		while PageTemp.find(u'\n{{colonnes|') != -1:
(contracted; show full)								return
							except wikipedia.IsRedirectPage:
								print u'Redirection l 1886 : ' + 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
								#printif debogage == True: 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')]
									summary = summary + ', traduction ' + langue2 + u' > ' + langue⏎
								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')]
							#print PageEnd[PageEnd.rfind(u'\n'):len(PageEnd)].encode(config.console_encoding, 'replace')
					PageEnd = PageEnd + TradCourante + TradSuivantes
			PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'\n')+1]
(contracted; show full)
			for p in range(1,limit6):
				if Modele[p] == PageTemp[0:position]:
					if debogage == True: print (Modele[p].encode(config.console_encoding, 'replace'))
					# 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':
						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'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):
(contracted; show full)								PageEnd = PageEnd + PageTemp[0:PageTemp.find("}}")] + "|" + codelangue + "}}"
								PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
								break
						else:
							PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]
							PageTemp = PageTemp[PageTemp.find(u'}}')+2:len(PageTemp)]
							break

					⏎
					elif Modele[p] == u'pron-rég':
						PageTemp2 = PageTemp[position+1:len(PageTemp)]
						# Saut des modèles régionnaux
						if PageTemp2.find("lang=") == -1 or PageTemp2.find("lang=") > PageTemp2.find("}}"):
							while PageTemp2.find(u'{{') < PageTemp2.find(u'}}') and PageTemp2.find(u'{{') != -1:
								PageTemp2 = PageTemp2[PageTemp2.find(u'}}')+2:]
							if PageTemp2.find("lang=") == -1 or PageTemp2.find("lang=") > PageTemp2.find("}}"):
								PageEnd = PageEnd + PageTemp[:position] + u'|lang=' + codelangue + PageTemp[position:PageTemp.find("}}")+2]
								PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
								break
						PageEnd = PageEnd + PageTemp[:PageTemp.find("}}")+2]
						PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
						break⏎
								⏎
					#elif Modele[p] == u'fr-rég' or Modele[p] == u'fr-inv': synchro de la pronociation avec {{pron|
					
					if Modele[p] == u'en-conj-rég':
						PageTemp2 = PageTemp[position+1:len(PageTemp)]
						if PageTemp2.find(u'|') < PageTemp2.find(u'}}') and PageTemp2.find(u'|') != -1:
							if PageTemp2[0:PageTemp2.find(u'|')] == PageHS:
(contracted; show full)
	) and (PageTemp.find(u':Catégorie:Sports') + 1 != PageTemp.rfind(u'Catégorie:Sports'))):
							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'danse':
						if (EstCodeLangue == "false"
	) or (PageTemp.find(u'Catégorie:Danses'
	) != -1 and (PageTemp.find(u':Catégorie:Danses') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Danses') + 1 != PageTemp.rfind(u'Catégorie:Danses'))):
							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'jeux':
						if (EstCodeLangue == "false"
	) or (PageTemp.find(u'Catégorie:Jeux'
	) != -1 and (PageTemp.find(u':Catégorie:Jeux') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) 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'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
	) and (PageTemp.find(u':Catégorie:Protocoles réseau') + 1 != PageTemp.rfind(u'Catégorie:Protocoles réseau'))):
							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'géographie' or Modele[p] == u'géog' or Modele[p] == u'geog' or Modele[p] == u'toponymie' or Modele[p] == u'topon':
						if (EstCodeLangue == "false"
	) or (PageTemp.find(u'Catégorie:Gentilés'
	) != -1 and (PageTemp.find(u':Catégorie:Gentilés') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
(contracted; show full)
							PageTemp = PageTemp[0:position+1+position2] + codelangue + PageTemp[position+1+position2+len(PageTemp2[0:PageTemp2.find(u'}}')]):]
						
						# Clé de tri propre à une langue
						if PageTemp.find(u'|clé=') == -1 or PageTemp.find(u'|clé=') > PageTemp.find(u'}}'):
							TitreTemp = PageHS
							if codelangue == u'
ru':
								if TitreTemp.find(u'ё') !=-1: TitreTemp = TitreTemp.replace(u'ё',u'е€')
								if TitreTemp.find(u'ӕ') !=-1: TitreTemp = TitreTemp.replace(u'ӕ',u'а€')
							elif codelangue == u'os':
								if TitreTemp.find(u'ё') !=-1: TitreTemp = TitreTemp.replace(u'ё',u'е€')
								if TitreTemp.find(u'ӕ') !=-1: TitreTemp = TitreTemp.replace(u'ӕ'es':
								if TitreTemp.find(u'ñ') !=-1: TitreTemp = TitreTemp.replace(u'ñ',u'n€')
								if TitreTemp.find(u'ñ'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ñ'.upper(),u'n€')
							elif codelangue == u'os':
								if TitreTemp.find(u'ё') !=-1: TitreTemp = TitreTemp.replace(u'ё',u'е€')
								if TitreTemp.find(u'ё'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ё'.upper(),u'е€')
								if TitreTemp.find(u'ӕ') !=-1: TitreTemp = TitreTemp.replace(u'ӕ',u'а€')
								if TitreTemp.find(u'ӕ'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ӕ'.upper(),u'а€')
								# Digrammes
								if TitreTemp.find(u'гъ') !=-1: TitreTemp = TitreTemp.replace(u'гъ',u'г€')
								if TitreTemp.find(u'дж') !=-1: TitreTemp = TitreTemp.replace(u'дж',u'д€')
								if TitreTemp.find(u'дз') !=-1: TitreTemp = TitreTemp.replace(u'дз',u'д€€')
								if TitreTemp.find(u'къ') !=-1: TitreTemp = TitreTemp.replace(u'къ',u'к€')
								if TitreTemp.find(u'пъ') !=-1: TitreTemp = TitreTemp.replace(u'пъ',u'п€')
								if TitreTemp.find(u'тъ') !=-1: TitreTemp = TitreTemp.replace(u'тъ',u'т€')
								if TitreTemp.find(u'хъ') !=-1: TitreTemp = TitreTemp.replace(u'хъ',u'х€')
								if TitreTemp.find(u'цъ') !=-1: TitreTemp = TitreTemp.replace(u'цъ',u'ц€')
								if TitreTemp.find(u'чъ') !=-1: TitreTemp = TitreTemp.replace(u'чъ',u'ч€')
							elif codelangue == u'es':
								if TitreTemp.find(u'ñ') !=-1: TitreTemp = TitreTemp.replace(u'ñ',u'n€')ru':
								if TitreTemp.find(u'ё') !=-1: TitreTemp = TitreTemp.replace(u'ё',u'е€')
								if TitreTemp.find(u'ё'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ё'.upper(),u'е€')
								if TitreTemp.find(u'ӕ') !=-1: TitreTemp = TitreTemp.replace(u'ӕ',u'а€')
								if TitreTemp.find(u'ӕ'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ӕ'.upper(),u'а€')
							if codelangue == u'sl':
								if TitreTemp.find(u'č') !=-1: TitreTemp = TitreTemp.replace(u'č',u'c€')
								if TitreTemp.find(u'č'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'č'.upper(),u'c€')
								if TitreTemp.find(u'š') !=-1: TitreTemp = TitreTemp.replace(u'š',u's€')
								if TitreTemp.find(u'š'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'š'.upper(),u's€')
								if TitreTemp.find(u'ž') !=-1: TitreTemp = TitreTemp.replace(u'ž',u'z€')
								if TitreTemp.find(u'ž'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ž'.upper(),u'z€')
							elif codelangue == u'sv':
								if TitreTemp.find(u'å') !=-1: TitreTemp = TitreTemp.replace(u'å',u'z€')	
								if TitreTemp.find(u'å'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'å'.upper(),u'z€')
								if TitreTemp.find(u'ä') !=-1: TitreTemp = TitreTemp.replace(u'ä',u'z€€')	
								if TitreTemp.find(u'ä'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ä'.upper(),u'z€€')	
								if TitreTemp.find(u'ö') !=-1: TitreTemp = TitreTemp.replace(u'ö',u'z€€€')	
								if TitreTemp.find(u'ö'.upper()) !=-1: TitreTemp = TitreTemp.replace(u'ö'.upper(),u'z€€€')	
							if TitreTemp != PageHS:
								TitreTemp = CleDeTri(TitreTemp)
								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
(contracted; show full)			txtfile = codecs.open(u'articles_listed.txt', 'a', 'utf-8')
			txtfile.write(u'* [[' + PageHS + u']]\n')
			txtfile.close()'''
	else:
		PageEnd = PageTemp
	if debogage == True: print u'Test des URL'
	PageEnd = hyperlynx.hyperlynx(PageEnd)
	if debogage == True: 
raw_inpuprint (u'--------------------------------------------------------------------------------------------')
	if PageEnd != PageBegin:
		sauvegarde(page,PageEnd, summary)
	elif debogage == True:
		print "Aucun changement"
		

def CleDeTri(PageTitre):
(contracted; show full)
			PageT = PageT + PageTitre[lettre:lettre+1].lower()
		else:
			PageT = PageT + PageTitre[lettre:lettre+1]
		#print (PageT.encode(config.console_encoding, 'replace'))
		#raw_input("lettre")
	if key == "yes":
		while PageT[0:1] == u' ': PageT = PageT[1:len(PageT)]
		return 
trim(PageT)
	else:
		#raw_input(PageTitre.encode(config.console_encoding, 'replace'))
		return PageTitre

def trim(s):
    return s.strip(" \t\n\r\0\x0B")

(contracted; show full)			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):
	result = "ok"
	#print(Contenu
[:2000].encode(config.console_encoding, 'replace'))	#[len(Contenu)-2000:len(Contenu)]) #
	#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: 
(contracted; show full)
TraitementPage = modification(u'Utilisateur:JackBot/test')
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)

⏎
⏎
TraitementRecherche = crawlerSearch(u'clé de tri')
TraitementUtilisateur = crawlerUser(u'Utilisateur:JackBot')
TraitementRedirections = crawlerRedirects()
TraitementTout = crawlerAll(u'')
while 1:
	TraitementRC = crawlerRC()
'''
</source>