Utente:BimBot/Scripts
Copiate gente, copiate! (Che poi va a fuoco il computer...) :-D
redirectlinks.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#################################################################################################
# #
# redirectlinks.py #
# #
# This script corrects links to a redirect. #
# #
# Syntax: redirectlinks.py [options] #
# Options: -dest:Destpage #
# It gets all redirects which link to Destpage and corrects their references. #
# #
# -page:Redirpage #
# It corrects all the references of the specified redirect. #
# #
# You must specify the -page OR the -dest option. #
# #
#################################################################################################
import re, wikipedia
def main():
args = wikipedia.handleArgs()
for argh in args:
if argh.startswith("-dest:"):
destPage = wikipedia.Page(wikipedia.getSite(), argh[6:])
redirs = destPage.getReferences(redirectsOnly = True)
if argh.startswith("-page:"):
redirs = [wikipedia.Page(wikipedia.getSite(), argh[6:])]
if not redirs[0].isRedirectPage():
raise wikipedia.IsNotRedirectPage(redirs[0])
destPage = redirs[0].linkedPages()[0]
wikipedia.output(destPage.title())
for r in redirs:
redirRefPages = r.getReferences()
for ref in redirRefPages:
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)
while linkMatch != None:
oldLink = newtext[linkMatch.start():linkMatch.end()]
afterLink = linkMatch.group(1)
if afterLink == None:
afterLink = ""
newLink = re.sub(linkRegexp, "[[" + destPage.title() + afterLink + "]]", oldLink)
choice = wikipedia.inputChoice("Replacing link " + oldLink + " to " + newLink + ".\nDo you want to change the link?", ["Accept", "Change"], ['a', 'c'], 'a')
if choice in ['C', 'c']:
linkText = wikipedia.input("Insert link (without square brackets): [[" + destPage.title())
newLink = "[[" + destPage.title() + linkText + "]]"
newtext = newtext[:linkMatch.start()] + newLink + newtext[linkMatch.end():]
linkMatch = re.search(ptrn, newtext)
wikipedia.showDiff(oldtext, newtext)
choice = wikipedia.inputChoice(u'Modifico?', ['Yes', 'No'], ['y', 'N'], 'N')
if choice in ['Y', 'y']:
ref.put(newtext, unicode("Correcting links to redirect: " + r.title()))
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
lonelypages.py
Prende le pagine da Speciale:Lonelypages, verifica che siano veramente orfane e inserisce l'avviso in quelle che non lo hanno già. Script spostato qui.
proxyaperti.py
Questo script fa semplicemente un edit in una pagina. In verità serve per scovare i proxy aperti, agendo da sloggati. Occorre però crackare wikipedia.py. Utilizzabile solo da personale addestrato ;-)
#! -*- coding: utf-8 -*-
import wikipedia
args = wikipedia.handleArgs()
pagina = wikipedia.Page(wikipedia.getSite(), args[0])
oldtxt = pagina.get()
newtxt = oldtxt + '\nSono un vandalo malvagissimo. Non bloccatemi. --~~~~'
wikipedia.showDiff(oldtxt, newtxt)
choice = wikipedia.inputChoice('Posso procedere?', ['Yes', 'No'], ['y', 'N'], 'N')
if choice in ['Y', 'y']:
wikipedia.setAction('Bot anonimo per individuare proxy aperti firmato Pietrodn. Non bloccare please.')
pagina.put(newtxt)
wikipedia.stopme()
lavorosporco.py
Questo script serve per aggiornare le statistiche del lavoro sporco.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import re, wikipedia
from templatecount import TemplateCountRobot
def main():
args = wikipedia.handleArgs()
wikiSite = wikipedia.getSite()
counter = TemplateCountRobot()
templates = { 'A': 'Aiutare',
'C': 'Controllare',
'Categorizzare': 'Da categorizzare',
'Controlcopy': 'Controlcopy',
'E': 'Ency',
'O': 'Orfane',
'P': 'NPOV',
'Senzafonti': 'Senza fonti',
'S': 'Stub',
'T': 'Tradurre',
'U': 'Unire',
'W': 'Wikificare',
}
pagina = wikipedia.Page(wikiSite, 'Progetto:Coordinamento/Statistiche manutenzioni')
vecchieStatistiche = pagina.get()
templateCountDict = counter.countTemplates(templates.keys(), None)
for k in templateCountDict:
sottopagina = wikipedia.Page(wikiSite, 'Progetto:Coordinamento/Statistiche manutenzioni/' + templates[k])
oldtxt = sottopagina.get()
newtxt = re.sub("</noinclude>.*", "</noinclude>" + str(templateCountDict[k]), oldtxt)
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)
findRegexp = "\d+:\d+, \d+ .{3} \d+ \(.*?\)"
replaceRegexp = "~~~~~"
nuoveStatistiche = re.sub(findRegexp, replaceRegexp, vecchieStatistiche)
wikipedia.showDiff(vecchieStatistiche, nuoveStatistiche)
choice = wikipedia.inputChoice(u"Aggiorno le date?", ['Yes', 'No'], ['y', 'N'], 'N')
if choice in ['Y', 'y']:
wikipedia.setAction(u'Aggiorno le date del conto')
pagina.put(nuoveStatistiche)
if __name__ == "__main__":
try:
main()
finally:
wikipedia.stopme()
statistichemanutenzioni.py
Questo script serve per aggiornare le statistiche manutenzioni dei progetti tematici. Andrebbe generalizzato ed unito con lavorosporco.py.
#!/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()
frazioni.py
Questo script serve per aggiungere {{Tmp|Frazione}} a tutte le frazioni che non contengono il template {{Frazione}}.
#!/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()
monitoraggioimmagini.py
#!/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()
aggiornaCitazioniPP.py
Script usato per aggiornare le citazioni del giorno sulla pagina principale.
#!/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()
numero_voci_vetrina.py
Aggiorna il template contenente il numero di voci in vetrina.
# -*- 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()
codici_autori_fantascienza.py
#!/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()
articoli_defaultsort.py
#!/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()
newsPedia.py
Prende le ultime notizie da 'news e le sbatte su 'pedia.
#!/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()
copyviolInversi.py
#!/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()
importa_asteroidi.py
# -*- 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
modello_asteroide.txt
{{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]]
discussioneanonimi3.py
# -*- 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()
prefissiTelefonici.py
#!/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()
vocicorrelate.py
#!/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()
Eliminazione parametro "Stato" dal Template:Edificio religioso
Codice da inserire in user-fixes.py:
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' ],
}
}
Content Disclaimer
Informasi ini disarikan dari Wikipedia dan disajikan kembali untuk tujuan edukasi. Konten tersedia di bawah lisensi CC BY-SA 3.0. Kami tidak bertanggung jawab atas ketidakakuratan data yang bersumber dari kontribusi publik tersebut.
- The information displayed on this website is sourced in part or in whole from Wikipedia and has been adapted for the purpose of restating it. We strive to provide accurate and relevant information, however:
- There is no guarantee of absolute accuracy. Wikipedia is an open, collaborative project that can be edited by anyone, so information is subject to change.
- It is not intended to constitute professional advice. The content displayed is for informational and educational purposes only. For important decisions (e.g., medical, legal, or financial), please consult a professional.
- Content copyright. Wikipedia is licensed under the Creative Commons Attribution-ShareAlike License (CC BY-SA). This means that content may be reused with appropriate attribution and shared under a similar license.
- Responsible use. Any risk arising from the use of information from this website is entirely the responsibility of the user.