Utente:Alfiobot/tasks.py

Da Wikipedia, l'enciclopedia libera.
Vai alla navigazione Vai alla ricerca

(la formattazione viene male perché io uso i tab a 4 spazi mentre qui pare che siano fissi ad 8).


#!/usr/bin/Python
# -*- coding: utf-8 -*-
#
# Script da riutilizzare per i vari compiti

import os, sys
import bot
import wikipedia, pagegenerators


########################################################
# Varie serie di replace da applicare ''sempre''

correggi_templates = [ ('\s+<noinclude>\s+', '<noinclude>'),			# Togli gli spazi prima e dopo il noinclude
					   ('\s+</noinclude>\s+', '</noinclude>'),
					   (r'<noinclude>(.*?)</noinclude><noinclude>(.*?)</noinclude>', r'<noinclude>\1\2</noinclude>')
					 ]

#####################################################
# Altri da applicare con approvazione manuale


# DA FARE
#
# Occorre evitare le sostituzioni dentro i link (per i piped link, la parte prima del pipe)

correggi_accenti =       [ (u"E' ", u"È "),				# tutti con lo spazio in modo da matchare solo a fine parola
                           (u"É ", u"È "),
                           (u"a' ", u"à "),
                           (u"e' ", u"è "),
                           (u"i' ", u"ì "),
                           (u"o' ", u"ò "),
                           (u"u' ", u"ù "),
                           (u" é ", u" è "),
                           (u"á ", u"à "),
                           (u"ú ", u"ù "),
                           (u"perchè", u'perché'),
                           (u"poichè", u'poiché'),
                           (u"nonchè", u'nonché'),
                           (u"benchè", u'benché'),
                           (u"sicchè", u'sicché'),
                           (u"pressochè", u'pressoché'),
                           (u"anzichè", u'anziché'),
                           (u"affinchè", u'affinché'),
                           (u"allorchè", u'allorché'),
                           (u"cosicchè", u'cosicché'),
                           (u"finchè", u'finché'),
                           (u"dopodichè", u'dopodiché'),
                           (u"peró", u'però'),
                           (u" nè", u' né'),
                           (u" pò ", u" po' "),				# Questi vanno in fondo (per rimediare al danno fatto prima)
                           (u" mò ", u" mo' "),
                           (u" dè ", u" de' "),
                           (u" Dè ", u" De' "),
                           (u" pè ", u" pe' "),
                           (u" fè ", u" fe' "),
                           (u" dù ", u" du' "),
                           (u" Frà ", u" Fra' "),
                           (u" fà ", u" fa' "),
                           (u" cà ", u" ca' "),
                           (u"'colorè", u"'colore'"),		# Caso speciale per il template film
                           (u"'mutò", u"'muto'"),			# Caso speciale per il template film
                           (u"Panamà", u"Panamá"),			# Panamá ha l'accento a rovescio
                           (u"Paranà", u"Paraná"),			# Anche Paraná
                           (u" và", u" va"),				# Toglie gli accenti dove non ci devono stare
                           (u" quì", u" qui"),
                           (u" fù", u" fu"),
                           (u" quà", u" qua"),
                           (u" tr[èé] ", u" tre "),
                           (u" puo ", u" può "),				# E li mette dove servono
                           (u" cioé ", u" cioè "),
                           (u" cioe ", u" cioè ")
                         ]
