Difference between revisions 18754739 and 18852698 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 labs Wikimedia :
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) Gère des modèles {{voir}} en début de page.
7) Ajoute les anagrammes (pour les petits mots)
8) 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
9) Remplace les modèles catégorisés comme obsolètes
10) Créer dGère les liens absentinternes cassés : http://fr.wiktionary.org/w/index.php?title=radiateur&diff=prev&oldid=14443668
11) Détecte les modèles à ajouter : http://fr.wiktionary.org/w/index.php?title=cl%C3%A9&diff=prev&oldid=14443625
12) 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
(contracted; show full)Section.append(u'méronymes')
Modele.append(u'-noms-vern-')
Section.append(u'noms vernaculaires')
Modele.append(u'-ortho-arch-')
Section.append(u'anciennes orthographes')
Modele.append(u'-paro-')
Section.append(u'paronymes')

Modele.append(u'-phrases-')
Section.append(u'phrases')⏎
Modele.append(u'-q-syn-')
Section.append(u'quasi-synonymes')
Modele.append(u'-syn-')
Section.append(u'synonymes')
Modele.append(u'-tran-')
Section.append(u'transcriptions')
Modele.append(u'-trans-')
Section.append(u'transcriptions')
(contracted; show full)Modele.append(u'admin')
Modele.append(u'administration')
Modele.append(u'affectueux')
Modele.append(u'agri')
Modele.append(u'agriculture')
Modele.append(u'algèbre')
Modele.append(u'algèbre‎')
Modele.append(u'al
latifgues‎')
Modele.append(u'allatif')
Modele.append(u'alpi')
Modele.append(u'alpinisme')
Modele.append(u'anal')
Modele.append(u'analogie')
Modele.append(u'anat')
Modele.append(u'anatomie')
Modele.append(u'angl')
Modele.append(u'anglicisme')
Modele.append(u'animaux')
Modele.append(u'anthro')
Modele.append(u'anthropologie')
Modele.append(u'antilopes')⏎
Modele.append(u'antiq')
Modele.append(u'antiquité')
Modele.append(u'aphérèse')
Modele.append(u'apiculture')
Modele.append(u'apiculture')
Modele.append(u'apocope')
Modele.append(u'arch')
Modele.append(u'archaïque')
(contracted; show full)Modele.append(u'canoë')
Modele.append(u'canoë-kayak')
Modele.append(u'capoeira')
Modele.append(u'capoeira')
Modele.append(u'cardin')
Modele.append(u'cardinal')
Modele.append(u'cartes')

Modele.append(u'catch')⏎
Modele.append(u'caténatif')
Modele.append(u'champignons')
Modele.append(u'charpenterie')
Modele.append(u'chasse')
Modele.append(u'chiens')
Modele.append(u'chim')
Modele.append(u'chimie')
Modele.append(u'chimie organique')
Modele.append(u'chimie physique')
Modele.append(u'chir')
Modele.append(u'chiromancie')
Modele.append(u'chirurgie')
Modele.append(u'christianisme')
Modele.append(u'ciné')
Modele.append(u'cinéma')
Modele.append(u'coiffure')
Modele.append(u'combat')
Modele.append(u'comm')
Modele.append(u'commerce')
Modele.append(u'commerces')⏎
Modele.append(u'comparatif de')
Modele.append(u'composants')
Modele.append(u'confiserie')
Modele.append(u'confiseries')
Modele.append(u'conjugaison')
Modele.append(u'constr')
Modele.append(u'construction')
Modele.append(u'contemporain')
(contracted; show full)Modele.append(u'informatique')
Modele.append(u'informel')
Modele.append(u'injur')
Modele.append(u'injurieux')
Modele.append(u'insecte')
Modele.append(u'instrumental')
Modele.append(u'instruments')

Modele.append(u'insultes')⏎
Modele.append(u'interjection')
Modele.append(u'internet')
Modele.append(u'intrans')
Modele.append(u'intransitif')
Modele.append(u'iron')
Modele.append(u'ironie')
Modele.append(u'ironique')
Modele.append(u'irrég')
Modele.append(u'irrégulier')
Modele.append(u'islam')
Modele.append(u'jardi')
Modele.append(u'jardin')
Modele.append(u'jardinage')
Modele.append(u'jazz')
Modele.append(u'jeu vidéo')
Modele.append(u'jeux vidéo')
Modele.append(u'jeux')
Modele.append(u'joaillerie')
Modele.append(u'jogging')
Modele.append(u'jonglage')
Modele.append(u'journal')
Modele.append(u'journalisme')
Modele.append(u'judaïsme')
Modele.append(u'judo')
Modele.append(u'juri')
Modele.append(u'jurisprudence')
Modele.append(u'just')
Modele.append(u'justice')
Modele.append(u'karaté')
Modele.append(u'langues')
Modele.append(u'latinisme')⏎
Modele.append(u'ling')
Modele.append(u'linguistique')
Modele.append(u'litote')
Modele.append(u'litt')
Modele.append(u'littér')
Modele.append(u'littéraire')
Modele.append(u'littérature')
Modele.append(u'liturgie')
(contracted; show full)Modele.append(u'minéraux')
Modele.append(u'miroiterie')
Modele.append(u'monnaies')
Modele.append(u'mot-valise')
Modele.append(u'motocyclisme')
Modele.append(u'muscle')
Modele.append(u'musi')

Modele.append(u'musiciens')⏎
Modele.append(u'musique')
Modele.append(u'musiques')
Modele.append(u'myco')
Modele.append(u'mycol')
Modele.append(u'mycologie')
Modele.append(u'mythol')
Modele.append(u'mythologie')
Modele.append(u'méca')
Modele.append(u'mécanique')
Modele.append(u'méd')
Modele.append(u'méde')
Modele.append(u'médecine non conv')
Modele.append(u'médecine')
Modele.append(u'média')
Modele.append(u'médicaments')
Modele.append(u'mélio')
Modele.append(u'mélioratif')
Modele.append(u'métal')
Modele.append(u'métallurgie')
Modele.append(u'métaph')
Modele.append(u'métaphore')
Modele.append(u'méton')
Modele.append(u'métonymie')
Modele.append(u'métrol')
Modele.append(u'métrologie')
Modele.append(u'météo')
Modele.append(u'météorol')
Modele.append(u'météorologie')
Modele.append(u'narratol')
Modele.append(u'narratologie')
Modele.append(u'nata')
Modele.append(u'natation')
Modele.append(u'navig')
Modele.append(u'navigation')
Modele.append(u'neuro')
Modele.append(u'neurologie')
Modele.append(u'noblesse')
Modele.append(u'nom')
Modele.append(u'nombre')⏎
Modele.append(u'nomin')
Modele.append(u'nominatif')
Modele.append(u'nosologie')
Modele.append(u'novlangue')
Modele.append(u'nucl')
Modele.append(u'nucléaire')
Modele.append(u'numis')
Modele.append(u'numismatique')
(contracted; show full)Modele.append(u'programmation')
Modele.append(u'pron')
Modele.append(u'pron-rég')
Modele.append(u'pronl')
Modele.append(u'pronominal')
Modele.append(u'propre')
Modele.append(u'protéines')

Modele.append(u'protocoles')⏎
Modele.append(u'prov')
Modele.append(u'proverbial')
Modele.append(u'préhistoire')
Modele.append(u'prépositionnel')
Modele.append(u'psych')
Modele.append(u'psychia')
Modele.append(u'psychiatrie')
Modele.append(u'psycho')
Modele.append(u'psycho')
Modele.append(u'psychol')
Modele.append(u'psychologie')
Modele.append(u'pâtisserie')
Modele.append(u'pédol')
Modele.append(u'pédologie')
Modele.append(u'péj')
Modele.append(u'péjoratif')
Modele.append(u'pétanque')
Modele.append(u'pétro')
Modele.append(u'pétrochimie')
Modele.append(u'pétrochimie')
Modele.append(u'pêch')
Modele.append(u'pêche')
Modele.append(u'rare')
Modele.append(u'reli')
Modele.append(u'religieux')
Modele.append(u'religion')
Modele.append(u'religions')
Modele.append(u'reliure')
Modele.append(u'repro')
Modele.append(u'reproduction')
Modele.append(u'rhéto')
Modele.append(u'rhétorique')
Modele.append(u'roches')
Modele.append(u'rugby')
Modele.append(u'running')⏎
Modele.append(u'récip')
Modele.append(u'réciproque')
Modele.append(u'réfl')
Modele.append(u'réflexif')
Modele.append(u'réfléchi')
Modele.append(u'réseau')
Modele.append(u'réseaux informatiques')
Modele.append(u'réseaux')
Modele.append(u'rhéto')
Modele.append(u'rhétorique')
Modele.append(u'robotiques')
Modele.append(u'roches')
Modele.append(u'rugby')
Modele.append(u'running')⏎
Modele.append(u'saccusatif')
Modele.append(u'satellites')
Modele.append(u'sci-fi')
Modele.append(u'sciences')
Modele.append(u'scol')
Modele.append(u'scolaire')
Modele.append(u'scul')
Modele.append(u'sculpture')
(contracted; show full)Modele.append(u'voitures')
Modele.append(u'volcanologie')
Modele.append(u'volley')
Modele.append(u'volley-ball')
Modele.append(u'vulg')
Modele.append(u'vulgaire')
Modele.append(u'vx')

Modele.append(u'vx')⏎
Modele.append(u'véhicules')
Modele.append(u'vétérinaire')
Modele.append(u'vête')
Modele.append(u'vêtements')
Modele.append(u'wiki')
Modele.append(u'yoga')
Modele.append(u'zool')
Modele.append(u'zoologie')
(contracted; show full)Modele.append(u'ébauche-trans')
Modele.append(u'ébauche-étym-nom-scientifique')
Modele.append(u'ébauche-étym')
Modele.append(u'ébauche-déf')
Modele.append(u'ébauche-exe')
Modele.append(u'ébauche-pron')
Modele.append(u'ébauche')

Modele.append(u'...')⏎
# Modèles régionaux, pb du nocat pour les prononciations
limit5 = len(Modele)

Modele.append(u'Acadie')
Modele.append(u'Afrique du Sud')
Modele.append(u'Afrique')
Modele.append(u'Algérie')
Modele.append(u'Allemagne')
(contracted; show full)Modele.append(u'Marseille')
Modele.append(u'Maurice')
Modele.append(u'Mayotte')
Modele.append(u'Mexique')
Modele.append(u'Midi toulousain')
Modele.append(u'Midi')
Modele.append(u'Moldavie')

Modele.append(u'Namibie')⏎
Modele.append(u'Nantes')
Modele.append(u'Navarre')
Modele.append(u'Niger')
Modele.append(u'Nigéria')
Modele.append(u'Normandie')
Modele.append(u'Nouvelle-Calédonie')
Modele.append(u'Nouvelle-Zélande')
Modele.append(u'Occitanie')
(contracted; show full)		Modele[] = u'imperfectif'
		Modele[] = u'perf'
		Modele[] = u'imperf'
		
Modele[] = u'T' : à synchroniser
'''


Nombre = []
Nombre.append(u'nombre')
Nombre.append(u'msing')
Nombre.append(u'fsing')
Nombre.append(u'nsing')
Nombre.append(u'mplur')
Nombre.append(u'fplur')
Nombre.append(u'nplur')
Nombre.append(u's')
Nombre.append(u'p')
Nombre.append(u'd')
Nombre.append(u'sp')
Nombre.append(u'singulare tantum')
Nombre.append(u'plurale tantum') 
Nombre.append(u'invariable')
Nombre.append(u'invar')

Genre = []
Genre.append(u'genre')
Genre.append(u'm')
Genre.append(u'f')
Genre.append(u'n')
Genre.append(u'c')
Genre.append(u'mf')
Genre.append(u'mf ?')
Genre.append(u'msing')
Genre.append(u'fsing')
Genre.append(u'nsing')
Genre.append(u'mplur')
Genre.append(u'fplur')
Genre.append(u'nplur')⏎
⏎
# Modification du wiki
def modification(PageHS):
	summary = u'[[Wiktionnaire:Structure des articles|Autoformatage]]'
	if debogage: print u'------------------------------------'
	print(PageHS.encode(config.console_encoding, 'replace'))
	
	if PageHS.find(u'’') != -1:
		page = Page(site,PageHS.replace(u'’', u'\''))
(contracted; show full)		return
	PageTemp = PageBegin
	CleTri = CleDeTri.CleDeTri(PageHS)
	
	regex = ur'{{=([a-z\-]+)=}}'
	if re.search(regex, PageTemp):
		PageTemp = re.sub(regex, ur'{{langue|\1}}', PageTemp)

		if summary.find(u'{{langue}}') == -1: summary = summary + u', déploiement de {{langue}}'⏎
	
	if page.namespace() == 0 or PageHS.find(u'Utilisateur:JackBot/') != -1:
		while PageTemp.find(u'{{ ') != -1:
			PageTemp = PageTemp[0:PageTemp.find(u'{{ ')+2] + PageTemp[PageTemp.find(u'{{ ')+3:len(PageTemp)]
(contracted; show full)		for p in range(1,limit2):
			if p == limit14: EgalSection = u'===='
			if p == limit15: EgalSection = u'====='
			
			regex = ur'[= ]*{{[\-loc]*(' + Modele[p] + u'|S\|'+ Section[p] + ur')([^}]*)}}[= ]*'
			if re.search(regex, PageTemp):
				PageTemp = re.sub(regex, EgalSection + ur' {{S|' + Section[p] + ur'\2}} ' + EgalSection, PageTemp)

				if summary.find(u'{{S}}') == -1 and re.search('{{-\w', PageBegin): summary = summary + u', [[WT:Prise de décision/Rendre toutes les sections modifiables|déploiement de {{S}}]]'⏎
			
			regex = ur'[= ]*{{\-flex[\-loc]*(' + Modele[p] + u'|S\|' + Section[p] + ur')\|([^}]*)}}[= ]*'
			if re.search(regex, PageTemp):
				PageTemp = re.sub(regex, EgalSection + ur' {{S|' + Section[p] + ur'|\2|flexion}} ' + EgalSection, PageTemp)
				if summary.find(u'{{S}}') == -1 and re.search('{{-\w', PageBegin): summary = summary + u', [[WT:Prise de décision/Rendre toutes les sections modifiables|déploiement de {{S}}]]'⏎
		
		if debogageLent: raw_input(PageTemp.encode(config.console_encoding, 'replace'))
		if PageTemp.find(u'|===') != -1 or PageTemp.find(u'{===') != -1:
			if debogage: print u' *==='
			return
		
		# Titres en minuscules
		#PageTemp = re.sub(ur'{{S\|([^}]+)}}', ur'{{S|' + ur'\1'.lower() + ur'}}', PageTemp)
(contracted; show full)
				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)]
			

			'''pb dans [[i]]
			if debogage: print u' Retrait des {{voir| si {{voir/'⏎
			while PageTemp.find(u'{{voir|') != -1 and PageTemp.find(u'{{voir/') != -1:
				PageTemp2 = PageTemp[PageTemp.find(u'{{voir|'):+len(PageTemp)u'{{voir|'):]
				PageTemp = PageTemp[0:PageTemp.find(u'{{voir|') + PageTemp2.find(u'}}')+2] + PageTemp[PageTemp.find(u'{{voir|') + PageTemp2.find(u'}}')+2:len(PageTemp)]⏎
	]
			'''⏎
			
			if debogage: print u' Nettoyage des {{voir}}...'
			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)]
(contracted; show full)
				PageTemp = PageTemp[0:PageTemp.find(baratin)] + PageTemp[PageTemp.find(baratin)+len(baratin):len(PageTemp)]
				summary = summary + u', {{clé de tri|}} supprimée'
			baratin = u'{{clé de tri|}}<!-- Veuillez mettre juste après « {{clé de tri| » le titre de la page en y enlevant tous les accents et éventuels apostrophes, et en changeant les éventuels traits d’union et autres caractères spéciaux par une espace ; s’il n’y a rien à changer, merci d’effacer ces lignes. -->'

			'''Inhibé depuis migration Lua :⏎
			if PageTemp.find(baratin) != -1:
				PageTemp = PageTemp[0:PageTemp.find(baratin)] + PageTemp[PageTemp.find(baratin)+len(baratin):len(PageTemp)]
				summary = summary + u', {{clé de tri|}} supprimée'
			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|}} supprimée'
			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}} supprimée'
			if PageTemp.find(u'{{clé de tri|' + PageHS.lower() + u'}}') != -1 and PageTemp.find(u'{{S|verb pronominal|fr}}') == -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)]
				summary = summary + u', {{clé de tri}} supprimée'''

			if debogage: print u'Remplacements des balises'
			PageTemp = re.sub(ur'\[\[Category:', ur'[[Catégorie:', PageTemp)
			while PageTemp.find(u'</br>') != -1:
				PageTemp = PageTemp[0:PageTemp.find(u'</br>')] + u'<br/>' + PageTemp[PageTemp.find(u'</br>')+len(u'</br>'):len(PageTemp)]
			while PageTemp.find(u'<sup/>') != -1:
				PageTemp = PageTemp[0:PageTemp.find(u'<sup/>')] + u'</sup>' + PageTemp[PageTemp.find(u'<sup/>')+len(u'<sup/>'):len(PageTemp)]
		
			# Ajout de catégories
			'''if PageHS[len(PageHS)-len(u'ejar'):] == u'ejar':
				if PageTemp.find(u'{{langue|ca}}') != -1 and PageTemp.find(u'[[Catégorie:Verbes en catalan suffixés en -ejar]]') == -1:
					PageTemp2 = PageTemp[:PageTemp.find(u'{{langue|ca}}')+len(u'{{langue|ca}}'):]
					if PageTemp2.find(u'\n== {{langue|') != -1:
						if debogage: print u'cat au milieu'
						PageTemp = PageTemp[:PageTemp.find(u'{{langue|ca}}')+len(u'{{langue|ca}}')+PageTemp2.find(u'\n== {{langue|')] + u'\n[[Catégorie:Verbes en catalan suffixés en -ejar]]\n\n' + PageTemp[PageTemp.find(u'{{langue|ca}}')+len(u'{{langue|ca}}')+PageTemp2.find(u'\n== {{langue|'):]
					else:
						if debogage: print u'cat à la fin'
						PageTemp = PageTemp + u'\n\n[[Catégorie:Verbes en occitan suffixés en -ejar]]\n'

				if PageTemp.find(u'{{langue|oc}}') != -1 and PageTemp.find(u'[[Catégorie:Verbes en occitan suffixés en -ejar]]') == -1:
					PageTemp2 = PageTemp[PageTemp.find(u'{{langue|oc}}')+len(u'{{langue|oc}}'):]
					if PageTemp2.find(u'\n== {{langue|') != -1:
						if debogage: print u'cat au milieu'
						PageTemp = PageTemp[:PageTemp.find(u'{{langue|oc}}')+len(u'{{langue|oc}}')+PageTemp2.find(u'\n== {{langue|')] + u'\n[[Catégorie:Verbes en occitan suffixés en -ejar]]\n\n' + PageTemp[PageTemp.find(u'{{langue|oc}}')+len(u'{{langue|oc}}')+PageTemp2.find(u'\n== {{langue|'):]
					else:
						if debogage: print u'cat à la fin'
						PageTemp = PageTemp + u'\n\n[[Catégorie:Verbes en occitan suffixés en -ejar]]\n'
			
			elif PageHS[len(PageHS)-len(u'-able'):] == u'-able':
				if PageTemp.find(u'{{langue|fr}}') != -1 and PageTemp.find(u'[[Catégorie:Mots en français suffixés en -able]]') == -1:
				
				if PageTemp.find(u'{{langue|en}}') != -1 and PageTemp.find(u'[[Category:Mots en anglais suffixés en -able]]') == -1:'''⏎
