Wikipedia

Utente:BimBot/Scripts: differenze tra le versioni

Naviga nella cronologia in modo interattivo
← Differenza precedente
Contenuto cancellato Contenuto aggiunto
VisualeWikitesto
Nessun oggetto della modifica
PAWBot (discussione | contributi)
Bot
12 556 modifiche
m Fix, replaced: <source → <syntaxhighlight (17), </source → </syntaxhighlight (17)
 
(47 versioni intermedie di 6 utenti non mostrate)
Riga 1:
__NEWSECTIONLINK__
Copiate gente, copiate! (<small>Che poi va a fuoco il computer...</small>) :-D
 
== <ttkbd>redirectlinks.py</ttkbd> ==
<sourcesyntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
Line 36 ⟶ 37:
raise wikipedia.IsNotRedirectPage(redirs[0])
destPage = redirs[0].linkedPages()[0]
print wikipedia.output(destPage.title())
for r in redirs:
redirRefPages = r.getReferences()
for ref in redirRefPages:
print wikipedia.output("Correcting links in page: " + ref.title())
oldtext = ref.get()
newtext = oldtext
linkRegexp = "\[\[" + re.escape(r.title()) + "(\|[^]]+)?\]\]"
ptrn = re.compile(linkRegexp, re.IGNORECASE)
linkMatch = re.search(ptrn, newtext)
Line 63 ⟶ 64:
choice = wikipedia.inputChoice(u'Modifico?', ['Yes', 'No'], ['y', 'N'], 'N')
if choice in ['Y', 'y']:
ref.put(newtext, strunicode("Correcting links to redirect: " + r.title()))
 
if __name__ == "__main__":
Line 70 ⟶ 71:
finally:
wikipedia.stopme()
</syntaxhighlight>
</source>
 