correggi_punteggiatura = [ (u"’", u"'"),				# apostrofi standard
                           (u"‘", u"'"),
                           (u"`", u"'"),
                           (u"´", u"'"),
                           (r" '([\.\w\ ]+)' ", r' "\1" '),		# converte 'parola' in "parola"
                           (u'"colore"', u"'colore'"),		# Caso speciale per il template film
                           (u'"muto"', u"'muto'"),			# Caso speciale per il template film
                           (u'“', u'"'),				# Virgolette standard
                           (u'”', u'"'),
                           (u'–', u'-'),                # linetta orizzontale standard
                           (r"\–", r"-"),
                           (r"\,([^\d\-\s\<\"\'])", r", \1"),	# Aggiunge lo spazio dopo la virgola tranne che nel caso di numeri o tag html da aprire o "virgola in virgolette"
                           (r" ([^\&\s]+)\;([^\s\"\<])", r" \1; \2"), # Aggiunge lo spazio dopo ; tranne che nel caso di entity html, oppure css che si chiudono o tag html che si aprono dopo il ;
                           (r", +([^\s\<])", r", \1"),           	# elimina spazi multipli dopo la virgola, ma non a fine riga
                           (r"([^\.])\. +([^\s\<])", r"\1. \2"),    # elimina spazi multipli dopo il punto, ma non a fine riga
                           (r"\: +([^\s\<])", r": \1"),          # elimina spazi multipli dopo i due punti, ma non a fine riga
                           (r"(\S) +,", r"\1,"),				# Non usare \s al posto dello spazio perché prende anche i newline
                           (r"(\S) +\.([^\.]{2})", r"\1.\2"),	# Toglie gli spazi prima del punto, tranne nel caso di tre puntini
                           (r"(\S) +\;", r"\1;"),
                           (r"(\S) +\:", r"\1:"),
                           (r"(?i) (l') ", r" \1"),				# Toglie gli spazi dopo l'apostrofo
                           (r"(?i) (dell') ", r" \1"),
                           (r"(?i) (dall') ", r" \1"),
                           (r"(?i) (nell') ", r" \1"),
                           (r"(?i) (sull') ", r" \1"),
                           (r"(?i) (all') ", r" \1"),
                           (r"(?i) (un') ", r" \1"),
                           (r"(?i) (d') ", r" \1"),
                           (r"(?i) (l') ", r" \1"),
                           (r"(?i) (dell)\s+' ", r" \1'"),		# E anche prima
                           (r"(?i) (dall)\s+' ", r" \1'"),
                           (r"(?i) (nell)\s+' ", r" \1'"),
                           (r"(?i) (sull)\s+' ", r" \1'"),
                           (r"(?i) (all)\s+' ", r" \1'"),
                           (r"(?i) (d)\s+' ", r" \1'"),
                           (r"(?i) (l)\s+' ", r" \1'"),
                           (r"([0-9A-Za-z])\(", r"\1 ("),	# Spazio prima della parentesi ( non usa \w per non matchare _ nei link)
                           (r"\)([0-9A-Za-z])", r") \1"),	# Spazio dopo della parentesi
                           (r"(?i) (d') ", r" \1"),
                           (r'([^\"]),("+)', r'\1\2,'),			# Inversione della "virgola in virgolette" tipica dell'inglese
                           (r'([^\"\.])\.("+)', r'\1\2.'),		# Inversione della "punto in virgolette" tipica dell'inglese
                           (r"'", r"'"),		# Il nowiki è quasi sempre inutile
                           (r",,", r",")						# Via le doppie virgole

#                          questo è tolto perché becca tutti i google maps
#                           (r"(\d+),(\d+)\.(\d+)", r"\1.\2,\3")		# Converte i numeri da notazione USA a notazione europea

                         ]
                          # (r"\.([A-Za-z])", r". \1"),   - non funziona con le immagini come pippo.jpg
                          # (r"\:([A-Za-z])", r": \1")    - questo matcha categorie e interwiki

correggi_html =        [ (r"\&sup2([^\;])", r"²\1"),
                         (r"\&nbsp([^\;])", r" \1"),
                         (r'Aria"', r'Arial"'),				# Ci sono molti riferimenti ad un font "Aria"
                         (r"<i>(.*?)</i>", r"''\1''"),
                         (r"<b>(.*?)</b>", r"'''\1'''"),
                         (r"<br>\n\n", r"\n\n"),            # Toglie il <br> a fine paragrafo
                         (r"&([\w]grave)[^\;]", r"&\1;\2"),
                         (r"&([\w]acute)[^\;]", r"&\1;\2"),
                         (u"È", u"È"),
                         (u"à", u"à"),
                         (u"è", u"è"),
                         (u"é", u"é"),
                         (u"ì", u"ì"),
                         (u"ò", u"ò"),
                         (u"ù", u"ù"),
                         (r"([Kk])m2", r"\1m²"),
                         (r" m2 ", r" m² ")
                         ]
                         
                         

correggi_intestazioni =  [ (u"(?i)\=+\s*vedi anche\s*\=+", u"== Voci correlate =="),
                           (u"(?i)\=+\s*articoli correlati\s*\=+", u"== Voci correlate =="),
                           (u"(?i)\=+\s*articoli collegati\s*\=+", u"== Voci correlate =="),
                           (u"(?i)\=+\s*link\s*\=+", u"== Collegamenti esterni =="),
                           (u"(?i)\=+\s*links* esterni\s*\=+", u"== Collegamenti esterni =="),
                           (u"(?i)\=+\s*riferimenti esterni\s*\=+", u"== Collegamenti esterni =="),
                           (u"(?i)\=+\s*risorse esterne\s*\=+", u"== Collegamenti esterni =="),
                           (r"(?i)\=+(\s*)voci correlate\s*\=+", r"==\1Voci correlate\1=="),				# Questi due per normalizzare il livello dell'header
                           (r"(?i)\=+(\s*)collegamenti esterni\s*\=+", r"==\1Collegamenti esterni\1==")
                         ]

correggi_links        =  [ (u'\[\[\s+', u'[['),			 	# Spazi dopo [[                           (r'([^\|\]])\s+\]\]', r'\1]]'),	# Spazi prima di ]], tranne che in un piped link o in]] nestati
                           (r'([A-Za-z])\[\[', r'\1 [['),	# Aggiunge uno spazio tra l'ultima parola e [[
                         ]


#################################
# Categorizza_template
#
# Si assicura che un template sia categorizzato nel modo giusto, e cioè:
#
# - abbia il tag di categoria
# - il tag di categoria sia dentro un tag <noinclude>
# - non ci siano spazi prima e dopo i tag noinclude
# - la pagina discussione non abbia né {{avvisotemplate}} né la categoria stessa
###############################

					   
					   