⏎
		if debogage: print u'Remplacements des modèles'
		PageTemp = re.sub(ur'{{(formatnum|Formatnum|FORMATNUM)\:([0-9]*) ', ur'{{\1:\2', PageTemp)
		PageTemp = re.sub(ur'{{terme*\|Registre neutre}} *', ur'', PageTemp)
		# Ligne de forme
		PageTemp = PageTemp.replace(u'[[' + PageHS + u']]', u'\'\'\'' + PageHS + u'\'\'\'')
(contracted; show full)
		PageTemp = PageTemp.replace(u'{{enm}}', u'moyen anglais')
		PageTemp = PageTemp.replace(u'{{en}}', u'anglais')
		PageTemp = PageTemp.replace(u'{{ru}}', u'russe')
		PageTemp = PageTemp.replace(u'{{nl}}', u'néerlandais')
		PageTemp = PageTemp.replace(u'{{pt}}', u'portugais')
		PageTemp = PageTemp.replace(u'{{it}}', u'italien')
		
PageTemp = PageTemp.replace(u'{{nds}}', u'bas allemand')
		PageTemp = PageTemp.replace(u'=== {{S|voir aussi}} ===\n{{Autres projets\n|w=AG}}', u'=== {{S|voir aussi}} ===\n* {{WP}}')⏎

		# Modèles trop courts
		if debogage: print u'Modèles courts'
		PageTemp = PageTemp.replace(u'{{fp}}', u'{{fplur}}')
		PageTemp = PageTemp.replace(u'{{mp}}', u'{{mplur}}')
		PageTemp = PageTemp.replace(u'{{np}}', u'{{nlur}}')
		PageTemp = PageTemp.replace(u'{{mascul}}', u'{{au masculin}}')
		PageTemp = PageTemp.replace(u'{{fémin}}', u'{{au féminin}}')
