Utente:BimBot/Scripts

Copiate gente, copiate! (Che poi va a fuoco il computer...) :-D

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.

  1. 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:
  2. 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.
  3. 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.
  4. 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.
  5. Responsible use. Any risk arising from the use of information from this website is entirely the responsibility of the user.