def categorizza_template( templateTitle, cat):

	p = bot.getpage("Template:"+templateTitle)
	disc_p = bot.getpage("Discussioni template:"+templateTitle)

	bot.setaction("Categorizzazione template con noinclude")

	cat_string = "[[%s:%s]]" % (wikipedia.getSite().category_namespace(), cat)
	noinclude_string = "<noinclude>"+cat_string+"</noinclude>"
	
	try:
		acted= False
		if not bot.isincat( p, cat):
			bot.append( p, noinclude_string, send = False)
			bot.log(u"Added category "+cat+" and noinclude tag", page = p)
			acted = True
		elif not bot.is_cat_noinclude( p, cat):
			bot.replace( p, [(cat_string, noinclude_string)], use_regexp = False, send = False)
			bot.log(u"Added noinclude", page = p)
			acted = True
		
		if bot.replace( p, correggi_templates, send = False ):
			bot.log(u"correggid template", page = p)
			acted = True

		if acted:
			bot.sendpage(p)
		else:
			bot.log(u"Skipped (ok)", page = p)
	except:
		bot.handle_exceptions()

	try:
		if bot.replace( disc_p, [("(?i){{Avvisotemplate}}", " ")]):
			bot.log(u"Removed warning template", page = disc_p)
		
		if bot.isincat( disc_p, cat):
			bot.removecat( p.title(), cat)
			bot.log(u"Removed category", page = disc_p)
	except:
		bot.handle_exceptions()


############################
# movecats
#
# Sposta la categorizzazione dei template dalle pagine discussione
# alle pagine template, usando il tag <noinclude>. Salta le pagine non-discussione già  categorizzate
#
#############################

def movecats( cat):

	bot.openlog("movecats")
	bot.setaction("Spostamento categoria dalla pagina discussione al template")

	# Trova l'elenco delle pagine da controllare
	pages = bot.list_cat_pages(cat)
	titoli = []
	
	for page in pages:
		pos = page.title().find(':')
		if pos >=0:
			titoli.append( page.title()[pos+1:])
		
	bot.log( str(len(titoli))+"*2 pages to process")
				
	for titolo in titoli:
		categorizza_template( titolo, cat)


##############################
# correggi
#
# Corregge gli errori più comuni in una pagina o in una lista di pagine.
# Viene chiesta conferma prima di applicare i cambiamenti.
#
#############################

def correggi( title):
	bot.openlog("correggi")
	bot.setaction("accenti/spazi/punteggiatura/intestazioni/links")
	
	bot.replace( title, correggi_punteggiatura + correggi_accenti + correggi_html + correggi_intestazioni + correggi_links,
	             interactive = True,
	             exclude=[('<math>','</math>'), ('<hiero>', '</hiero>'), ('<!--', '-->'), ('<div style', '>') ])



#########################
# fai_comune
#
# piccolo bot per correggere alcuni errori nelle tabelle dei comuni

def fai_comune(title):
	bot.openlog("comuni")
	bot.setaction("apostrofi")
	
	correggi_comuni = [  (u"latitudine(.*)\‘", r"latitudine\1'"),
                         (u"latitudine(.*)\’", r"latitudine\1'"),
                         (u"longitudine(.*)\‘", r"longitudine\1'"),
                         (u"longitudine(.*)\’", r"longitudine\1'"),
                       ]

	try:
		bot.replace( title, correggi_comuni, interactive= False)
	except wikipedia.LockedPage:
		pass


###############################################
# Main

    	

if sys.argv<2:
	print "Devi specificare un task"
	sys.exit()
	
task = sys.argv[1]
print "Task: "+task


##################
# Movecats
#
# Uso:  tasks.py movecats "Categoria"
#
# Sposta le categorie dalla pagina di discussione del template al template stesso
###################

if task == "movecats":
	cat = sys.argv[2]
	movecats(cat)
	
##############
# test
#
#############

if task == "test":
	f = sys.argv[2]
	gen = bot.XmlDumpPageGenerator(f)
	for page in gen:
		print page.text
	
###############
# Correggi
#
# Uso: tasks.py correggi -file:file.txt
#      tasks.py correggi -all "Start"
#
# Esegue la funzione correggi() sulle pagine elencate nel file, oppure in tutte le pagine di it.wiki a partire da quella indicata

if task == "correggi":
	title = sys.argv[2]
	if title[0] == "-":
		if title[0:6] == "-file:":
			bot.do_generator( pagegenerators.TextfilePageGenerator(title[6:]), correggi, preload = True)
		elif title == "-all":
			start = sys.argv[3]
			bot.do_generator( pagegenerators.AllpagesPageGenerator( start = start), correggi, preload = True)
	else:
		correggi(title)

if task == "comuni":
	bot.do_generator( pagegenerators.ATextfilePageGenerator("comuni.txt"), fai_comune, preload = True)
	
bot.closelog()
wikipedia.stopme()