(contracted; show full)
		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)]
		regex = ur'\{\{ISBN\|([^\}]*)\}\}'
		if re.search(regex, PageTemp):
			PageTemp = re.sub(regex, ur'ISBN \1', 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)
		
		# Ajout des redirections des pronominaux
		if PageTemp.find(u'{{S|verbe|fr}}') != -1 and PageHS[:3] != u'se' and PageHS[:2] != u's’':
			PageTemp2 = PageTemp[PageTemp.find(u'{{S|verbe|fr}}'):]
			regex = ur'(\n|\')s(e |’)\'\'\''
			if re.search(regex, PageTemp2) 
< PageTemp2.find(u'{{S|') or (re.search(regex, PageTemp2) != -1 andis not None:
				if re.search(regex, PageTemp2) < PageTemp2.find(u'{{S|') or PageTemp2.find(u'{{S|') == -1):
						regex = ur'^[aeiouyàéèêôù]'
						if re.search(regex, PageHS):	# ne pas prendre [:1] car = & si encodage ASCII du paramètre DOS / Unix
							PageHS2 = u's’'+PageHS
						else:
							PageHS2 = u'se '+PageHS
						page2 = Page(site,PageHS2)
						if not page2.exists():
							if debogage: print u'Création de ' + CleDeTri.CleDeTri(PageHS2)
							summary2 = u'Création d\'une redirection provisoire catégorisante du pronominal'
							sauvegarde(page2, u'#REDIRECT[[' + PageHS + u']]\n<!-- Redirection temporaire avant de créer le verbe pronominal -->\n[[Catégorie:Wiktionnaire:Verbes pronominaux à créer en français]]', summary2)
						
		# Ajout de modèles pour les gentités et leurs adjectifs
		if debogage: print u'Gentilés'
		if PageTemp.find(u'{{langue|fr}}') != -1:
			ligne = 6
			colonne = 4
			ModeleGent = [[0] * (colonne+1) for _ in range(ligne+1)]
			ModeleGent[1][1] = ur'fr-accord-mixte'