== <ttkbd>lonelypages.py</ttkbd> ==
'''Attenzione!''': questo script ha dei problemi con le disambigue.
Prende le pagine da [[Speciale:Lonelypages]], verifica che siano veramente orfane e inserisce l'avviso in quelle che non lo hanno già.
Script spostato [http://www.botwiki.sno.cc/wiki/Python:Lonelypages.py qui].
 
== <kbd>proxyaperti.py</kbd> ==
<source lang="python">
# -*- coding: utf-8 -*-
 
#
# (C) Pietrodn it.wiki
# (C) Filnik it.wiki
# lonelypages.py - version: 1.5
#
 
import wikipedia
import re
from pagegenerators import AllpagesPageGenerator
 
def main():
args = wikipedia.handleArgs()
wikiSite = wikipedia.getSite()
allpages = wikiSite.lonelypages(number = 10000, repeat = True)
allfunction = False
for i in allpages:
if i.isRedirectPage() or i.isDisambig():
continue
refs = i.getReferences()
refsList = list()
for j in refs:
refsList = refsList.append(j)
if len(refsList) > 0:
wikipedia.output("The page isn't orphan...")
continue
elif len(refsList) == 0:
try:
oldtxt = i.get()
except wikipedia.NoPage:
wikipedia.output("%s doesn't exist! Skip.." % i.title())
except wikipedia.IsRedirectPage:
wikipedia.output("%s is a redirect! Skip..." % i.title())
if '{{o}}' in oldtxt.lower() or '{{o|' in oldtxt.lower():
wikipedia.output("The page has already the template!")
continue
else:
newtxt = u'{{O||mese={{subst:CURRENTMONTH}} {{subst:CURRENTYEAR}}}}\n' + oldtxt
print "\t\t>>> %s <<<" % i.title()
wikipedia.showDiff(oldtxt, newtxt)
choice = wikipedia.inputChoice(u'Pagina orfana non segnalata! Posso procedere?', [u'Yes', u'No'], [u'y', u'N'], [u'a', u'A'], ['All', 'all'], u'N')
if choice in [u'A', u'a', 'all', 'All']:
allfunction = True
if choice in [u'Y', u'y']:
try:
i.put(newtxt, u'Bot: Voce orfana, aggiungo template {{O}}')
except wikipedia.EditConflict:
wikipedia.output('Edit Conflict! Skip...')
 
if "__main__" == __name__:
try:
main()
finally:
wikipedia.stopme()
 
</source>
 
== Il mio <tt>benvenuto.py</tt> ==
Da [[Utente:Alfiobot/benvenuto.py]]
<source lang="python">
######################################################
#
# benvenuto.py
#
# Bot per dare il benvenuto agli utenti (sono diventati troppi per farlo a mano...)
#
# Scarica il log dei nuovi utenti (fino ad un limite predefinito) e, per ogni utente
# che ancora non ha pagina di discussione, crea il seguente testo:
#
# {{benvenuto|nome=<nomeutente>}}
#
# Basato sulle librerie pywikipediabot.
 
 
import urllib, re
import wikipedia
 
 
wikipedia.handleArgs()
 
# No. of users to check
limit = 250
 
# URL of the newuser log
url = "http://%s/w/index.php?title=Speciale:Log&type=newusers&user=&page=&limit=%d" % (wikipedia.getSite().hostname(), limit)
 
# Search regular expression to find links like this (and the class attribute is optional too)
#<a href="/w/index.php?title=Discussioni_utente:Urizon9&action=edit" class="new" title="Discussioni utente:Urizon9">Discussione</a>
 
regexp = '</a> \(<a href=\"/w/index.php\?title=Discussioni_utente:(.*?)&amp;action=edit'
 
# Modify user-agent string
class AppURLopener(urllib.FancyURLopener):
version = "Alfiobot/1.0"
urllib._urlopener = AppURLopener()
 
# Modify summary text
wikipedia.setAction("benvenuto")
 
# Read newuser log
print "Getting newuser log (last %d new users)..." % limit
f = urllib.urlopen(url)
text = f.read()
f.close()
 
r = re.compile(regexp, re.UNICODE)
 
# Loop over the newuser log and put welcome messages on empty discussion pages
pos = 0
tutti = False
while 1:
m = r.search(text, pos)
if m == None:
break
pos = m.end()
username = m.group(1)
print "User %s needs welcome" % username
page = u'Discussioni utente:%s' % username
p = wikipedia.Page(wikipedia.getSite(), page)
# Additional check: make a get to prevent the rare case where a discussion page
# is created between the newuser log download and now.
try:
p.get()
except wikipedia.NoPage:
newtext = u'{{benve|nome={{subst:PAGENAME}}|1=--~~~~}}'
wikipedia.showDiff('', newtext)
if not tutti:
choice = wikipedia.inputChoice(u"Vuoi dare il benvenuto all'utente %s?" % username, ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
if choice in ['a', 'A']:
tutti = True
if tutti or choice in ['y', 'Y']:
p.put(newtext)
print u"User OK!"
wikipedia.stopme()
</source>
 
== <tt>proxyaperti.py</tt> ==
Questo script fa semplicemente un edit in una pagina.
In verità serve per scovare i proxy aperti, agendo da sloggati.
Line 224 ⟶ 83:
Utilizzabile solo da personale addestrato ;-)
 
<sourcesyntaxhighlight lang="python">
#! -*- coding: utf-8 -*-
 
Line 239 ⟶ 98:
pagina.put(newtxt)
wikipedia.stopme()
</syntaxhighlight>
</source>
 
== <ttkbd>lavorosporco.py</ttkbd> ==
Questo script serve per aggiornare le [[Progetto:Coordinamento/Statistiche manutenzioni|statistiche del lavoro sporco]].
 
<sourcesyntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
Line 300 ⟶ 159:
finally:
wikipedia.stopme()
</syntaxhighlight>
</source>
 
== <kbd>statistichemanutenzioni.py</kbd> ==
Questo script serve per aggiornare le statistiche manutenzioni dei progetti tematici. Andrebbe generalizzato ed unito con lavorosporco.py.
 
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import re, wikipedia
from catlib import Category
 
def main():
args = wikipedia.handleArgs()
wikiSite = wikipedia.getSite()
categories = { u'Da controllare per copyright - psicologia': 'Controlcopy',
u'Da verificare per enciclopedicità - psicologia': 'Ency',
u'Da aiutare psicologia': 'Aiutare',
u'Pagine orfane - psicologia': 'Orfane',
u'Da controllare psicologia': 'Controllare',
u'Segnalazioni NPOV psicologia': 'NPOV',
u'Voci mancanti di fonti - psicologia': 'Senza fonti',
u'Stub psicologia': 'Stub',
u'Da tradurre - psicologia': 'Tradurre',
u'Da unire - psicologia': 'Unire',
u'Da wikificare psicologia': 'Wikificare',
}
pagina = wikipedia.Page(wikiSite, 'Progetto:Psicologia/Statistiche manutenzioni')
vecchieStatistiche = pagina.get()
for k in categories:
currentCategory = Category(wikiSite, 'Category:' + k)
categoryCount = len(currentCategory.articlesList(recurse=True))
sottopagina = wikipedia.Page(wikiSite, 'Progetto:Psicologia/Statistiche manutenzioni/' + categories[k])
oldtxt = sottopagina.get()
newtxt = str(categoryCount)
wikipedia.showDiff(oldtxt, newtxt)
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No'], ['y', 'N'], 'N')
if choice in ['Y', 'y']:
wikipedia.setAction(u'Conto lavoro sporco')
sottopagina.put(newtxt, "Aggiorno statistiche manutenzioni")
 
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>frazioni.py</kbd> ==
Questo script serve per aggiungere <kbd><nowiki>{{Tmp|Frazione}}</nowiki></kbd> a tutte le frazioni che non contengono il template {{Tl|Frazione}}.
 
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import re, wikipedia, catlib
 
def main():
args = wikipedia.handleArgs()
all = False
frazTemplateRegexp = re.compile("\{\{ *([Tt]emplate: *)?[Ff]razione")
tmpTemplateRegexp = re.compile("\{\{ *([Tt]emplate: *)?[Tt]mp *\| *[Ff]razione")
frazCat = catlib.Category(wikipedia.getSite(), "Categoria:Frazioni comunali italiane")
frazList = frazCat.articles(recurse=True)
for currentFraz in frazList:
try:
oldtxt = currentFraz.get()
except wikipedia.IsRedirectPage:
continue
if (re.search(frazTemplateRegexp, oldtxt) != None) or (re.search(tmpTemplateRegexp, oldtxt) != None):
continue
wikipedia.output(">>>>> " + currentFraz.title() + " <<<<<")
newtxt = "{{Tmp|Frazione}}\n" + oldtxt
wikipedia.showDiff(oldtxt, newtxt)
if not all:
choice = wikipedia.inputChoice(u'Aggiungo la segnalazione di template mancante?', ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
if choice in ['A', 'a']:
all = True
if (choice in ['Y', 'y']) or all:
currentFraz.put(newtxt, unicode("Template Frazione mancante: aggiungo {{Tmp|Frazione}}"))
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>monitoraggioimmagini.py</kbd> ==
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- utf-8 -*-
import wikipedia, catlib, re
 
args = wikipedia.handleArgs()
all = False
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
categoria = catlib.Category(wikipedia.getSite('it', 'wikipedia'), 'Categoria:Progetto:Aree protette/Tabella monitoraggio automatico - immagini nc')
discussioni = categoria.articles()
 
try:
for i in discussioni:
if not i.isTalkPage():
continue
associatedPage = i.toggleTalkPage()
pageText = associatedPage.get()
match = re.search('\[\[(image|immagine):', pageText, re.IGNORECASE)
if match == None:
wikipedia.output(">>>>> " + associatedPage.title() + " <<<<<")
talkText = i.get()
newTalkText = re.sub('\|immagini=\n', '|immagini=d\n', talkText)
wikipedia.showDiff(talkText, newTalkText)
if not all:
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
wikipedia.setAction(u'Non ci sono immagini: valutazione "d"')
i.put(newTalkText)
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>aggiornaCitazioniPP.py</kbd> ==
Script usato per aggiornare le citazioni del giorno sulla pagina principale.
 
<syntaxhighlight lang="python">
#!/usr/bin/python
# -*- coding: utf-8 -*-
import wikipedia
import re, datetime
 
mesi = {1: 'gennaio',
2: 'febbraio',
3: 'marzo',
4: 'aprile',
5: 'maggio',
6: 'giugno',
7: 'luglio',
8: 'agosto',
9: 'settembre',
10: 'ottobre',
11: 'novembre',
12: 'dicembre',
}
 
def main():
args = wikipedia.handleArgs()
all = False
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
pageQuote = wikipedia.Page(wikipedia.getSite(code='it', fam='wikiquote'), "Wikiquote:Archivio delle citazioni del giorno/" + mesi[datetime.datetime.today().month])
originalQuotes = re.search("\{\{ArchivioQotd\}\}\n<!--.*?-->\n*(.*)", pageQuote.get(), re.DOTALL).group(1)
newQuotes = "{{Multiview\n" + re.sub("\*'''\[\[Template:Qotd/.*?\|(\d+)(.*?)\]\]:''' (.*?) \(\[\[(.*?)\]\]\)", "|<!--\\1-->[[Image:cquote1.png|12px]] \\3 [[Image:cquote2.png|12px]] <br /> '''[[q:\\4|\\4]]'''", originalQuotes) + "\n}}"
pagePedia = wikipedia.Page(wikipedia.getSite(code='it', fam='wikipedia'), "Template:Pagina principale/Citazione del giorno/Auto")
if pagePedia.exists():
oldtext = pagePedia.get()
else:
oldtext = ""
wikipedia.showDiff(oldtext, newQuotes)
if not all:
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
pagePedia.put(newQuotes, u"Bot: Aggiorno citazioni da Wikiquote")
 
 
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>numero_voci_vetrina.py</kbd> ==
Aggiorna il template contenente il numero di voci in vetrina.
 
<syntaxhighlight lang="python">
# -*- coding: utf8 -*-
import wikipedia, catlib
 
def main():
args = wikipedia.handleArgs()
all = False
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
vetrinaCat = catlib.Category(wikipedia.getSite('it', 'wikipedia'), "Categoria:Voci in vetrina")
arts = vetrinaCat.articlesList(recurse=False)
newtext = str(len(arts))
wikipedia.output("Numero di voci in vetrina: " + newtext)
page = wikipedia.Page(wikipedia.getSite('it', 'wikipedia'), "Template:Numero voci in Vetrina")
if page.exists():
oldtext = page.get()
else:
oldtext = ""
wikipedia.showDiff(oldtext, newtext)
if not all:
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
page.put(newtext, u"Bot: Aggiorno numero di voci in vetrina")
 
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>codici_autori_fantascienza.py</kbd> ==
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from autorifanta import *
import wikipedia, re, catlib
 
args = wikipedia.handleArgs()
all = False
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
categoria = catlib.Category(wikipedia.getSite('it', 'wikipedia'), 'Categoria:Autori di fantascienza')
voci = categoria.articles(recurse=True)
 
try:
for i in voci:
wikipedia.output(">>>>> " + i.title() + " <<<<<")
nomi = i.title().split(' ')
print nomi
for j in autoriFantascienza:
authorId = None
if nomi[len(nomi)-1].lower() == j[2].lower() and nomi[0].lower() in j[1].lower():
authorId = j[3]
print j
if authorId:
oldText = i.get()
newText = re.sub("== ?[Cc]ollegamenti esterni ?==", "== Collegamenti esterni ==\n{{Catalogo SF|" + str(authorId) + "}}", oldText)
wikipedia.showDiff(oldText, newText)
i = wikipedia.Page(wikipedia.getSite('it', 'wikipedia'), 'Utente:BimBot/Sandbox') # DEBUG
if not all:
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
wikipedia.setAction(u'Inserisco id autore SF')
i.put(newText)
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>articoli_defaultsort.py</kbd> ==
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import re, wikipedia
import pagegenerators
from add_text import add_text
 
def main():
args = wikipedia.handleArgs()
all = False
genFactory = pagegenerators.GeneratorFactory()
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
else:
generator = genFactory.handleArg(currentArgument)
# Check if pages on which the bot should work are specified.
if not generator:
raise NoEnoughData('You have to specify which pages the script has to work on!')
# Main Loop
for i in generator:
attenzioneIo = False # Dubbio su "I" o "An", che possono svolgere diverse funzioni.
titolo = i.title()
wikipedia.output(">>>>> " + titolo + " <<<<<")
nuovoTitolo = re.sub("^(The |A |Il |Lo |La |I |Gli |Le |L'|Uno |Una |Un'|Un )([A-Z0-9].*)", r"{{DEFAULTSORT:\2, \1}}", titolo)
if titolo == nuovoTitolo:
wikipedia.output("Non c'è nessun articolo. Prossima pagina...")
continue
if re.search("^(I |An )", titolo):
attenzioneIo = True
nuovoTitolo = re.sub("[ ']\}\}", "}}", nuovoTitolo) # Toglie spazi, apostrofi...
try:
oldtext = i.get()
except wikipedia.IsRedirectPage:
wikipedia.output(u"%s is a redirect, I'll ignore it." % i.title())
continue
if re.search("\{\{DEFAULTSORT:", oldtext):
wikipedia.output("C'è già un DEFAULTSORT. Prossima pagina...")
continue
newtext = add_text(page = i, addText = nuovoTitolo, putText = False, oldTextGiven = oldtext)[1]
wikipedia.showDiff(oldtext, newtext)
if not all or attenzioneIo:
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
i.put_async(newtext, comment="Aggiungo: " + nuovoTitolo)
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>newsPedia.py</kbd> ==
Prende le ultime notizie da 'news e le sbatte su 'pedia.
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import wikipedia, urllib2, re
 
# Costanti
newsListPage = wikipedia.Page(wikipedia.getSite('it', 'wikinews'), 'Utente:BimBot/RecentNews') # Prende qui le notizie
updatePage = wikipedia.Page(wikipedia.getSite('it', 'wikipedia'), 'Template:Pagina principale/Notizie/Auto') # Dove mette le notizie
 
def pageText(url):
request = urllib2.Request(url)
user_agent = 'BimBot/1.0'
request.add_header("User-Agent", user_agent)
response = urllib2.urlopen(request)
text = response.read()
response.close()
return text
def main():
args = wikipedia.handleArgs()
all = False
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
wikipedia.output(">>>>> " + updatePage.title() + " <<<<<")
try:
oldtext = updatePage.get()
except wikipedia.NoPage:
oldtext = ''
wikipedia.output("Purging input page...")
newsListPage.put(newsListPage.get()) # PURGE
newsListUrl = 'http://' + newsListPage.site().hostname() + newsListPage.site().nice_get_address(newsListPage.title())
try:
htmlText = pageText(newsListUrl)
except urllib2.HTTPError:
try:
wikipedia.output(u"Errore del server. Aspetto 10 secondi... " + time.strftime("%d %b %Y %H:%M:%S (UTC)", time.gmtime()) )
time.sleep(10)
htmlText = pageText(newsListUrl)
except urllib2.HTTPError:
wikipedia.output(u"Errore del server. Chiudo.")
return
divMatch = re.search('(?s)<div id="recentnews">(.*?)</div>', htmlText) # Prendo il blocco che mi interessa
news = re.findall('<li><a .*?>(.*?)</a></li>', divMatch.group(1)) # Array di titoli di notizie
newtext = ''
for i in news:
newtext = newtext + '[[n:' + i + '|' + i + ']] · ' # Formatto il link
newtext = newtext[:len(newtext)-3].decode('utf-8') # Tolgo il pallino alla fine e decodifico
wikipedia.showDiff(oldtext, newtext)
if not all:
choice = wikipedia.inputChoice(u"Aggiorno?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
wikipedia.setAction("Aggiorno notizie da Wikinews")
updatePage.put(newtext)
 
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>copyviolInversi.py</kbd> ==
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import wikipedia, re, catlib
 
# Costanti
site = wikipedia.getSite('it', 'wikipedia')
logPage = wikipedia.Page(site, 'Wikipedia:Copyviol inversi/Segnalazioni/Bot')
archPage = wikipedia.Page(site, 'Wikipedia:Copyviol inversi/Segnalazioni/Archivio/Bot')
copyCat = catlib.Category(site, 'Categoria:Copyviol inversi')
copyTemplate = u'Utente:Marco 27/Sandbox cloni'
logTemplate = u'Utente:Marco 27/Sandbox cloni/2'
def main():
args = wikipedia.handleArgs()
all = False
for currentArgument in args:
if currentArgument.startswith("-always"):
all = True
talkList = copyCat.articles(recurse=True)
logNew = ""
archNew = ""
for i in talkList:
talkText = i.get()
templs = filter((lambda x: x[0]==copyTemplate), i.templatesWithParams()) # Prendo solo i template che mi interessano
for j in templs:
logEntry = '\n' + '{{' + logTemplate + '|pagina=' + i.toggleTalkPage().title() + '|' + str('|').join(j[1]) + '}}'
if re.search("\|esito\s*=\s*(6|7|8|2|3)\s*", logEntry):
archNew += logEntry
else:
logNew += logEntry
# Aggiornamento LOG
wikipedia.output(">>>>> " + logPage.title() + " <<<<<")
try:
logOld = logPage.get()
except wikipedia.NoPage:
logOld = ''
wikipedia.showDiff(logOld, logNew)
if not all:
choice = wikipedia.inputChoice(u"Aggiorno il log?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
wikipedia.setAction("Bot: Aggiorno il log dei presunti [[WP:Copyviol inversi|copyviol inversi]]")
logPage.put(logNew)
# Aggiornamento ARCHIVIO
wikipedia.output(">>>>> " + archPage.title() + " <<<<<")
try:
archOld = archPage.get()
except wikipedia.NoPage:
archOld = ''
wikipedia.showDiff(archOld, archNew)
if not all:
choice = wikipedia.inputChoice(u"Aggiorno l'archivio?", ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
wikipedia.setAction("Bot: Archivio i [[WP:Copyviol inversi|copyviol inversi]]")
archPage.put(archNew)
 
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>importa_asteroidi.py</kbd> ==
<syntaxhighlight lang="python">
# -*- coding: utf-8 -*-
import wikipedia, re, sys, codecs
 
def main():
args = wikipedia.handleArgs()
beginast = args[0]
beginok = False
templatefile = codecs.open("modelloasteroide.txt", "r", "utf-8")
testomodello = templatefile.read()
templatefile.close()
myfile = file(u'MPCORB.DAT')
for theLine in myfile:
if not theLine[0].isdigit(): continue
tupla = adatta(theLine)
if not tupla[31][0].isalpha(): continue
asteroidname = tupla[30] + ' ' + tupla[31]
if (asteroidname != beginast) and (not beginok): continue
beginok = True
print asteroidname
mypage = wikipedia.Page(wikipedia.getSite(), asteroidname)
# mypage = wikipedia.Page(wikipedia.getSite(), u'Utente:BimBot/Sandbox')
if mypage.exists():
continue
oldtxt = u''
newtxt = generatemplate(testomodello, tupla)
wikipedia.showDiff(oldtxt, unicode(newtxt))
print tupla
choice = wikipedia.inputChoice(u"Modificare?", ['Yes', 'No'], ['y', 'N'], 'N')
if choice in [u'Y', u'y']:
wikipedia.setAction(u'Nuovo asteroide')
mypage.put(newtxt)
myfile.close()
wikipedia.stopme()
 
def adatta(txt):
mtch=re.match('^([^ ]*) *(\d+)\.(\d+) *(-?\d+)\.([0-9]+) *([^ ]*) *(\d+)\.(\d+) *(\d+)\.(\d+) *(\d+)\.(\d+) *(\d+)\.(\d+) *(\d+)\.(\d+) *(\d+)\.(\d+) *(\d+)\.(\d+) *\d? *(....? *\d+) *(\d+) *(\d+) *(\d{4})-(\d{4}) *(\d+)\.(\d+) *(M-.) *([^ ]*) *([^ ]*?) *.{4} *\((\d+)\)(.*?) *(\d{8})', txt)
#print txt
grps = mtch.groups()
return grps
#
def generatemplate(modello, tupla):
elencosostituzioni = {
u'#nome': tupla[31],
u'#sottotitolo': tupla[30] + ' ' + tupla[31],
u'#magn_ass': tupla[1]+','+tupla[2],
u'#epoca': tupla[5],
u'#anomalia_media': tupla[6]+','+tupla[7],
u'#argomento_perielio': tupla[8]+','+tupla[9],
u'#nodo_ascendente': tupla[10]+','+tupla[11],
u'#inclinazione_asse_su_eclittica': tupla[12]+','+tupla[13],
u'#eccentricità': tupla[14]+','+tupla[15],
u'#semiasse_maggiore': tupla[18]+','+tupla[19],
u'#data': tupla[23]
}
for k in elencosostituzioni:
modello = re.sub(k, elencosostituzioni[k], modello)
return modello
main()
 
#K07B19V 15.7 0.15 K06CV 19.17898 347.71274 101.16774 10.08579 0.0550460 0.19108058 2.9853254 E2007-B48 13 1 16 days 0.37 MPC 0000 2007 BV19 20070124
</syntaxhighlight>
 
=== <kbd>modello_asteroide.txt</kbd> ===
<pre>
{{S|asteroidi}}
{{Corpo celeste
|tipo = Asteroide
|nome = #nome
|sottotitolo = #sottotitolo
|magn_ass = #magn_ass
|epoca = #epoca
|anomalia_media = #anomalia_media°
|argomento_perielio = #argomento_perielio°
|nodo_ascendente = #nodo_ascendente°
|inclinazione_asse_su_eclittica = #inclinazione_asse_su_eclittica°
|eccentricità = #eccentricità
|semiasse_maggiore = #semiasse_maggiore UA
|data = #data
}}
 
'''#nome''' è un [[asteroide]] del [[sistema solare]]. Scoperto nel [[#data]], presenta un'[[orbita]] caratterizzata da un [[semiasse maggiore]] pari a #semiasse_maggiore [[Unità Astronomica|UA]] e da un'[[eccentricità orbitale|eccentricità]] di #eccentricità, inclinata di #inclinazione_asse_su_eclittica° rispetto all'[[eclittica]].
 
{{Asteroide}}
 
[[Categoria:Asteroidi del sistema solare|#nome]]
</pre>
 
== <kbd>discussioneanonimi3.py</kbd> ==
 
<syntaxhighlight lang="python">
# -*- coding: utf-8 -*-
import wikipedia, re, commands
 
def main():
wikipedia.handleArgs()
talkpages = wikipedia.Page(wikipedia.getSite(), u'Wikipedia:Elenchi generati offline/Discussioni utenti anonimi').linkedPages();
for talk in talkpages:
static=False
if talk.namespace() != 3 or not talk.exists() or not talk.canBeEdited():
continue
wikipedia.output(">>>>> " + talk.title() + " <<<<<")
oldtext = talk.get()
if checkStatic(talk.titleWithoutNamespace()):
newtext = oldtext + u'\n[[Categoria:IP statici]]'
wikipedia.showDiff(oldtext, newtext)
wikipedia.setAction(u'Categorizzo in [[:Categoria:IP statici]]')
talk.put(newtext)
else:
newtext = u'{{BenvenutoIP}}'
match = re.search("\{\{IPcondiviso.*?\}\}", oldtext)
if match != None:
newtext = match.group() + '\n' + newtext
wikipedia.showDiff(oldtext, newtext)
wikipedia.setAction(u'Svuotata pagina ed inserito benvenuto.')
talk.put(newtext)
 
def checkStatic(ip):
response = commands.getoutput("dig -x " + ip + " +short")
wikipedia.output('Dig response: ' + response)
return bool(re.search('[Ss]tatic', response))
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <kbd>prefissiTelefonici.py</kbd> ==
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import wikipedia, pagegenerators, re, catlib
 
note1 = u"<ref>[http://www2.agcom.it/provv/d_8_01_CIR.htm Delibera n. 8/01/CIR]</ref>"
note2 = u"<ref>[http://www.paginebianche.it/prefissi-telefonici?pref=%s Elenco sulle Pagine Bianche]</ref>"
sezioneNote = u"== Note ==\n<references />\n"
 
oggetto = u"Aggiungo le fonti per il prefisso telefonico ([[Wikipedia:Bot/Richieste#Aggiungere_fonte_ai_prefissi_telefonici_italiani|richiesta]])."
 
def main():
all = False
args = wikipedia.handleArgs()
startWith=""
for argh in args:
if argh.startswith("-start:"):
startWith = argh[len("-start:"):]
mySite = wikipedia.getSite(code='it', fam='wikipedia')
cat = catlib.Category(mySite, "Categoria:Prefissi telefonici italiani")
gen = pagegenerators.CategorizedPageGenerator(cat, False, startWith)
for p in gen:
voceOk = 1
try:
oldText = p.get()
except wikipedia.NoPage:
wikipedia.output(currentPage.title() + " does not exist!")
continue
except wikipedia.IsRedirectPage:
p = p.getRedirectTarget()
oldText = p.get()
# Per sicurezza se non esegue tutti i match salta la voce
if re.search("== ?[Nn]ote ?==", oldText):
continue
# Ottengo il prefisso "nudo" dal titolo
m = re.match("^(\d+)", p.title());
if m == None:
continue
prefisso = m.group(1)
newText = oldText
# Sostituzione 1
m = re.subn(r"il \[\[prefisso telefonico\]\] del \[\[distretto telefonico\|distretto\]\] di \[\[(.*?)\]\],",
r"il [[prefisso telefonico]] del [[distretto telefonico|distretto]] di [[\1]]" + note1 + ",",
newText, 1)
if m[1]==0:
continue
else:
newText = m[0]
# Sostituzione 2
m = re.subn(r"Il distretto di (.*?) comprende (.*?)\.\s+\{\{[Cc]ompartimento",
r'Il distretto di \1 comprende \2 ' + note2 % prefisso + ".\n\n" + sezioneNote + "\n{{Compartimento",
newText, 1)
if m[1]==0:
continue
else:
newText = m[0]
# Sostituzione 3
newText = re.sub("\{\{[Ff](\|.*?)\}\}\s+", "", newText, 1)
# Visualizza le differenze, chiede e salva
wikipedia.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
% p.title())
wikipedia.showDiff(oldText, newText)
if not all:
choice = wikipedia.inputChoice(u"Modificare?",
['Yes', 'No', 'All', "Quit"],
['y', 'N', 'a', 'q'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
p.put_async(newText, minorEdit=False, comment=oggetto)
elif choice in ['Q', 'q']:
return
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== <code>vocicorrelate.py</code> ==
 
<syntaxhighlight lang="python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Lo script rimuove i piped links e i corsivi dai link nelle "Voci correlate".
# Si lancia con gli argomenti supportati da pagegenerators.py
#
# Esempi:
# $ python vocicorrelate.py -catr:Informatica
# $ python vocicorrelate.py -start:!
#
# Autore: Pietrodn
 
import wikipedia, pagegenerators, re
 
oggetto = u"Uniformo le [[Aiuto:Voci correlate|voci correlate]]"
 
def main():
all = False
args = wikipedia.handleArgs()
genf = pagegenerators.GeneratorFactory();
for argh in args:
genf.handleArg(argh)
mySite = wikipedia.getSite(code='it', fam='wikipedia')
gen = genf.getCombinedGenerator()
if not gen:
return
for p in gen:
try:
oldText = p.get()
except wikipedia.NoPage:
wikipedia.output(currentPage.title() + " does not exist!")
continue
except wikipedia.IsRedirectPage:
p = p.getRedirectTarget()
oldText = p.get()
newText = oldText
# Cerco il contenuto della sezione voci correlate:
# inizia dal titolo di sezione e finisce alla prima riga che non inizia con un punto elenco
m = re.search(r"(?s)==\s*[Vv]oci correlate\s*==(.*?)\n[^*]", oldText)
# Niente "voci correlate"? Passo alla prossima voce
if not m:
continue
vcorrTextOld = m.group(1)
vcorrText = vcorrTextOld
# Tolgo il corsivo
vcorrText = re.sub(r"''\[\[(.*?)\]\]''", r"[[\1]]", vcorrText);
# Tolgo i piped link
vcorrText = re.sub(r"\[\[(.*?)\|(.*?)\]\]", r"[[\1]]", vcorrText);
# Se non ho effettuato modifiche nella sezione "voci correlate", avanti alla prossima voce
if vcorrText == vcorrTextOld:
continue
# Re-innesto la sezione voci correlate al suo posto nella voce
newText = re.sub(r"(?s)==\s*[Vv]oci correlate\s*==(.*?)(\n[^*])", r"== Voci correlate ==" + vcorrText + r"\2", oldText)
# Visualizza le differenze, chiede e salva
wikipedia.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
% p.title())
wikipedia.showDiff(oldText, newText)
if not all:
choice = wikipedia.inputChoice(u"Modificare?",
['Yes', 'No', 'All', "Quit"],
['y', 'N', 'a', 'q'], 'N')
else:
choice = 'y'
if choice in ['A', 'a']:
all = True
choice = 'y'
if choice in ['Y', 'y']:
p.put_async(newText, minorEdit=True, comment=oggetto)
elif choice in ['Q', 'q']:
return
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
</syntaxhighlight>
 
== Eliminazione parametro "Stato" dal [[Template:Edificio religioso]] ==
 
Codice da inserire in <kbd>user-fixes.py</kbd>:
 
<syntaxhighlight lang="python">
import re
 
def EdRel(match):
# Le parentesi devono essere bilanciate, e le prime parentesi graffe trovate non devono essere chiuse
aperte = re.findall(ur'\{\{', match.group(1))
chiuse = re.findall(ur'\}\}', match.group(1))
if (len(aperte) == len(chiuse)) and (not re.match("(?s)[^{}]*\}\}.*", match.group(1))):
return ur"{{Edificio religioso" + match.group(1)
else:
return match.group() # Unchanged
fixes['EdificioReligioso'] = {
'regex': True,
'msg': {
'_default':u'Eliminazione parametro obsoleto del [[Template:Edificio religioso]] ([[Wikipedia:Bot/Richieste#Eliminazione_campo_dal_template_.22Edificio_religioso.22|richiesta]])',
},
'replacements': [
(ur"(?s)\{\{\s*[Ee]dificio[ _]religioso(.*?)\|\s*[Ss]tato\s*=\s*([^|\n]*)\n", EdRel),
],
'exceptions': {
'inside-tags': ['comment', 'header', 'pre', 'source', 'ref', 'table', 'hyperlink', 'gallery', 'link', 'interwiki' ],
}
}
</syntaxhighlight>
Aggiungi argomento
Estratto da "https://it.wikipedia.org/wiki/Utente:BimBot/Scripts"