# -*- coding: utf-8 -*-
# funziona solo con l'ultima versione di pywikipedia
"""
Questo bot controlla che le immagini specificate non siano presenti nelle
pagine utenti. Nel caso lo siano lascia un messaggio nella pagine di
discussione dell'utente. Nel caso il messaggio sia stato lasciato più di
un certo tempo rimuove l'immagine.
Parametri:
-images - Lavora sulle immagini. Controlla tutte le immagini specificate,
se sono presenti su una pagina utente mette l'avviso, se
l'avviso è caduto elimina l'immagine
-users - Lavora sugli utenti. Controlla gli utenti specificati, se hanno
un avviso scaduto elimina l'immagine relativa all'avviso
-template - Considera tutti gli/le utenti/immagini che includono un template,
ad esempio "-template:EDP"
-page - Considera gli/le utenti/immagini specificati
-file - Considera gli/le utenti/immagini specificati nel file
-cat - Considera gli/le utenti/immagini che appartengono ad una
categoria specificate
-first - Agisce solo sulle pagine dopo l'argomento specificato
-always - Non chiede conferma
-ultimatum - Numero di giorni tra la segnalazione tramite avviso e la
cancellazione. Default = 7
Esempi: elimina_immagini.py -images -template:EDP
controlla tutte le immagini che includono il Template:EDP, se
sono presenti in una pagina utente mette l'avviso, se l'avviso
è scaduto elimina l'immagine
elimina_immagini.py -images -page:Immagine:Italia-Stemma.png
controlla se l'immagine Italia-Stemma.png è presente nelle
pagine utente. Mette gli avvisi, se trova avvisi scaduti
relativi a queste immagini elimina le immagini
elimina_immagini.py -users -cat:\"Categoria:Utenti che hanno
immagini EDP\"
controlla tutti gli utenti che appartegono alla categoria:... che
è quella a cui appartengono gli utenti se hanno l'avviso nella
pagina di discussione. La categoria può riferirsi sia alla pagina
utente che alla pagina di discussione
elimina_immagini-py -users -template:EDP Pagina Utente
controlla tutti gli utenti che hanno nella loro pagina il
template Template:EDP_Pagina_Utente. Se hanno un avviso
scaduto elimina le immagini.
elimina_immagini.py -users -page:Utente:Wisbot
controlla se l'utente Wisbot ha un avviso scaduto nelle sue
discussioni. Se scaduto elimina l'immagine a cui l'avviso
si riferisce
elimina_immagini.py -images -template:EDP -first=\"Immagine:British
iot flag medium.png\"
"""
#
# (C) Wiso, 2007
#
# Distributed under the terms of the GPL license.
#
from __future__ import generators
from datetime import date, timedelta
from time import strptime
import sys, re
import wikipedia, pagegenerators, config, catlib
mysite = wikipedia.getSite()
# TODO: generalizzare
userDiscussionNamespaceName = 'Discussioni_utente'
# TODO: generalizzare
userNamespaceName = 'Utente'
paginaSostituti = 'Utente:Wisbot/EDP/sostituti'
formatoData = '%d %b %Y'
regexTrovaUtente = re.compile(u'[^/]+')
rAvviso = u'\{\{[Ee]DP[ _]Pagina[ _]Utente\|(.*?)\|[Dd]ata_eliminazione ?= ?(.*?)\|[Ss]tato ?= ?(.*?)\}\}'
regex_ = re.compile('_([^\]])')
def imageName2regex(image):
"""
prende il nome di una immagine e la rende adatta ad essere usata in una
regex es: 'mia immagine.png' -> '[Mm]ia[ _]immagine\.png'
"""
# maiuscole / minuscole come iniziale
image = '[' + image.upper()[0] + image.lower()[0] + ']' + image[1:]
# escape sul .
image = image.replace('.','\.')
# escape su parantesi )(
image = image.replace('(','\(')
image = image.replace(')','\)')
# spazio -> [ _]
image = image.replace(' ','[ _]')
# accenti ' -> ('|%27)
image = image.replace('\'','(\'|%27)')
# à -> (à|%C3%A0)
image = image.replace(u'à',u'(à|%C3%A0)')
# _ -> [ _] facendo attenzione che è già stata fatta la
# precedente sostituzione
regex = regex_
regex_.sub('[ _]\1',image)
return image
def trovaPaginaUtente(page):
#TODO: FAR FUNZIONARE CON SOTTOPAGINE
if (page.namespace() == 2):
return page
elif (page.namespace() == 3):
title = page.titleWithoutNamespace()
regex = regexTrovaUtente
match = regex.search(title)
if (not match):
return None
paginaUtente = wikipedia.Page(mysite, userNamespaceName + ':' + match.group(0))
return paginaUtente
else:
return None
def trovaPaginaDiscussione(page):
#TODO: FAR FUNZINOARE CON SOTTOPAGINE
if (page.namespace() == 3):
return page
elif (page.namespace() == 2):
title = page.titleWithoutNamespace()
regex = regexTrovaUtente
match = regex.search(title)
if (not match):
return None
paginaDiscussione = wikipedia.Page(mysite, userDiscussionNamespaceName + ':' + match.group(0))
return paginaDiscussione
else:
return None
def scaduto(string):
"""
ritorna True o False a seconda che la data rappresentata nella stringa
string sia scaduta
"""
dataScadenza = date(*(strptime(string, formatoData)[:3]))
delta = date.today() - dataScadenza
if (delta.days >= 0):
return True
return False
class ImmaginiUtenteRobotCattivo:
"""
Questo bot cicla sulle pagine utente contenute in gen. Se in gen sono
contente delle pagine di discussione cicla sulle pagine utente relative.
Per prima cosa analizza se sono stati lasciati avvisi nella pagina di
discussione. In caso positivo fa passare la pagina utente e tutte le
sottopagine guardando quali immagini sono incluse. Se è inclusa l'
immagine cercata apre la pagina e cerca dove è inserita l'immagine. La
elimina e aggiorna il messaggio nella discussione.
"""
def __init__(self, gen, acceptAll = False, ultimatumGiorni = 7, verbose = True):
# generatore che contiene le pagine su cui agire. Le pagine dovrebbero
# essere pagine utente o di discussione. Nel secondo caso vengono
# trovate le pagine utente relative
self.gen = gen
self.acceptAll = acceptAll
self.verbose = verbose
self.ultimatumGiorni = ultimatumGiorni
self.mysite = wikipedia.getSite()
# stringhe da usare nel template
self.fattoStr = 'fatto'
self.rimossoStr = 'rimosso'
self.incorsoStr = 'in_corso'
# messaggio in setAction
self.messageEliminaImmagine = "Bot: elimino immagine [[Immagine:%s]]"
# regex per immagini semplici
self.preRegexImmagine1 = u'\[\[[Ii]m(?:age|magine): ?%s ?(?P<arg>(\|.*?)?\]\])'
# regex per immagini nelle gallerie
self.preRegexImmagine2 = u'(?s)(?P<pre><gallery>.*?)([Ii]m(?:age|magine):%s)(?P<post>.*?</gallery>)'
# quello che lascia al posto delle immagini semplici
# self.immagineSostituto1 = '<!-- Immagine eliminata dal bot -->'
# e quelle nelle gallerie
# self.immagineSostituto2 = '\g<pre> '+ self.immagineSostituto1 + ' \g<post>'
# save time
self.compileRegex()
# load sostituti
self.sostituti = self.caricaSostituti()
def compileRegex(self):
#TODO: duplicato
self.regexAvviso = re.compile(rAvviso)
self.regexTrovaUtente = re.compile(u'[^/]+')
def caricaSostituti(self):
regex = re.compile('\[\[:(Immagine:.*?)\]\]\|\|\[\[:(Immagine:.*?)\]\]')
page = wikipedia.Page(mysite,paginaSostituti)
text = page.get()
sostituti = {}
for m in regex.finditer(text):
pageIm = wikipedia.Page(mysite,m.group(1))
sostituti[pageIm.title()] = m.group(2)
return sostituti
def immagineSostituta(self, immagine, gallery=False):
sostituto = '<!-- Immagine eliminata dal bot -->'
immagine = u'Immagine:' + immagine
if self.sostituti.has_key(immagine):
wikipedia.output(u'Trovata immagine sostituta: %s' % self.sostituti[immagine])
if gallery:
sostituto = '\g<pre>' + self.sostituti[immagine] + '\g<post>'
else:
# arg comprende già le parentesi di chiusura
sostituto = '[[' + self.sostituti[immagine] + '\g<arg>'
return sostituto
def run(self):
for page in self.gen:
# se la pagina è una pagina di discussione passa la pagina
# utente relativa
page = trovaPaginaUtente(page)
# se è bloccata segnala e salta
if (not page.canBeEdited()):
string = u'\03{lightyellow}Pagina \03{lightred}%s\03{lightyellow} bloccata\03{default}' % page.title()
wikipedia.output(string)
continue
stringa = u'\03{lightpurple} >>> %s <<<\03{default}' % page.title()
wikipedia.output(stringa)
self.runPage(page)
def runPage(self,page):
pageDiscussione = trovaPaginaDiscussione(page)
if (not pageDiscussione):
# se non c'è la pagina di discussione lascia perdere
# significa che non ci possono essere avvisi
stringa = u'\03{lightyellow}PAGINA \03{lightred}%s\03{lightyellow} NON VALIDA\03{default}' % page.title()
wikipedia.output(stringa)
return
# cerca le immagini segnalate nella pagina di discussione
images = self.trovaImmaginiSegnalate(pageDiscussione)
for image in images:
if self.verbose:
wikipedia.output(u'E\' stata segnalata l\'immagine \03{lightblue}%s\03{default} in \03{lightblue}%s\03{default}' % (image, page.title()))
self.doinPage(page,image)
def doinPage(self,page,image):
if self.deleteinPage(page,image):
self.avvisoRimosso(trovaPaginaDiscussione(page),image)
return True
else:
# se l'immagine non viene eliminata significa che non è stata
# trovata.
wikipedia.output(u'\03{lightgreen}L\'utente ha rimosso da solo l\'immagine\03{default}')
self.avvisoFatto(trovaPaginaDiscussione(page),image)
return True
def sottoPagine(self,page):
"""
Ritorna una lista di nomi di sottopagine
"""
#TODO: CHECK AND FIX
result = []
text = page.get()
Rtemplate = re.compile(r'{{(?P<name>[^{\|]+?)}}')
for m in Rtemplate.finditer(text):
name = m.group('name')
result.append(name)
return result
def deleteinPage(self,page,imageEliminare):
"""
Trova in quale sottopagina c'è l'immagine da eliminare e chiama la
funzione che l'elimina. Resistuisce True o False se l'immagine è stata
trovata ed eliminata
"""
# TODO trovato / trovato2
if self.verbose:
wikipedia.output(u'Cerco in %s' % page.title())
try:
images = page.imagelinks()
except wikipedia.IsRedirectPage:
string = u'\03{lightyellow}La pagina \03{lightred}%s\03{lightyellow} è un REDIRECT ==> SALTO\03{default}' % page.title()
wikipedia.output(string)
return False
except wikipedia.NoPage:
string = u'\03{lightyellow}Pagina \03{lightred}%s\03{lightyellow} NON TROVATA ==> SALTO\03{default}' % page.title()
wikipedia.output(string)
return False
# imagelinks restituisce solo le immagini che sono presenti nella pagina
# NON quelle presenti nelle sottopagine incluse (e che quindi compaiono)
trovata = False
for image in images:
if (image.title() == imageEliminare):
# l'immagine è proprio in questa (sotto)pagina
wikipedia.output(u'Immagine \03{lightblue}%s\03{default} presente in \03{lightblue}%s\03{default}' %(image.title(), page.title()))
if (self.deleteImage(page,image.titleWithoutNamespace())):
trovata = True
else:
stringa = u'\03{lightyellow}ERRORE: NON TROVO L\'IMMAGINE \03{lightred}%s\03{default} in \03{lightred}%s\03{default}' % (imageEliminare,page.title())
wikipedia.output(stringa)
# cerca nelle sottopagine (anche se l'immagine è già stata trovata)
trovato2 = False
# prendo la lista di tutte le pagine incluse
templates = self.sottoPagine(page)
for template in templates:
if (template[0]=='/'):
# sintassi sintetica "/", gli aggiungo il prefisso assoluto
template = page.title() + template
templatePage = wikipedia.Page(self.mysite,template)
if (templatePage.namespace() == 2 and templatePage.title()!=page.title()):
if (self.deleteinPage(templatePage,imageEliminare)):
trovato2 = True
if (trovato2):
trovata = True
return trovata
def deleteImage(self,page,imageEliminare):
"""
Cancella l'immagine dalla pagina specificata e ritorna True o False
se l'operazione è riuscita o meno.
"""
# editabile?
if not page.canBeEdited():
stringa = u'\03{lightyellow}La pagina \03{lightred}%s\03{lightyello} è bloccata, salto\03{lightyellow}' % page.title()
wikipedia.output(stringa)
return False
# ask
if not self.acceptAll:
choice = wikipedia.inputChoice(u'Elimino l\'immagine %s dalla pagina %s?' % (imageEliminare,page.title()), ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
if choice in ['a', 'A']:
self.acceptAll = True
if self.acceptAll or choice in ['y', 'Y']:
# do it!
if self.verbose:
wikipedia.output('Cerco l\'immagine \03{lightblue}%s\03{default}' % imageEliminare)
# converti il nome dell'immagine in modo che sia usabile come regex
imageEliminareR = imageName2regex(imageEliminare)
# regex che trova tipo [[Immagine:mia_immagine|...]]
regex1 = re.compile(self.preRegexImmagine1 % imageEliminareR)
# regex che trova le gallerie (trova solo un'immagine per
# volta, quindi deve essere reiterata ==> FIX REGEX
regex2 = re.compile(self.preRegexImmagine2 % imageEliminareR)
# force=True, altrimenti è possibile che non ricarichi la pagina
# perché l'ha già fatto in precedenza, ma la pagina potrebbe essere
# cambiata quando ci sono più immagini diverse da togliere
try:
oldtext = page.get(force = True)
except wikipedia.IsRedirectPage:
string = u'\03{lightyellow}La pagina \03{lightred}%s\03{lightyellow} è un REDIRECT ==> SALTO\03{default}' % page.title()
wikipedia.output(string)
return False
text = oldtext
# applica prima regex
text = regex1.sub(self.immagineSostituta(imageEliminare),text)
# applica seconda regex iterando
textnew = regex2.sub(self.immagineSostituta(imageEliminare,gallery=True),text)
while (textnew!=text):
text = textnew
textnew = regex2.sub(self.immagineSostituta(imageEliminare,gallery=True),text)
# controllo finale
if (text==oldtext):
stringa = u'\03{lightyellow}Non trovo l\'immagine\03{default}'
wikipedia.output(stringa)
return False
wikipedia.setAction(self.messageEliminaImmagine % imageEliminare)
page.put(text, minorEdit = False)
return True
# sicurezza
return False
def avvisoFatto(self,page,imageEliminare):
"""
Cambia l'avviso per l'immagine specificata che era in_corso in fatto
"""
self.avvisoCambiaStato(page,imageEliminare,self.fattoStr)
def avvisoRimosso(self,page,imageEliminare):
"""
Cambia l'avviso per l'immagine specificata che era in_corso in rimosso
"""
self.avvisoCambiaStato(page,imageEliminare,self.rimossoStr)
def avvisoCambiaStato(self,page,imageEliminare,nuovoStato):
if not self.acceptAll:
choice = wikipedia.inputChoice(u'Modifico pagina %s per l\'immagine %s? Nuovo stato: %s' % (page.title(),imageEliminare,nuovoStato), ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
if choice in ['a', 'A']:
self.acceptAll = True
if self.acceptAll or choice in ['y', 'Y']:
regex = self.regexAvviso
text = page.get()
avvisi = regex.finditer(text)
trovato = False
for avviso in avvisi:
image = avviso.group(1)
if (image==imageEliminare):
trovato = True
nuovoAvviso = avviso.group(0)
nuovoAvviso = nuovoAvviso.replace(self.incorsoStr,nuovoStato)
text = text[:avviso.start()] + nuovoAvviso + text[avviso.end():]
if (trovato):
wikipedia.setAction(u'Bot:Cambio stato per immagine %s: %s' %(imageEliminare,nuovoStato))
page.put(text, minorEdit = False)
else:
stringa = u'\03{lightyellow}PROBLEMA: NON RIESCO A CAMBIARE STATO IN PAGINA %s PER IMMAGINE %s\03{default}' %(page.title(),imageEliminare)
wikipedia.output(stringa)
def trovaImmaginiSegnalate(self,page):
"""
Apre la pagina di discussione e restituisce la lista delle immagini i
cui avvisi sono scaduti
"""
immaginiTrovate = []
if self.verbose:
wikipedia.output(u'Controllo gli avvisi in %s' % page.title())
text = page.get()
regex = self.regexAvviso
match = regex.finditer(text)
if (not match):
return []
for item in match:
immagineTrovata = item.group(1)
scadenza = item.group(2)
dataScadenza = date(*(strptime(scadenza, formatoData)[:3]))
stato = item.group(3)
if (stato == self.incorsoStr):
if (scaduto(scadenza)):
immaginiTrovate.append(immagineTrovata)
wikipedia.output('Trovata immagine \03{lightblue}%s\03{default} da controllare' % immagineTrovata)
else:
wikipedia.output(u'Non ancora scaduto %s' % immagineTrovata)
else:
wikipedia.output(u'Non è più in corso %s' % immagineTrovata)
return immaginiTrovate
class ImmaginiUtenteRobot:
def __init__(self,genImages, acceptAll = False, ultimatumGiorni = 7, verbose = True):
"""
Questo bot cicla sulle immagini presenti nel generatore. Se trova un
utente che include l'immagine lo segnala. Se l'avviso era già presente
ed è scaduto rimuove l'immagine usando l'altro bot
"""
self.mysite = wikipedia.getSite()
self.genImages = genImages
self.ultimatumGiorni = ultimatumGiorni
self.templateNamespaceName = self.mysite.template_namespace()
self.fattoStr = 'fatto'
self.rimossoStr = 'rimosso'
self.incorsoStr = 'in_corso'
self.manualeStr = 'manuale'
self.avviso = u'\n\n{{EDP Pagina Utente|%s|data_eliminazione=%s|stato=' + self.incorsoStr + '}}messaggio automatico del bot ~~~~'
self.acceptAll = acceptAll
self.verbose = verbose
self.compileRegex()
self.fratelloCattivo = ImmaginiUtenteRobotCattivo(None, acceptAll, ultimatumGiorni, verbose)
def compileRegex(self):
self.regexTrovaUtente = re.compile(u'[^/]+')
self.regexAvviso = re.compile(rAvviso)
def trovaUtente(self,titolo):
regex = self.regexTrovaUtente
match = regex.search(titolo)
if (match):
return match.group(0)
return None
def isPrincipal(self,page):
"""
Restituisce True se il titolo non è quello di una sottopagina.
Utente:utente -> True Utente:utente/sottopagina -> False
"""
titolo = page.titleWithoutNamespace()
if (titolo.find('/')==-1):
return True
else:
return False
def scadenza(self):
"""
Ritorna la data della scadenza da oggi in formato stringa
"""
delta = timedelta(days=self.ultimatumGiorni)
scadenza = date.today() + delta
return scadenza.strftime(formatoData)
def decidiMettereAvviso(self,page,text,immagine):
if (text == ''):
text = page.get()
regex = self.regexAvviso
match = regex.finditer(text)
if (not match):
return True
metto = True
for item in match:
immagineTrovata = item.group(1)
scadenza = item.group(2)
dataScadenza = date(*(strptime(scadenza, formatoData)[:3]))
stato = item.group(3)
if (immagineTrovata == immagine):
if (stato==self.incorsoStr):
metto = False
if (scaduto(scadenza)):
wikipedia.output('L\'avviso trovato è scaduto, \03{lightred}elimino l\'immagine\03{default}')
pageUtente = trovaPaginaUtente(page)
if (not self.fratelloCattivo.doinPage(pageUtente,immagine)):
stringa = u'\03{lightyellow}ERRORE: è stato segnalato che nella pagina c\'è l\'immagine ma non la trova\03{default}'
wikipedia.output(stringa)
elif (stato==self.fattoStr or stato==self.rimossoStr):
string = u'\03{lightyellow}L\'utente sta facendo il furbo oppure è recidivo per l\'immagine \03{lightred}%s\03{lightyellow}. CONTROLLA MANUALMENTE\03{default}' % immagine
wikipedia.output(string)
elif (stato==self.manualeStr):
metto = False
return metto
def marchiaUtente(self,utente,immagine):
pageDiscussione = wikipedia.Page(self.mysite,userDiscussionNamespaceName+ ':' + utente)
try:
text = pageDiscussione.get()
if not pageDiscussione.canBeEdited():
string = u'\03{lightyellow}Pagina \03{lightred}%s\03{lightyellow} bloccata ==> SALTO\03{default}' % pageDiscussione.title()
wikipedia.output(string)
return
except wikipedia.NoPage:
string = u'\03{lightyellow}Pagina \03{lightred}%s\03{lightyellow} non trovata ==> SALTO\03{default}' % pageDiscussione.title()
wikipedia.output(string)
return
except wikipedia.IsRedirectPage:
string = u'\03{lightyellow}La pagina \03{lightred}%s\03{lightyellow} è un REDIRECT ==> SALTO\03{default}' % pageDiscussione.title()
wikipedia.output(string)
return
if (self.decidiMettereAvviso(pageDiscussione,text,immagine)):
if not self.acceptAll:
choice = wikipedia.inputChoice(u'L\'%s:%s ha l\'%s, segnalo?' % (userNamespaceName,utente,immagine), ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
if choice in ['a', 'A']:
self.acceptAll = True
if self.acceptAll or choice in ['y', 'Y']:
if self.verbose:
wikipedia.output('Segnalo all\'utente %s la presenza dell\'immagine %s' % (utente,immagine))
text += self.avviso % (immagine,self.scadenza())
wikipedia.setAction('Bot: segnalo presenza immagine [[%s]]' % immagine)
pageDiscussione.put(text, minorEdit = False)
else:
wikipedia.output('Non metto avviso per l\'immagine %s' % immagine)
def run(self):
for image in self.genImages:
# preleva le pagine che includono direttamente o indirettamente
# tramite altre pagine l'immagine
genUser = pagegenerators.FileLinksGenerator(image)
# le pagine devono essere pagine utente -> filtra namespace
genUser = pagegenerators.NamespaceFilterPageGenerator(genUser,[2])
for paginaUtente in genUser:
stringa = u'\03{lightpurple} >>> %s <<<\03{default}' % paginaUtente.title()
wikipedia.output(stringa)
utente = self.trovaUtente(paginaUtente.titleWithoutNamespace())
if (not utente):
stringa = u'\03{lightyellow}ERRORE: NON RIESCO A RISALIRE ALLA PAGINA UTENTE\03{default}'
wikipedia.output(stringa)
continue
if (self.isPrincipal(paginaUtente)):
# solo se la pagina è quella principale si avvisa l'utente,
# altrimenti si genererebbero avvisi duplicati. Quindi
# l'utente viene avvisato solo se l'immagine compare,
# nel senso che si vede, nella sua pagina principale. Se
# l'immagine è presente in una sottopagina, ma questa non è
# inclusa (anche indirettamente) nella pagina principale non
# viene segnalata
self.marchiaUtente(utente,image.title())
def main():
doImmagini = False
doUtenti = False
acceptAll = False
gen = None
first = ''
templateName = None
pageTitles = []
pageCat = []
ultimatum = 7
verbose = True
# This factory is responsible for processing command line arguments
# that are also used by other scripts and that determine on which pages
# to work on.
genFactory = pagegenerators.GeneratorFactory()
mysite = wikipedia.getSite()
for arg in wikipedia.handleArgs():
if arg == '-images':
doImmagini = True
elif arg == '-users':
doUtenti = True
elif arg.startswith('-template'):
if len(arg) == 9:
templateName = wikipedia.input(u'Inserisci il nome del template:')
else:
templateName = arg[10:]
elif arg.startswith('-page'):
if len(arg) == 5:
pageTitles.append(wikipedia.input(u'Quale voce vuoi controllare?'))
else:
pageTitles.append(arg[6:])
elif arg.startswith('-cat'):
if len(arg) == 4:
pageCat.append(wikipedia.intput(u'Quale categoria vuoi controllare?'))
else:
pageCat = arg[5:]
elif arg.startswith('-first'):
if len(arg) == 6:
first = wikipedia.input(u'Quale deve essere la prima pagina?')
else:
first = arg[7:]
elif arg == '-always':
acceptAll = True
elif arg.startswith('-ultimatum'):
if len(arg) == 10:
ultimatum = int(wikipedia.input(u'Quanto deve essere l\'ultimatum?'))
else:
ultimatum = int(arg[11:])
else:
generator = genFactory.handleArg(arg)
if generator:
gen = generator
else:
wikipedia.output(u'argomento non valido %s' % arg)
if (doImmagini == doUtenti):
# syntax error, show help text from the top of this file
wikipedia.showHelp('elimina_immagini')
wikipedia.stopme()
sys.exit()
if templateName:
gen = pagegenerators.ReferringPageGenerator(wikipedia.Page(mysite, mysite.template_namespace() + ':' + templateName), onlyTemplateInclusion= True)
elif pageTitles:
pages = [wikipedia.Page(mysite, pageTitle) for pageTitle in pageTitles]
gen = iter(pages)
elif pageCat:
cat = catlib.Category(mysite, pageCat)
gen = pagegenerators.CategorizedPageGenerator(cat)
if not gen:
# gen is empty: syntax error, show help text from the top of this file
wikipedia.showHelp('elimina_immagini')
wikipedia.stopme()
sys.exit()
if first:
for page in gen:
# salto le pagine precedenti
if (page.title()==first):
break
if (doImmagini):
# ciclo sulle immagini
gen = pagegenerators.NamespaceFilterPageGenerator(gen,[6])
robot = ImmaginiUtenteRobot(gen, acceptAll, ultimatum, verbose)
robot.run()
if (doUtenti):
# ciclo sugli utenti
# il namespace può anche essere quello delle discussioni (3)
# verranno convertite dal bot
gen = pagegenerators.NamespaceFilterPageGenerator(gen,[2,3])
robot = ImmaginiUtenteRobotCattivo(gen, acceptAll, ultimatum, verbose)
robot.run()
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