(contracted; show full)				position = PageTemp.find("}}")
			elif PageTemp.find("|") == -1:
				position = PageTemp.find("}}")
			else:
				position = PageTemp.find("|")

			# Ajout des anagrammes pour cette nouvelle langue détectée
			if 
codelangue == u'conv':
				regex = ur'[= ]*{{S\|anagrammes}}[^}]+\|conv}}\n'
				if re.compile(regex).search(PageTemp):
					if debogage: print u'Retrait d\'anagramme en conv'
					PageEnd2 = PageTemp[:re.compile(regex).search(PageTemp).start()]
					PageTemp2 = PageTemp[re.compile(regex).search(PageTemp).end():]
					delta = re.compile(regex).search(PageTemp).end()
					regex = ur'[^}]+\|conv}}\n'
					while re.compile(regex).search(PageTemp2):
						if debogage: print u' autre anagramme en conv'
						delta = delta + re.compile(regex).search(PageTemp2).end()
						PageTemp2 = PageTemp2[re.compile(regex).search(PageTemp2).end():]
					PageTemp = PageEnd2 + PageTemp[delta:]
				
			elif NouvelleLangue == True and socket.gethostname() != "willow" and socket.gethostname() != "yarrow" and socket.gethostname() != "nightshade" and PageTemp.find(u'-S|erreur-') == -1 |' + codelangue) == -1 and PageTemp.find(u'S|faute|' + codelangue) == -1  and codelangue != u'conv': #and PageHS != u'six':
				if debogage: print u' Anagrammes pour ' + codelangue
				if PageTemp.find(u'{{S|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: print anagramme.encode(config.console_encoding, 'replace')
(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'chimie' or Modele[p] == u'chim' or Modele[p] == u'biochimie' or Modele[p] == u'bioch':
						if (EstCodeLangue == "false"

⏎
	) or (PageTemp.find(u'Catégorie:Acides gras'
	) != -1 and (PageTemp.find(u'Catégorie:Acides gras') < PageTemp.find(u'{{langue|') and PageTemp.find(u'{{langue|') != -1 or PageTemp.find(u'{{langue|') == -1
	) and (PageTemp.find(u':Catégorie:Acides gras') + 1 != PageTemp.rfind(u'Catégorie:Acides gras'))⏎
⏎
	) or (PageTemp.find(u'Catégorie:Éléments chimiques'
	) != -1 and (PageTemp.find(u'Catégorie:É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:Éléments chimiques') + 1 != PageTemp.rfind(u'Catégorie:Éléments chimiques'))

	) or (PageTemp.find(u'Catégorie:Substances chimiques'
(contracted; show full)							print u'Section introuvable : ' + TitreSection
							return
						if Index < limit1:
							# Paragraphe définition
							EstCodeLangue = "true"
							trad = u'false'
							# Ajouts en fin de ligne de forme
							if TitreSection == 'nom' and (codelangue == 'fr' or codelangue == 'e
s' or codelangue == 'pt' or codelangue == 'it' or codelangue == 'de' or codelangue == 'ar' or codelangue == 'ru'):
								if debogage: 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'):]⏎
n' or codelangue == 'es' or codelangue == 'pt' or codelangue == 'it' or codelangue == 'de' or codelangue == 'ar' or codelangue == 'ru'):
								
								if debogage: print u'Recherche du nombre manquant'
								NombreManquant = True
								if PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'') != -1 and PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'') < 100:
									PageTemp2 = PageTemp[PageTemp.find(u'\n')+1:]
									if PageTemp2.find(u'{{' + codelangue + u'-') > PageTemp2.find(u'\n') or PageTemp2.find(u'{{' + codelangue + u'-') == -1:
										PageTemp2 = PageTemp[PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'')+len(u'\n\'\'\'' + PageHS + u'\'\'\''):]
										for n in range(0,len(Nombre)):
											if PageTemp2.find(u'{{' + Nombre[n] + u'|') != -1 or PageTemp2.find(u'{{' + Nombre[n] + u'}}') != -1:
												if debogage: print u' ' + Nombre[n] + u' trouvé'
												NombreManquant = False
										if NombreManquant == True:
											PageTemp = PageTemp[:PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'')+len(u'\n\'\'\'' + PageHS + u'\'\'\'')+PageTemp2.find(u'\n')] + u' {{nombre|' + codelangue + u'}}' + PageTemp[PageTemp.find(u'\n\'\'\'' + PageHS + u'\'\'\'')+len(u'\n\'\'\'' + PageHS + u'\'\'\'')+PageTemp2.find(u'\n'):]
								
								if codelangue != u'en':
									if debogage: print u'Recherche du genre manquant'
									GenreManquant = True
									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'\'\'\''):]
										for n in range(0,len(Genre)): 
											if PageTemp2.find(u'{{' + Genre[n] + u'|') != -1 or PageTemp2.find(u'{{' + Genre[n] + u'}}') != -1:
												if debogage: print u' ' + Genre[n] + u' trouvé'
												GenreManquant = False
										if GenreManquant == True:
											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'):]⏎
								
						else:
							# Paragraphe sans code langue
							EstCodeLangue = "false"
							if TitreSection == 'traductions':
								trad = u'true'
								# Ajout de {{trad-début}} si {{T| en français (pas {{L| car certains les trient par famille de langue)
								if PageTemp.find(u'{{') == PageTemp.find(u'{{T|') and codelangue == 'fr':
