Difference between revisions 14672679 and 14708474 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.
(contracted; show full)Modele[810] = u'planche à neige'
Modele[811] = u'planche à roulettes'
Modele[812] = u'volcanologie'
Modele[813] = u'infographie'
Modele[814] = u'football américain'
Modele[815] = u'football canadien'
Modele[816] = u'geog'	# à remplacer ?

⏎
limit4 = 817	# ébauches
Modele[817] = u'Modele[817] = u'scolaire'

limit4 = 818	# ébauche-syn's
Modele[818] = u'ébauche-étym-nom-scientifique'
Modele[819] = u'ébauche-trans'
Modele[820] = u'ébauche-déf'
Modele[821] = u'ébauche-étym'
Modele[822] = u'ébauche-pron'
Modele[823] = u'ébauche'
Modele[824] = u'ébauche-exe'
Modele[825] = u'ébauche-pron'
Modele[826] = u'ébauche-syn'⏎
'''
# 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 = 8267
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)
		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'|notat=1') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'|notat=1')] + u'|nocat=1' + PageTemp[PageTemp.find(u'|notat=1')+len(u'|notat=1'):len(PageTemp)]⏎
		
		LimiteReg = 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'
(contracted; show full)			#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) < 7: # sinon trop long ( > 1 h par page)
				#print socket.gethostname()
				anagrammes = anagram(PageHS)
(contracted; show full)
				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:
					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'
					else:
						PageTemp2 = PageTemp[PageTemp.find(u'}}')+2:len(PageTemp)]
						codelangueif 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|'):PageTemp.find(u'}}')+2+]
						codelangue = PageTemp2[:PageTemp2.find(u'}}')]
						EstCodeLangue = u'true'
				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'
					position = PageTemp.find("{{")
				if debogage == True: print u'Nouveau code langue trouvé : ' + codelangue⏎
			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'
					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)]
			
			# Modèles imbriqués (à sauter)
			while PageTemp.find(u'{{') < PageTemp.find(u'}}') and PageTemp.find(u'{{') != -1 and PageTemp.find(u'}}') != -1:
				if debogage == True: print u'Modèle inclu dans ' + PageTemp[0:PageTemp.find("}}")]
				PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]
				PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
				
			# ParamètresFin du nom du modèle
			if PageTemp.find("|") > PageTemp.find("}}"):
				position = PageTemp.find("}}")
			elif PageTemp.find("|") == -1:
				position = PageTemp.find("}}")
			else:
				position = PageTemp.find("|")
							
(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], pour identifier le traitement à effectuer
			for p in range(1,limit6):
				if Modele[p] == PageTemp[0:position]:
					if debogage == True: print (Modele[p].encode(config.console_encoding, 'replace'))

					⏎
					# Modèles imbriqués (à sauter)
					while PageTemp.find(u'{{') < PageTemp.find(u'}}') and PageTemp.find(u'{{') != -1 and PageTemp.find(u'}}') != -1:
						if debogage == True:
							print u'Modèle inclu dans '
							print PageTemp[:PageTemp.find(u'}}')].encode(config.console_encoding, 'replace')
						PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]
						PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
						# Fin du nom du modèle
						if PageTemp.find("|") > PageTemp.find("}}"):
							position = PageTemp.find("}}")
						elif PageTemp.find("|") == -1:
							position = PageTemp.find("}}")
						else:
							position = PageTemp.find("|")
						if position == -1:
							if debogage == True: print u'Erreur ligne 2271 : modèle brisé'
							return⏎
						⏎
					# 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'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)								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':

						#raw_input(PageTemp.encode(config.console_encoding, 'replace'))⏎
						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("}}"):
(contracted; show full)						PageTemp = PageTemp[PageTemp.find("}}")+2:len(PageTemp)]
						break
					elif Modele[p] == u'-trad-':
						EstCodeLangue = u'false'
						trad = u'true'
						PageEnd = PageEnd + Modele[p] + u'}}'
						PageTemp = PageTemp[PageTemp.find(u'}}')+2:len(PageTemp)]

						# Ajout de {{trad-début}}
						if PageTemp.find(u'{{') == PageTemp.find(u'{{T|'):
							PageTemp = u'\n{{trad-début}}' + PageTemp
							PageTemp2 =  PageTemp[PageTemp.find(u'{{trad-début}}\n')+len(u'{{trad-début}}\n'):]
							while PageTemp2.find(u'{{T|') < PageTemp2.find(u'\n') and PageTemp2.find(u'{{T|') != -1:
								PageTemp2 = PageTemp2[PageTemp2.find(u'\n')+1:]
							PageTemp = PageTemp[:len(PageTemp)-len(PageTemp2)] + u'{{trad-fin}}\n' + PageTemp[len(PageTemp)-len(PageTemp2):]⏎
						break
					elif Modele[p] == u'trad' or Modele[p] == u'trad+' or Modele[p] == u'trad-' or Modele[p] == u'trad--':
						# Lettres spéciales à remplacer dans les traductions vers certaines langues
						if debogage == True: print u'Test des traductions'
						PageTemp2 = PageTemp[position+1:len(PageTemp)]
						if PageTemp2[0:PageTemp2.find(u'|')] == u'ro' or PageTemp2[0:PageTemp2.find(u'|')] == u'mo':
(contracted; show full)							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

						if debogage == True: print "limit2"⏎
						EstCodeLangue = "false"
						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"
						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:
							PageEnd = PageEnd + PageTemp[0:PageTemp.find(u'}}')+2]
					elif p < limit3:
						if debogage == True: print "limit3"⏎
						if debogage == True: print u'Modèle sans paramètre'
						PageEnd = PageEnd + PageTemp[0:position] + "}}"
					elif p < limit4:
						if debogage == True: print "limit4"⏎
						if debogage == True: print u'Paragraphe potentiellement avec code langue'
						if EstCodeLangue == "true":
							if debogage == True: print u'avec'
							PageEnd = PageEnd + PageTemp[0:position] + "|" + codelangue + "}}"
						else:
							if debogage == True: print u'sans'
							PageEnd = PageEnd + PageTemp[0:position] + "|nocat=1}}"		
					elif p < limit5:
						if debogage == True: print "limit5"⏎
						if debogage == True: print u'ébauche : catégorisée quel que soit EstCodeLangue'
						if codelangue:
							PageEnd = PageEnd + PageTemp[0:position] + "|" + codelangue + "}}"
						else:
							PageEnd = PageEnd + PageTemp[0:position] + "|nocat=1}}"		
					else:
						if debogage == True: print u'Paragraphe régional : non catégorisé dans la prononciation'
						if PageEnd.rfind(u'{{') != -1:
							PageEnd2 = PageEnd[0:PageEnd.rfind(u'{{')]
							if EstCodeLangue == "true" and (PageEnd2.rfind(u'{{') != PageEnd2.rfind(u'{{pron|') or PageEnd.rfind(u'{{pron|') < PageEnd.rfind(u'\n') or PageEnd2.rfind(u'{{pron|') == -1) and ((PageTemp.find(u'{{') != PageTemp.find(u'{{pron|') or PageTemp.find(u'{{pron|') > PageTemp.find(u'\n')) or PageTemp.find(u'{{pron|') == -1):
								PageEnd = PageEnd + PageTemp[0:position] + "|" + codelangue + "}}"
							else:
								PageEnd = PageEnd + PageTemp[0:position] + "|nocat=1}}"
					if position == PageTemp.find("|"):
						position = PageTemp.find("}}")
					PageTemp = PageTemp[position+2:len(PageTemp)]
					⏎
					⏎
					⏎
					⏎
				elif (PageTemp[0:position] == u'-flex-verb-' or PageTemp[0:position] == u'-flex-verbe-') and codelangue == u'fr':
					if debogage == True: print u'Flexion de verbe'
					if PageTemp.find(u'fr-verbe-flexion') != -1:
						Infinitif = PageTemp[PageTemp.find(u'[[')+2:PageTemp.find(u']]')]
						if Infinitif == u'verbe':
(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"
	
#if debogage == True:⏎
		print(Contenu[:len(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: 
			print "NoPage en sauvegarde"
(contracted; show full)
TraitementLiens = crawlerLink(u'Modèle:femin',u'')
TraitementLiens = crawlerLink(u'Modèle:sing',u'')
TraitementLiens = crawlerLink(u'Modèle:plur',u'')
TraitementLiens = crawlerLink(u'Modèle:pluri',u'')
TraitementLiens = crawlerLink(u'Modèle:=langue=',u'')
TraitementLiens = crawlerLink(u'Modèle:trad-',u'')
'''

⏎
⏎
# Modèles
TraitementFile = crawlerFile('articles_list.txt')
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>