(contracted; show full)
								trad = u'true'
							else:
								trad = u'false'
						
						if debogage: print " EstCodeLangue = " + EstCodeLangue
						# Tous ces modèles peuvent facultativement contenir |clé= et |num=, et |genre= pour les prénoms
						if ((p < limit1 and p > 0) or (p == 0 and Section.index(TitreSection) < limit1)) and (PageTemp.find(u'|clé=') == -1 or PageTemp.find(u'|clé=') > PageTemp.find(u'}}')):
							if debogage
Lent: print u'  ' + str(p)
							if debogageLent: print u'  ' + str(Section.index(TitreSection))
							if debogageLent: print PageTemp[:PageTemp.find(u'}}')].encode(config.console_encoding, 'replace')
							TitreTemp = PageHS
							if codelangue == 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'fi':
								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€€€')⏎
								
							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'а€')
(contracted; show full)			PageEnd = PageEnd.replace(u"{{genre|fr}}", u"{{m}}")
		if PageHS[-4:] == u'iste':
			PageEnd = PageEnd.replace(u"{{genre|fr}}", u"{{mf}}")
		if PageHS[-4:] == u'aire':
			PageEnd = PageEnd.replace(u"{{genre|fr}}", u"{{mf}}")
		if PageHS[-1:] == u'é':
			PageEnd = PageEnd.replace(u"{{genre|fr}}", u"{{m}}")
		
	⏎
		if PageHS.find(u' ⏎
		if debogage: print u'Genre manquant de locution'
		if PageHS.find(u' ') != -1 and PageHS.find(u'{{langue|fr}}') != -1:
			PageLemme = u''
			page2 = Page(site,PageHS[:PageHS.find(u' ')])
			if page2.exists():
				if page.namespace() !=0:
					print u'Page non traitée l 4591785'
					return
				else:
					try:
						PageLemme = page2.get()
					except wikipedia.NoPage:
						print "NoPage l 4597791"
					except wikipedia.IsRedirectPage: 
						print "IsRedirect l 4599793"
			else:
				print "NoPage l 4601795"
			if PageLemme != u'':
				genre = u''
				if PageLemme.find(u'|fr}} {{m}}') != -1:
					genre = u'{{m}}'
				elif PageLemme.find(u'|fr}} {{f}}') != -1:
					genre = u'{{f}}'
				if genre != u'':
(contracted; show full)			except wikipedia.IsRedirectPage: 
				print "IsRedirect l 4701"
				return
			if PageEN.find(u'==English==') != -1:
				PageEnd = PageEnd + u'\n[[en:' + PageHS + u']]'
				summary = summary + u', ajout d\'interwiki'
				
	# Syntaxe humaine imprévue de {{terme}}
 dans l'étymologie
	PageEnd = PageEnd.replace(u'{{nom|nocat=1}}', u"''(Nom)''")
	
	#Traitement de crawlerSearch(u'"source à préciser"')
	'''regex = ur'({{source\|)([^1}}])'
	if re.search(regex, PageEnd):
		if debogage: print u'source à préciser'
		PageEnd = re.sub(regex, ur'{{source|1=\2', PageEnd)
		summary = summary + u', précision de "(source à préciser)"'
	'''⏎
	⏎
	if debogage: print u'Test des URL'
	#PageEnd = hyperlynx.hyperlynx(PageEnd)
	if debogage: print (u'--------------------------------------------------------------------------------------------')
	if PageEnd != PageBegin:
		# Modifications mineures, ne justifiant pas une édition à elles seules
		PageEnd = PageEnd.replace(u'  ', u' ')
		PageEnd = PageEnd.replace(u'\n\n\n\n', u'\n\n\n')
		sauvegarde(page,PageEnd, summary)
	elif debogage:
		print "Aucun changement"
		

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

def addCat(PageTemp, lang, cat):
	if PageTemp.find(cat) == -1:
		PageTemp2 = PageTemp[PageTemp.find(u'{{langue|' + lang + u'}}')+len(u'{{langue|' + lang + u'}}'):]
		if PageTemp2.find(u'{{langue|') != -1:
			if debogage: print u' catégorie ajoutée avant la section suivante'
			if PageTemp2.find(u'== {{langue|') != -1:
				PageTemp = PageTemp[:PageTemp.find(u'{{langue|' + lang + u'}}')+len(u'{{langue|' + lang + u'}}')+PageTemp2.find(u'== {{langue|')] + cat + u'\n\n' + PageTemp[PageTemp.find(u'{{langue|' + lang + u'}}')+len(u'{{langue|' + lang + u'}}')+PageTemp2.find(u'== {{langue|'):]
			elif PageTemp2.find(u'=={{langue|') != -1:
				PageTemp = PageTemp[:PageTemp.find(u'{{langue|' + lang + u'}}')+len(u'{{langue|' + lang + u'}}')+PageTemp2.find(u'=={{langue|')] + cat + u'\n\n' + PageTemp[PageTemp.find(u'{{langue|' + lang + u'}}')+len(u'{{langue|' + lang + u'}}')+PageTemp2.find(u'=={{langue|'):]
			else:
				 print u'Modèle {{langue| mal positionné'
		else:
			if debogage: print u' catégorie ajoutée avant les interwikis'
			regex = ur'\n\[\[\w?\w?\w?:'
			if re.compile(regex).search(PageTemp):
				try:
					PageTemp = PageTemp[:re.search(regex,PageTemp).start()] + u'\n' + cat + u'\n' + PageTemp[re.search(regex,PageTemp).start():]
				except:
					print u'pb regex interwiki'
			else:
				if debogage: print u' catégorie ajoutée en fin de page'
				PageTemp = PageTemp + u'\n' + cat
	return PageTemp⏎
⏎
def rec_anagram(counter):
	# Copyright http://www.siteduzero.com/forum-83-541573-p2-exercice-generer-tous-les-anagrammes.html
    if sum(counter.values()) == 0:
        yield ''
    else:
        for c in counter:
            if counter[c] != 0:
                counter[c] -= 1
(contracted; show full)			return

# Lancement
if len(sys.argv) > 1:
	if sys.argv[1] == u'test':
		TraitementPage = modification(u'User:' + mynick + u'/test')
	elif sys.argv[1] == u'txt':
		TraitementFichier = crawlerFile(u'articles_' +
 language + u'_' + family + u'.txt')
	elif sys.argv[1] == u'm':
		TraitementLiens = crawlerLink(u'Modèle:pl-cour',u'')
		TraitementLiens = crawlerLink(u'Modèle:pl-rare',u'')
	elif sys.argv[1] == u'cat':
		TraitementCategorie = crawlerCat(u'Catégorie:Pages using duplicate arguments in template calls',False,u'')
	elif sys.argv[1] == u'lien':
		TraitementLiens = crawlerLink(u'Modèle:sports de combat',u'finnois',False,u'tuulla')
	elif sys.argv[1] == u'lien':
		TraitementLiens = crawlerLink(u'Modèle:sports de combat',u'')
	elif sys.argv[1] == u'page':
		TraitementPage = modification(u'AG')
	elif sys.argv[1] == u's':
		TraitementRecherche = crawlerSearch(u'"source à préciser"')
	else:
		TraitementPage = modification(sys.argv[1])	# Format http://tools.wmflabs.org/jackbot/xtools/public_html/unicode-HTML.php
else:
	# Quotidiennement :
	TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Codes langue manquantsTerminologie sans langue précisée',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'')
	TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Ébauches à compléter',False,u'')
	TraitementLiens = crawlerLink(u'Modèle:trad',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:-',u'')
	TraitementLiens = crawlerLink(u'Modèle:-ortho-alt-',u'')
	TraitementLiens = crawlerLink(u'Modèle:mascul',u'')
	TraitementLiens = crawlerLink(u'Modèle:fémin',u'')
	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:-déf-',u'')
	TraitementCategorie = crawlerCat(u'Catégorie:Wiktionnaire:Utilisation d\'anciens modèles de section',True,u'')⏎
	TraitementCategorie = crawlerCat(u'Catégorie:Pages à vérifier car créées automatiquement',False,u'')

'''	
	while 1:
		TraitementRC = crawlerRC_last_day()

TraitementLiensCategorie = crawlerCatLink(u'Catégorie:Modèles désuets',u'')
TraitementLiens = crawlerLink(u'Modèle:SAMPA',u'') : remplacer les tableaux de prononciations ?
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'')

# Modèles
TraitementPage = modification(u'Modèle:terme')
TraitementLiens = crawlerLink(u'Modèle:terme',u'')
TraitementFichier = crawlerFile(u'articles_WTin.txt')
TraitementLiensCategorie = crawlerCatLink(u'Modèles de code langue',u'')
TraitementCategorie = crawlerCat(u'Catégorie:Appels de modèles incorrects',True,u'')
TraitementRecherche = crawlerSearch(u'"en terme de"')⏎
TraitementUtilisateur = crawlerUser(u'Utilisateur:JackBot', 800)
TraitementRedirections = crawlerRedirects()
TraitementTout = crawlerAll(u'')
	
python delete.py -lang:fr -family:wiktionary -file:articles_WTin.txt
python movepages.py -lang:fr -family:wiktionary -pairs:"articles_WTin.txt" -noredirect -pairs
python interwiki.py -lang:fr -family:wiktionary -page:"Wiktionnaire:Accueil communautaire"
'''
</source>
All content in the above text box is licensed under the Creative Commons Attribution-ShareAlike license Version 4 and was originally sourced from https://fr.wiktionary.org/w/index.php?diff=prev&oldid=18852698.
This site is not affiliated with or endorsed in any way by the Wikimedia Foundation or any of its affiliates. In fact, we fucking despise them.