Revision: 6256
Author: russblau
Date: 2009-01-14 15:17:47 +0000 (Wed, 14 Jan 2009)
Log Message:
-----------
Branch for port to rewrite
Added Paths:
-----------
branches/rewrite/pywikibot/scripts/solve_disambiguation.py
Copied: branches/rewrite/pywikibot/scripts/solve_disambiguation.py (from rev 6255,
trunk/pywikipedia/solve_disambiguation.py)
===================================================================
--- branches/rewrite/pywikibot/scripts/solve_disambiguation.py
(rev 0)
+++ branches/rewrite/pywikibot/scripts/solve_disambiguation.py 2009-01-14 15:17:47 UTC
(rev 6256)
@@ -0,0 +1,1012 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+"""
+Script to help a human solve disambiguations by presenting a set of options.
+
+Specify the disambiguation page on the command line, or enter it at the
+prompt after starting the program. (If the disambiguation page title starts
+with a '-', you cannot name it on the command line, but you can enter it at
+the prompt.) The program will pick up the page, and look for all
+alternative links, and show them with a number adjacent to them. It will
+then automatically loop over all pages referring to the disambiguation page,
+and show 30 characters of context on each side of the reference to help you
+make the decision between the alternatives. It will ask you to type the
+number of the appropriate replacement, and perform the change.
+
+It is possible to choose to replace only the link (just type the number) or
+replace both link and link-text (type 'r' followed by the number).
+
+Multiple references in one page will be scanned in order, but typing 'n' (next)
+on any one of them will leave the complete page unchanged. To leave only some reference
unchanged, use the 's' (skip) option.
+
+Command line options:
+
+ -pos:XXXX adds XXXX as an alternative disambiguation
+
+ -just only use the alternatives given on the command line, do not
+ read the page for other possibilities
+
+ -primary "primary topic" disambiguation (Begriffsklärung nach Modell 2).
+ That's titles where one topic is much more important, the
+ disambiguation page is saved somewhere else, and the important
+ topic gets the nice name.
+
+ -primary:XY like the above, but use XY as the only alternative, instead of
+ searching for alternatives in [[Keyword (disambiguation)]].
+ Note: this is the same as -primary -just -pos:XY
+
+ -file:XYZ reads a list of pages from a text file. XYZ is the name of the
+ file from which the list is taken. If XYZ is not given, the user is asked
for a filename.
+ Page titles should be inside [[double brackets]].
+ The -pos parameter won't work if -file is used.
+
+ -always:XY instead of asking the user what to do, always perform the same
+ action. For example, XY can be "r0", "u" or
"2". Be careful with
+ this option, and check the changes made by the bot. Note that
+ some choices for XY don't make sense and will result in a loop,
+ e.g. "l" or "m".
+
+ -main only check pages in the main namespace, not in the talk,
+ wikipedia, user, etc. namespaces.
+
+ -start:XY goes through all disambiguation pages in the category on your wiki
+ that is defined (to the bot) as the category containing disambiguation
+ pages, starting at XY. If only '-start' or '-start:' is
given, it starts
+ at the beginning.
+
+ -min:XX (XX being a number) only work on disambiguation pages for which
+ at least XX are to be worked on.
+
+To complete a move of a page, one can use:
+
+ python solve_disambiguation.py -just -pos:New_Name Old_Name
+"""
+#
+# (C) Rob W.W. Hooft, 2003
+# (C) Daniel Herding, 2004
+# (C) Andre Engels, 2003-2004
+# (C) WikiWichtel, 2004
+#
+# Distributed under the terms of the MIT license.
+#
+__version__='$Id$'
+#
+# Standard library imports
+import re, sys, codecs
+
+# Application specific imports
+import wikipedia, pagegenerators, editarticle
+
+# Summary message when working on disambiguation pages
+msg = {
+ 'ar': u'توضيح بمساعدة روبوت: %s - غير الوصلة أو الوصلات إلى %s',
+ 'cs': u'Odstranění linku na rozcestník [[%s]] s použitím robota -
Změněn(y) odkaz(y) na %s',
+ 'en': u'Robot-assisted disambiguation: %s - Changed link(s) to %s',
+ 'es': u'Bot:Desambiguación asistida: %s - Cambiando enlace(s) para
%s',
+ 'da': u'Retter flertydigt link til: %s - Ændrede link(s) til %s',
+ 'de': u'Bot-unterstützte Begriffsklärung: %s - Link(s) ersetzt durch
%s',
+ 'fi': u'Täsmennystä botin avulla: %s korvattiin link(e)illä %s',
+ 'fr': u'Homonymie résolue à l\'aide du robot: %s - Modifications du
(des) lien(s) pour %s',
+ 'he': u'תיקון קישור לדף פירושונים באמצעות בוט: %s',
+ 'hu': u'Bottal végzett egyértelműsítés: %s –> %s',
+ 'ia': u'Disambiguation assistite per robot: %s - Changed link(s) to
%s',
+ 'it': u'Sistemazione automatica della disambigua: %s - Inversione di
redirect %s',
+ 'lt': u'Nuorodų į nukrepiamąjį straipsnį keitimas: %s - Pakeistos
nuorodos į %s',
+ 'kk': u'Айрықты мағыналарды бот көмегімен шешу: %s - Changed link(s) to
%s',
+ 'ko': u'로봇의 도움을 받아 동음이의 처리 : [[%s]] - %s 문서로 링크 걸음',
+ 'nl': u'Robot-geholpen doorverwijzing: [[%s]] - Link(s) veranderd naar
%s',
+ 'no': u'bot: Retter lenke til peker: %s - Endret lenke(r) til %s',
+ 'pl': u'Wspomagane przez robota ujednoznacznienie: %s - Zmieniono link(i)
%s',
+ 'pt': u'Desambiguação assistida por bot: %s link(s) mudado(s) para
%s',
+ 'ru': u'Разрешение значений с помощью бота: %s - Changed link(s) to
%s',
+ 'sr': u'Решавање вишезначних одредница помоћу бота: %s - Changed link(s)
to %s',
+ 'sv': u'Länkar direkt till rätt artikel för: %s - Bytte länk(ar) till
%s',
+ }
+
+# Summary message when working on disambiguation pages and the link is removed
+msg_unlink = {
+ 'ar': u'توضيح بمساعدة روبوت: %s - أزال الوصلة أو الوصلات.',
+ 'cs': u'Odstranění linku na rozcestník [[%s]] s použitím robota -
Odstraněn(y) odkaz(y)',
+ 'en': u'Robot-assisted disambiguation: %s - Removed link(s).',
+ 'da': u'Retter flertydigt link til: %s - Fjernede link(s)',
+ 'de': u'Bot-unterstützte Begriffsklärung: %s - Link(s) entfernt',
+ 'fi': u'Täsmennystä botin avulla: %s - poistettiin linkkejä.',
+ 'fr': u'Homonymie résolue à l\'aide du robot: %s - Retrait du (des)
lien(s)',
+ 'he': u'הסרת קישור לדף פירושונים באמצעות בוט: %s',
+ 'hu': u'Bottal végzett egyértelműsítés: %s – hivatkozások
eltávolítása',
+ 'ia': u'Disambiguation assistite per robot: %s - Removed link(s).',
+ 'it': u'Sistemazione automatica della disambigua: %s - Collegamenti
rimossi',
+ 'lt': u'Nuorodų į nukrepiamąjį straipsnį keitimas: %s - Pašalintos
nuorodos',
+ 'kk': u'Айрықты мағыналарды бот көмегімен шешу: %s - Removed
link(s).',
+ 'ko': u'로봇의 도움을 받아 동음이의 처리: [[%s]] - 링크 제거',
+ 'nl': u'Robot-geholpen doorverwijzing: [[%s]] - Link(s)
weggehaald.',
+ 'no': u'bot: Retter lenke til peker: %s - Fjernet lenke(r)',
+ 'pl': u'Wspomagane przez robota ujednoznacznienie: %s - Usunięto
link(i)',
+ 'pt': u'Desambiguação assistida por bot: %s link(s) removido(s)',
+ 'ru': u'Разрешение значений с помощью бота: %s - Removed link(s)',
+ 'sr': u'Решавање вишезначних одредница помоћу бота: %s - Removed
link(s)',
+ 'sv': u'Länkar direkt till rätt artikel för: %s - Tog bort
länk(ar)',
+ }
+
+# Summary message when working on redirects
+msg_redir = {
+ 'ar': u'توضيح بمساعدة روبوت: %s - غير الوصلة أو الوصلات إلى %s',
+ 'cs': u'Robot opravil přesměrování na %s - Změněn(y) odkaz(y) na
%s',
+ 'en': u'Robot-assisted disambiguation: %s - Changed link(s) to %s',
+ 'da': u'Retter flertydigt link til: %s - Ændrede link(s) til %s',
+ 'de': u'Bot-unterstützte Redirectauflösung: %s - Link(s) ersetzt durch
%s',
+ 'fi': u'Täsmennystä botin avulla: %s korvattiin link(e)illä %s',
+ 'fr': u'Correction de lien vers redirect: %s - Modifications du (des)
lien(s) pour %s',
+ 'he': u'תיקון קישור לדף פירושונים באמצעות בוט: %s שונה ל%s',
+ 'hu': u'Bottal végzett egyértelműsítés: %s –> %s',
+ 'ia': u'Resolution de redirectiones assistite per robot: %s - Changed
link(s) to %s',
+ 'it': u'Sistemazione automatica del redirect: %s - Inversione di redirect
%s',
+ 'lt': u'Nuorodų į peradresavimo straipsnį keitimas: %s - Pakeistos
nuorodos į %s',
+ 'kk': u'Айрықты мағыналарды бот көмегімен шешу: %s - Changed link(s) to
%s',
+ 'ko': u'로봇의 도움을 받아 동음이의 처리: [[%s]] - %s 문서로 링크 걸음',
+ 'nl': u'Robot-geholpen redirect-oplossing: [[%s]] - Link(s) veranderd
naar %s',
+ 'no': u'bot: Endrer omdirigeringslenke: %s - Endret lenke(r) til
%s',
+ 'pl': u'Wspomagane przez robota ujednoznacznienie: %s - Zmieniono link(i)
%s',
+ 'pt': u'Desambiguação assistida por bot: %s link(s) mudados para
%s',
+ 'ru': u'Разрешение значений с помощью бота: %s - Changed link(s) to
%s',
+ 'sr': u'Решавање вишезначних одредница помоћу бота: %s - Changed link(s)
to %s',
+ 'sv': u'Länkar direkt till rätt artikel för: %s - Bytte länk(ar) till
%s',
+ }
+
+# Summary message when working on redirects and the link is removed
+msg_redir_unlink = {
+ 'ar': u'توضيح بمساعدة روبوت: %s - أزال الوصلة أو الوصلات',
+ 'cs': u'Robot opravil přesměrování na %s - Odstraněn(y) odkaz(y)',
+ 'en': u'Robot-assisted disambiguation: %s - Removed link(s)',
+ 'da': u'Retter flertydigt link til: %s - Fjernede link(s)',
+ 'de': u'Bot-unterstützte Redirectauflösung: %s - Link(s) entfernt',
+ 'fr': u'Correction de lien vers redirect: %s - Retrait du (des)
lien(s)',
+ 'fi': u'Täsmennystä botin avulla: %s - poistettiin linkkejä',
+ 'he': u'הסרת קישור לדף פירושונים באמצעות בוט: %s',
+ 'hu': u'Bottal támogatott egyértelműsítés: %s – hivatkozások
eltávolítása',
+ 'ia': u'Resolution de redirectiones assistite per robot: %s - Removed
link(s).',
+ 'it': u'Sistemazione automatica del redirect: %s - Collegamenti
rimossi',
+ 'lt': u'Nuorodų į peradresavimo straipsnį keitimas: %s - Pašalintos
nuorodos',
+ 'kk': u'Айрықты мағыналарды бот көмегімен шешу: %s - Removed
link(s).',
+ 'ko': u'로봇의 도움을 받아 동음이의 처리: [[%s]] - 링크 제거',
+ 'nl': u'Robot-geholpen redirect-oplossing: [[%s]] - Link(s)
weggehaald',
+ 'no': u'bot: Endrer omdirigeringslenke: %s - Fjernet lenke(r)',
+ 'pl': u'Wspomagane przez robota ujednoznacznienie: %s - Usunięto
link(i)',
+ 'pt': u'Desambiguação assistida por bot: %s link(s) removidos',
+ 'ru': u'Разрешение значений с помощью бота: %s - Removed link(s)',
+ 'sr': u'Решавање вишезначних одредница помоћу бота: %s - Removed
link(s)',
+ 'sv': u'Länkar direkt till rätt artikel för: %s - Tog bort
länk(ar)',
+ }
+
+# Summary message to (unknown)
+unknown_msg = {
+ 'ar' : u'(غير معروف)',
+ 'en' : u'(unknown)',
+ 'fi' : u'(tuntematon)',
+ 'hu' : u'(ismeretlen)',
+ 'pt' : u'(desconhecido)',
+ }
+
+# disambiguation page name format for "primary topic" disambiguations
+# (Begriffsklärungen nach Modell 2)
+primary_topic_format = {
+ 'ar': u'%s_(توضيح)',
+ 'cs': u'%s_(rozcestník)',
+ 'de': u'%s_(Begriffsklärung)',
+ 'en': u'%s_(disambiguation)',
+ 'fi': u'%s_(täsmennyssivu)',
+ 'hu': u'%s_(egyértelműsítő lap)',
+ 'ia': u'%s_(disambiguation)',
+ 'it': u'%s_(disambigua)',
+ 'lt': u'%s_(reikšmės)',
+ 'kk': u'%s_(айрық)',
+ 'ko': u'%s_(동음이의)',
+ 'nl': u'%s_(doorverwijspagina)',
+ 'no': u'%s_(peker)',
+ 'pl': u'%s_(ujednoznacznienie)',
+ 'pt': u'%s_(desambiguação)',
+ 'he': u'%s_(פירושונים)',
+ 'ru': u'%s_(значения)',
+ 'sr': u'%s_(вишезначна одредница)',
+ 'sv': u'%s_(olika betydelser)',
+ }
+
+# List pages that will be ignored if they got a link to a disambiguation
+# page. An example is a page listing disambiguations articles.
+# Special chars should be encoded with unicode (\x##) and space used
+# instead of _
+
+ignore_title = {
+ 'wikipedia': {
+ 'ar': [
+ u'تصنيف:صفحات توضيح',
+ ],
+ 'cs': [
+ u'Wikipedie:Chybějící interwiki/.+',
+ u'Wikipedie:Rozcestníky',
+ u'Wikipedie diskuse:Rozcestníky',
+ u'Wikipedie:Seznam nejvíce odkazovaných rozcestníků',
+ u'Wikipedie:Seznam rozcestníků/první typ',
+ u'Wikipedie:Seznam rozcestníků/druhý typ',
+ u'Wikipedista:Zirland/okres',
+ ],
+ 'da': [
+ u'Wikipedia:Links til sider med flertydige titler'
+ ],
+ 'de': [
+ u'Benutzer:Katharina/Begriffsklärungen',
+ u'Benutzer:Kirschblut/.+buchstabenkürzel',
+ u'Benutzer:Noisper/Dingliste/[A-Z]',
+ u'Benutzer:SirJective/.+',
+ u'Benutzer:SrbBot/Index/.+',
+ u'Benutzer Diskussion:.+',
+ u'GISLexikon \([A-Z]\)',
+ u'Lehnwort',
+ u'Liste griechischer Wortstämme in deutschen Fremdwörtern',
+ u'Liste von Gräzismen',
+ u'Portal:Abkürzungen/.+',
+ u'Wikipedia:Archiv:.+',
+ u'Wikipedia:Artikelwünsche/Ding-Liste/[A-Z]',
+ u'Wikipedia:Begriffsklärung.*',
+ u'Wikipedia:Dreibuchstabenkürzel von [A-Z][A-Z][A-Z] bis
[A-Z][A-Z][A-Z]',
+ u'Wikipedia:Interwiki-Konflikte',
+ u'Wikipedia:Kurze Artikel',
+ u'Wikipedia:Liste aller 2-Buchstaben-Kombinationen',
+ u'Wikipedia:Liste mathematischer Themen/BKS',
+ u'Wikipedia:Liste mathematischer Themen/Redirects',
+ u'Wikipedia:Löschkandidaten/.+',
+ u'Wikipedia:Qualitätsoffensive/UNO', #requested by Benutzer:Addicted
+ u'Wikipedia:WikiProjekt Altertumswissenschaft/.+',
+ u'Wikipedia:WikiProjekt Verwaiste Seiten/Begriffsklärungen',
+ ],
+ 'en': [
+ u'Wikipedia:Links to disambiguating pages',
+ u'Wikipedia:Disambiguation pages with links',
+ u'Wikipedia:Multiple-place names \([A-Z]\)',
+ u'Wikipedia:Non-unique personal name',
+ u"User:Jerzy/Disambiguation Pages i've Editted",
+ u'User:Gareth Owen/inprogress',
+ u'TLAs from [A-Z][A-Z][A-Z] to [A-Z][A-Z][A-Z]',
+ u'List of all two-letter combinations',
+ u'User:Daniel Quinlan/redirects.+',
+ u'User:Oliver Pereira/stuff',
+ u'Wikipedia:French Wikipedia language links',
+ u'Wikipedia:Polish language links',
+ u'Wikipedia:Undisambiguated abbreviations/.+',
+ u'List of acronyms and initialisms',
+ u'Wikipedia:Usemod article histories',
+ u'User:Pizza Puzzle/stuff',
+ u'List of generic names of political parties',
+ u'Talk:List of initialisms/marked',
+ u'Talk:List of initialisms/sorted',
+ u'Talk:Programming language',
+ u'Talk:SAMPA/To do',
+ u"Wikipedia:Outline of Roget's Thesaurus",
+ u'User:Wik/Articles',
+ u'User:Egil/Sandbox',
+ u'Wikipedia talk:Make only links relevant to the context',
+ u'Wikipedia:Common words, searching for which is not possible',
+ ],
+ 'fi': [
+ u'Wikipedia:Luettelo täsmennyssivuista',
+ u'Wikipedia:Luettelo (täsmennyssivuista)',
+ u'Wikipedia:Täsmennyssivu',
+ ],
+ 'fr': [
+ u'Wikipédia:Liens aux pages d\'homonymie',
+ u'Wikipédia:Homonymie',
+ u'Wikipédia:Homonymie/Homonymes dynastiques',
+ u'Wikipédia:Prise de décision, noms des membres de dynasties/liste des
dynastiens',
+ u'Liste de toutes les combinaisons de deux lettres',
+ u'Wikipédia:Log d\'upload/.*',
+ u'Sigles de trois lettres de [A-Z]AA à [A-Z]ZZ',
+ u'Wikipédia:Pages sans interwiki,.'
+ ],
+ 'fy': [
+ u'Wikipedy:Fangnet',
+ ],
+ 'ia': [
+ u'Categoria:Disambiguation',
+ u'Wikipedia:.+',
+ u'Usator:.+',
+ u'Discussion Usator:.+',
+ ],
+ 'it': [
+ u'Aiuto:Disambigua/Disorfanamento',
+ u'Discussioni utente:.+',
+ u'Utente:Civvì/disorfanamento',
+ ],
+ 'kk': [
+ u'Санат:Айрықты бет',
+ ],
+ 'ko': [
+ u'위키백과:(동음이의) 문서의 목록',
+ u'위키백과:동음이의어 문서의 목록',
+ ],
+ 'lt': [
+ u'Wikipedia:Rodomi nukreipiamieji straipsniai',
+ ],
+ 'nl': [
+ u"Gebruiker:.*",
+ u"Overleg gebruiker:.+[aA]rchief.*",
+ u"Overleg gebruiker:Pven",
+ u"Portaal:.+[aA]rchief.*",
+ u"Wikipedia:Humor en onzin.*",
+ u"Wikipedia:Links naar doorverwijspagina's/Winkeldochters.*",
+ u"Wikipedia:Project aanmelding bij startpagina's",
+ u"Wikipedia:Wikiproject Roemeense
gemeenten/Doorverwijspagina's",
+ u'Categorie:Doorverwijspagina',
+ u'Lijst van Nederlandse namen van pausen',
+ u'Overleg Wikipedia:Discussie spelling 2005',
+ u'Overleg Wikipedia:Doorverwijspagina',
+ u'Overleg Wikipedia:Logboek.*',
+ u'Wikipedia:Logboek.*',
+ u'Overleg gebruiker:Sybren/test.*',
+ u'Overleg
gebruiker:[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?',
+ u'Overleg:Lage Landen (staatkunde)',
+ u'Wikipedia:.*[aA]rchief.*',
+ u'Wikipedia:Doorverwijspagina',
+ u'Wikipedia:Lijst van alle tweeletter-combinaties',
+ u'Wikipedia:Onderhoudspagina',
+ u'Wikipedia:Ongelijke redirects',
+ u'Wikipedia:Protection log',
+ u'Wikipedia:Te verwijderen.*',
+ u'Wikipedia:Top 1000 van meest bekeken artikelen',
+ u'Wikipedia:Wikipedianen met een encyclopedisch artikel',
+ u'Wikipedia:Woorden die niet als zoekterm gebruikt kunnen worden',
+ ],
+ 'pl': [
+ u'Wikipedysta:.+',
+ u'Dyskusja.+:.+',
+ ],
+ 'pt': [
+ u'Usuário:.+',
+ u'Usuário Discussão:.+',
+ u'Discussão:.+',
+ u'Lista de combinações de duas letras',
+ u'Wikipedia:Lista de páginas de desambiguação.+',
+ u'Wikipedia:Páginas para eliminar/.+',
+ ],
+ 'ru': [
+ u'Категория:Disambig',
+ u'Википедия:Страницы разрешения неоднозначностей',
+ u'Википедия:Вики-уборка/Статьи без языковых ссылок',
+ u'Википедия:Страницы с пометкой «(значения)»',
+ u'Список общерусских фамилий',
+ ],
+ },
+ 'memoryalpha': {
+ 'en': [
+ u'Memory Alpha:Links to disambiguating pages'
+ ],
+ 'de': [
+ u'Memory Alpha:Liste der Wortklärungsseiten'
+ ],
+ },
+}
+
+def firstcap(string):
+ return string[0].upper()+string[1:]
+
+def correctcap(link, text):
+ # If text links to a page with title link uncapitalized, uncapitalize link, otherwise
capitalize it
+ linkupper = link.title()
+ linklower = linkupper[0].lower() + linkupper[1:]
+ if text.find("[[%s]]"%linklower) > -1 or
text.find("[[%s|"%linklower) > -1:
+ return linklower
+ else:
+ return linkupper
+
+class ReferringPageGeneratorWithIgnore:
+ def __init__(self, disambPage, primary=False, minimum = 0):
+ self.disambPage = disambPage
+ # if run with the -primary argument, enable the ignore manager
+ self.primaryIgnoreManager = PrimaryIgnoreManager(disambPage,
+ enabled=primary)
+ self.minimum = minimum
+
+ def __iter__(self):
+ # TODO: start yielding before all referring pages have been found
+ refs = [page for page in self.disambPage.getReferences(follow_redirects = False,
withTemplateInclusion = False)]
+ wikipedia.output(u"Found %d references." % len(refs))
+ # Remove ignorables
+ if ignore_title.has_key(self.disambPage.site().family.name) and
ignore_title[self.disambPage.site().family.name].has_key(self.disambPage.site().lang):
+ for ig in
ignore_title[self.disambPage.site().family.name][self.disambPage.site().lang]:
+ for i in range(len(refs)-1, -1, -1):
+ if re.match(ig, refs[i].title()):
+ if wikipedia.verbose:
+ wikipedia.output('Ignoring page %s'
+ % refs[i].title())
+ del refs[i]
+ elif self.primaryIgnoreManager.isIgnored(refs[i]):
+ #wikipedia.output('Ignoring page %s because it was skipped
before' % refs[i].title())
+ del refs[i]
+ if len(refs) < self.minimum:
+ wikipedia.output(u"Found only %d pages to work on; skipping." %
len(refs))
+ return
+ wikipedia.output(u"Will work on %d pages." % len(refs))
+ for ref in refs:
+ yield ref
+
+class PrimaryIgnoreManager(object):
+ '''
+ If run with the -primary argument, reads from a file which pages should
+ not be worked on; these are the ones where the user pressed n last time.
+ If run without the -primary argument, doesn't ignore any pages.
+ '''
+ def __init__(self, disambPage, enabled = False):
+ self.disambPage = disambPage
+ self.enabled = enabled
+
+ self.ignorelist = []
+ filename = wikipedia.config.datafilepath('disambiguations',
+ self.disambPage.titleForFilename() + '.txt')
+ try:
+ # The file is stored in the disambiguation/ subdir. Create if necessary.
+ f = codecs.open(filename, 'r', 'utf-8')
+ for line in f.readlines():
+ # remove trailing newlines and carriage returns
+ while line[-1] in ['\n', '\r']:
+ line = line[:-1]
+ #skip empty lines
+ if line != '':
+ self.ignorelist.append(line)
+ f.close()
+ except IOError:
+ pass
+
+ def isIgnored(self, refPage):
+ return self.enabled and refPage.urlname() in self.ignorelist
+
+ def ignore(self, refPage):
+ if self.enabled:
+ # Skip this occurence next time.
+ filename = wikipedia.config.datafilepath('disambiguations',
+ self.disambPage.urlname() + '.txt')
+ try:
+ # Open file for appending. If none exists yet, create a new one.
+ # The file is stored in the disambiguation/ subdir. Create if necessary.
+ f = codecs.open(filename, 'a', 'utf-8')
+ f.write(refPage.urlname() + '\n')
+ f.close()
+ except IOError:
+ pass
+
+
+class DisambiguationRobot(object):
+ ignore_contents = {
+ 'de':(u'{{[Ii]nuse}}',
+ u'{{[Ll]öschen}}',
+ ),
+ 'fi':(u'{{[Tt]yöstetään}}',
+ ),
+ 'kk':(u'{{[Ii]nuse}}',
+ u'{{[Pp]rocessing}}',
+ ),
+ 'nl':(u'{{wiu2}}',
+ u'{{nuweg}}',
+ ),
+ 'ru':(u'{{[Ii]nuse}}',
+ u'{{[Pp]rocessing}}',
+ ),
+ }
+
+ primary_redir_template = {
+ # Page.templates() format, first letter uppercase
+ 'hu': u'Egyért-redir',
+ }
+
+ def __init__(self, always, alternatives, getAlternatives, generator, primary,
main_only, minimum = 0):
+ self.always = always
+ self.alternatives = alternatives
+ self.getAlternatives = getAlternatives
+ self.generator = generator
+ self.primary = primary
+ self.main_only = main_only
+ self.minimum = minimum
+
+ self.mysite = wikipedia.getSite()
+ self.mylang = self.mysite.language()
+ self.comment = None
+
+ self.setupRegexes()
+
+ def checkContents(self, text):
+ '''
+ For a given text, returns False if none of the regular
+ expressions given in the dictionary at the top of this class
+ matches a substring of the text.
+ Otherwise returns the substring which is matched by one of
+ the regular expressions.
+ '''
+ for ig in self.ignore_contents_regexes:
+ match = ig.search(text)
+ if match:
+ return match.group()
+ return None
+
+ def makeAlternativesUnique(self):
+ # remove duplicate entries
+ result={}
+ for i in self.alternatives:
+ result[i]=None
+ self.alternatives = result.keys()
+
+ def listAlternatives(self):
+ list = u'\n'
+ for i in range(len(self.alternatives)):
+ list += (u"%3i - %s\n" % (i, self.alternatives[i]))
+ wikipedia.output(list)
+
+ def setupRegexes(self):
+ # compile regular expressions
+ self.ignore_contents_regexes = []
+ if self.ignore_contents.has_key(self.mylang):
+ for ig in self.ignore_contents[self.mylang]:
+ self.ignore_contents_regexes.append(re.compile(ig))
+
+ linktrail = self.mysite.linktrail()
+ self.trailR = re.compile(linktrail)
+ # The regular expression which finds links. Results consist of four groups:
+ # group title is the target page title, that is, everything before | or ].
+ # group section is the page section. It'll include the # to make life easier
for us.
+ # group label is the alternative link title, that's everything between | and
].
+ # group linktrail is the link trail, that's letters after ]] which are part
of the word.
+ # note that the definition of 'letter' varies from language to language.
+ self.linkR =
re.compile(r'\[\[(?P<title>[^\]\|#]*)(?P<section>#[^\]\|]*)?(\|(?P<label>[^\]]*))?\]\](?P<linktrail>'
+ linktrail + ')')
+
+ def treat(self, refPage, disambPage):
+ """
+ Parameters:
+ disambPage - The disambiguation page or redirect we don't want anything
+ to link on
+ refPage - A page linking to disambPage
+ Returns False if the user pressed q to completely quit the program.
+ Otherwise, returns True.
+ """
+ # TODO: break this function up into subroutines!
+
+ include = False
+ unlink = False
+ new_targets = []
+ try:
+ text=refPage.get(throttle=False)
+ ignoreReason = self.checkContents(text)
+ if ignoreReason:
+ wikipedia.output('\n\nSkipping %s because it contains %s.\n\n' %
(refPage.title(), ignoreReason))
+ else:
+ include = True
+ except wikipedia.IsRedirectPage:
+ wikipedia.output(u'%s is a redirect to %s' % (refPage.title(),
disambPage.title()))
+ if disambPage.isRedirectPage():
+ target = self.alternatives[0]
+ choice = wikipedia.inputChoice(u'Do you want to make redirect %s
point to %s?' % (refPage.title(), target), ['yes', 'no'],
['y', 'N'], 'N')
+ if choice == 'y':
+ redir_text = '#%s [[%s]]' %
(self.mysite.redirect(default=True), target)
+ try:
+ refPage.put_async(redir_text,comment=self.comment)
+ except wikipedia.PageNotSaved, error:
+ wikipedia.output(u'Page not saved: %s' % error.args)
+ else:
+ choice = wikipedia.inputChoice(u'Do you want to work on pages linking
to %s?' % refPage.title(), ['yes', 'no', 'change redirect'],
['y', 'N', 'c'], 'N')
+ if choice == 'y':
+ gen = ReferringPageGeneratorWithIgnore(refPage, self.primary)
+ preloadingGen = pagegenerators.PreloadingGenerator(gen)
+ for refPage2 in preloadingGen:
+ # run until the user selected 'quit'
+ if not self.treat(refPage2, refPage):
+ break
+ elif choice == 'c':
+ text=refPage.get(throttle=False,get_redirect=True)
+ include = "redirect"
+ except wikipedia.NoPage:
+ wikipedia.output(u'Page [[%s]] does not seem to exist?! Skipping.' %
refPage.title())
+ include = False
+ if include in (True, "redirect"):
+ # make a backup of the original text so we can show the changes later
+ original_text = text
+ n = 0
+ curpos = 0
+ edited = False
+ # This loop will run until we have finished the current page
+ while True:
+ m = self.linkR.search(text, pos = curpos)
+ if not m:
+ if n == 0:
+ wikipedia.output(u"No changes necessary in %s" %
refPage.title())
+ return True
+ else:
+ # stop loop and save page
+ break
+ # Make sure that next time around we will not find this same hit.
+ curpos = m.start() + 1
+ # ignore interwiki links and links to sections of the same page
+ if m.group('title') == '' or
self.mysite.isInterwikiLink(m.group('title')):
+ continue
+ else:
+ try:
+ linkPage = wikipedia.Page(disambPage.site(),
m.group('title'))
+ # Check whether the link found is to disambPage.
+ except wikipedia.InvalidTitle:
+ continue
+ if linkPage != disambPage:
+ continue
+
+ n += 1
+ # how many bytes should be displayed around the current link
+ context = 60
+ # This loop will run while the user doesn't choose an option
+ # that will actually change the page
+ while True:
+ # Show the title of the page where the link was found.
+ # Highlight the title in purple.
+ wikipedia.output(u"\n\n>>>
\03{lightpurple}%s\03{default} <<<" % refPage.title())
+
+ # at the beginning of the link, start red color.
+ # at the end of the link, reset the color to default
+ wikipedia.output(text[max(0, m.start() - context) : m.start()] +
'\03{lightred}' + text[m.start() : m.end()] + '\03{default}' +
text[m.end() : m.end() + context])
+
+ if not self.always:
+ if edited:
+ choice = wikipedia.input(u"Option (#, r#, s=skip link,
e=edit page, n=next page, u=unlink, q=quit\n"
+ " m=more context, l=list,
a=add new, x=save in this form):")
+ else:
+ choice = wikipedia.input(u"Option (#, r#, s=skip link,
e=edit page, n=next page, u=unlink, q=quit\n"
+ " m=more context, d=show
disambiguation page, l=list, a=add new):")
+ else:
+ choice = self.always
+ if choice in ['a', 'A']:
+ newAlternative = wikipedia.input(u'New alternative:')
+ self.alternatives.append(newAlternative)
+ self.listAlternatives()
+ elif choice in ['e', 'E']:
+ editor = editarticle.TextEditor()
+ newText = editor.edit(text, jumpIndex = m.start(), highlight =
disambPage.title())
+ # if user didn't press Cancel
+ if newText and newText != text:
+ text = newText
+ break
+ elif choice in ['d', 'D']:
+ editor = editarticle.TextEditor()
+ if disambPage.isRedirectPage():
+ disambredir = disambPage.getRedirectTarget()
+ disambigText = editor.edit(disambredir.get(), jumpIndex =
m.start(), highlight = disambredir.title())
+ else:
+ disambigText = editor.edit(disambPage.get(), jumpIndex =
m.start(), highlight = disambPage.title())
+ elif choice in ['l', 'L']:
+ self.listAlternatives()
+ elif choice in ['m', 'M']:
+ # show more text around the link we're working on
+ context *= 2
+ else:
+ break
+
+ if choice in ['e', 'E']:
+ # user has edited the page and then pressed 'OK'
+ edited = True
+ curpos = 0
+ continue
+ elif choice in ['n', 'N']:
+ # skip this page
+ if self.primary:
+ # If run with the -primary argument, skip this occurence next
time.
+ self.primaryIgnoreManager.ignore(refPage)
+ return True
+ elif choice in ['q', 'Q']:
+ # quit the program
+ return False
+ elif choice in ['s', 'S']:
+ # Next link on this page
+ n -= 1
+ continue
+ elif choice in ['x', 'X'] and edited:
+ # Save the page as is
+ break
+
+ # The link looks like this:
+ # [[page_title|link_text]]trailing_chars
+ page_title = m.group('title')
+ link_text = m.group('label')
+
+ if not link_text:
+ # or like this: [[page_title]]trailing_chars
+ link_text = page_title
+ if m.group('section') == None:
+ section = ''
+ else:
+ section = m.group('section')
+ trailing_chars = m.group('linktrail')
+ if trailing_chars:
+ link_text += trailing_chars
+
+ if choice in ['u', 'U']:
+ # unlink - we remove the section if there's any
+ text = text[:m.start()] + link_text + text[m.end():]
+ unlink = True
+ continue
+ else:
+ if len(choice)>0 and choice[0] == 'r':
+ # we want to throw away the original link text
+ replaceit = True
+ choice = choice[1:]
+ elif include == "redirect":
+ replaceit = True
+ else:
+ replaceit = False
+
+ try:
+ choice=int(choice)
+ except ValueError:
+ wikipedia.output(u"Unknown option")
+ # step back to ask the user again what to do with the current
link
+ curpos -= 1
+ continue
+ if choice >= len(self.alternatives) or choice < 0:
+ wikipedia.output(u"Choice out of range. Please select a
number between 0 and %i." % (len(self.alternatives) - 1))
+ # show list of possible choices
+ self.listAlternatives()
+ # step back to ask the user again what to do with the current
link
+ curpos -= 1
+ continue
+ new_page_title = self.alternatives[choice]
+ repPl = wikipedia.Page(disambPage.site(), new_page_title)
+ if (new_page_title[0].isupper()) or (link_text[0].isupper()):
+ new_page_title = repPl.title()
+ else:
+ new_page_title = repPl.title()
+ new_page_title = new_page_title[0].lower() + new_page_title[1:]
+ if new_page_title not in new_targets:
+ new_targets.append(new_page_title)
+ if replaceit and trailing_chars:
+ newlink = "[[%s%s]]%s" % (new_page_title, section,
trailing_chars)
+ elif replaceit or (new_page_title == link_text and not section):
+ newlink = "[[%s]]" % new_page_title
+ # check if we can create a link with trailing characters instead of a
pipelink
+ elif len(new_page_title) <= len(link_text) and
firstcap(link_text[:len(new_page_title)]) == firstcap(new_page_title) and
re.sub(self.trailR, '', link_text[len(new_page_title):]) == '' and not
section:
+ newlink = "[[%s]]%s" %
(link_text[:len(new_page_title)], link_text[len(new_page_title):])
+ else:
+ newlink = "[[%s%s|%s]]" % (new_page_title, section,
link_text)
+ text = text[:m.start()] + newlink + text[m.end():]
+ continue
+
+ wikipedia.output(text[max(0,m.start()-30):m.end()+30])
+ if text == original_text:
+ wikipedia.output(u'\nNo changes have been made:\n')
+ else:
+ wikipedia.output(u'\nThe following changes have been made:\n')
+ wikipedia.showDiff(original_text, text)
+ wikipedia.output(u'')
+ # save the page
+ self.setSummaryMessage(disambPage, new_targets, unlink)
+ try:
+ refPage.put_async(text,comment=self.comment)
+ except wikipedia.LockedPage:
+ wikipedia.output(u'Page not saved: page is locked')
+ except wikipedia.PageNotSaved, error:
+ wikipedia.output(u'Page not saved: %s' % error.args)
+ return True
+
+ def findAlternatives(self, disambPage):
+ if disambPage.isRedirectPage() and not self.primary:
+ if self.primary_redir_template.has_key(disambPage.site().lang) and
self.primary_redir_template[disambPage.site().lang] in disambPage.templates(get_redirect =
True):
+ baseTerm = disambPage.title()
+ for template in disambPage.templatesWithParams(get_redirect = True):
+ if template[0] == self.primary_redir_template[disambPage.site().lang]
and len(template[1]) > 0:
+ baseTerm = template[1][1]
+ disambTitle = primary_topic_format[self.mylang] % baseTerm
+ try:
+ disambPage2 = wikipedia.Page(self.mysite, disambTitle)
+ links = disambPage2.linkedPages()
+ links = [correctcap(l,disambPage2.get()) for l in links]
+ except wikipedia.NoPage:
+ wikipedia.output(u"No page at %s, using redirect target." %
disambTitle)
+ links = disambPage.linkedPages()[:1]
+ links = [correctcap(l,disambPage.get(get_redirect = True)) for l in
links]
+ self.alternatives += links
+ else:
+ try:
+ target = disambPage.getRedirectTarget().title()
+ self.alternatives.append(target)
+ except wikipedia.NoPage:
+ wikipedia.output(u"The specified page was not found.")
+ user_input = wikipedia.input(u"""\
+Please enter the name of the page where the redirect should have pointed at,
+or press enter to quit:""")
+ if user_input == "":
+ sys.exit(1)
+ else:
+ self.alternatives.append(user_input)
+ except wikipedia.IsNotRedirectPage:
+ wikipedia.output(
+ u"The specified page is not a redirect. Skipping.")
+ return False
+ elif self.getAlternatives:
+ try:
+ if self.primary:
+ try:
+ disambPage2 = wikipedia.Page(self.mysite,
+ primary_topic_format[self.mylang]
+ % disambPage.title()
+ )
+ links = disambPage2.linkedPages()
+ links = [correctcap(l,disambPage2.get()) for l in links]
+ except wikipedia.NoPage:
+ wikipedia.output(u"Page does not exist, using the first link
in page %s." % disambPage.title())
+ links = disambPage.linkedPages()[:1]
+ links = [correctcap(l,disambPage.get()) for l in links]
+ else:
+ try:
+ links = disambPage.linkedPages()
+ links = [correctcap(l,disambPage.get()) for l in links]
+ except wikipedia.NoPage:
+ wikipedia.output(u"Page does not exist, skipping.")
+ return False
+ except wikipedia.IsRedirectPage:
+ wikipedia.output(u"Page is a redirect, skipping.")
+ return False
+ self.alternatives += links
+ return True
+
+ def setSummaryMessage(self, disambPage, new_targets = [], unlink = False):
+ # make list of new targets
+ targets = ''
+ for page_title in new_targets:
+ targets += u'[[%s]], ' % page_title
+ # remove last comma
+ targets = targets[:-2]
+
+ if not targets:
+ targets = wikipedia.translate(self.mysite, unknown_msg)
+
+ # first check whether user has customized the edit comment
+ if wikipedia.config.disambiguation_comment.has_key(self.mysite.family.name) and
wikipedia.config.disambiguation_comment[self.mysite.family.name].has_key(self.mylang):
+ try:
+ self.comment = wikipedia.translate(self.mysite,
+ wikipedia.config.disambiguation_comment[
+ self.mysite.family.name]
+ ) % (disambPage.title(), targets)
+ #Backwards compatibility, type error probably caused by too many arguments
for format string
+ except TypeError:
+ self.comment = wikipedia.translate(self.mysite,
+ wikipedia.config.disambiguation_comment[
+ self.mysite.family.name]
+ ) % disambPage.title()
+ elif disambPage.isRedirectPage():
+ # when working on redirects, there's another summary message
+ if unlink and not new_targets:
+ self.comment = wikipedia.translate(self.mysite, msg_redir_unlink) %
disambPage.title()
+ else:
+ self.comment = wikipedia.translate(self.mysite, msg_redir) %
(disambPage.title(), targets)
+ else:
+ if unlink and not new_targets:
+ self.comment = wikipedia.translate(self.mysite, msg_unlink) %
disambPage.title()
+ else:
+ self.comment = wikipedia.translate(self.mysite, msg) %
(disambPage.title(), targets)
+
+ def run(self):
+ if self.main_only:
+ if not ignore_title.has_key(self.mysite.family.name):
+ ignore_title[self.mysite.family.name] = {}
+ if not ignore_title[self.mysite.family.name].has_key(self.mylang):
+ ignore_title[self.mysite.family.name][self.mylang] = []
+ ignore_title[self.mysite.family.name][self.mylang] += [
+ u'%s:' % namespace for namespace in self.mysite.namespaces()]
+
+ for disambPage in self.generator:
+ self.primaryIgnoreManager = PrimaryIgnoreManager(disambPage,
enabled=self.primary)
+
+ if not self.findAlternatives(disambPage):
+ continue
+
+ self.makeAlternativesUnique()
+ # sort possible choices
+ if wikipedia.config.sort_ignore_case:
+ self.alternatives.sort(lambda x,y: cmp(x.lower(), y.lower()))
+ else:
+ self.alternatives.sort()
+ self.listAlternatives()
+
+ gen = ReferringPageGeneratorWithIgnore(disambPage, self.primary, minimum =
self.minimum)
+ preloadingGen = pagegenerators.PreloadingGenerator(gen)
+ for refPage in preloadingGen:
+ if not self.primaryIgnoreManager.isIgnored(refPage):
+ # run until the user selected 'quit'
+ if not self.treat(refPage, disambPage):
+ break
+
+ # clear alternatives before working on next disambiguation page
+ self.alternatives = []
+
+def main():
+ # the option that's always selected when the bot wonders what to do with
+ # a link. If it's None, the user is prompted (default behaviour).
+ always = None
+ alternatives = []
+ getAlternatives = True
+ # if the -file argument is used, page titles are dumped in this array.
+ # otherwise it will only contain one page.
+ generator = None
+ # This temporary array is used to read the page title if one single
+ # page to work on is specified by the arguments.
+ pageTitle = []
+ primary = False
+ main_only = False
+
+ # For sorting the linked pages, case can be ignored
+ ignoreCase = False
+ minimum = 0
+
+ for arg in wikipedia.handleArgs():
+ if arg.startswith('-primary:'):
+ primary = True
+ getAlternatives = False
+ alternatives.append(arg[9:])
+ elif arg == '-primary':
+ primary = True
+ elif arg.startswith('-always:'):
+ always = arg[8:]
+ elif arg.startswith('-file'):
+ if len(arg) == 5:
+ generator = pagegenerators.TextfilePageGenerator(filename = None)
+ else:
+ generator = pagegenerators.TextfilePageGenerator(filename = arg[6:])
+ elif arg.startswith('-pos:'):
+ if arg[5]!=':':
+ mysite = wikipedia.getSite()
+ page = wikipedia.Page(mysite, arg[5:])
+ if page.exists():
+ alternatives.append(page.title())
+ else:
+ answer = wikipedia.inputChoice(u'Possibility %s does not actually
exist. Use it anyway?'
+ % page.title(), ['yes', 'no'], ['y',
'N'], 'N')
+ if answer == 'y':
+ alternatives.append(page.title())
+ else:
+ alternatives.append(arg[5:])
+ elif arg == '-just':
+ getAlternatives = False
+ elif arg == '-main':
+ main_only = True
+ elif arg.startswith('-min:'):
+ minimum = int(arg[5:])
+ elif arg.startswith('-start'):
+ try:
+ if len(arg) <= len('-start:'):
+ generator =
pagegenerators.CategorizedPageGenerator(wikipedia.getSite().disambcategory())
+ else:
+ generator =
pagegenerators.CategorizedPageGenerator(wikipedia.getSite().disambcategory(), start =
arg[7:])
+ generator = pagegenerators.NamespaceFilterPageGenerator(generator, [0])
+ except wikipedia.NoPage:
+ print "Disambiguation category for your wiki is not known."
+ raise
+ elif arg.startswith("-"):
+ print "Unrecognized command line argument: %s" % arg
+ # show help text and exit
+ wikipedia.showHelp()
+ else:
+ pageTitle.append(arg)
+
+ # if the disambiguation page is given as a command line argument,
+ # connect the title's parts with spaces
+ if pageTitle != []:
+ pageTitle = ' '.join(pageTitle)
+ page = wikipedia.Page(wikipedia.getSite(), pageTitle)
+ generator = iter([page])
+
+ # if no disambiguation pages was given as an argument, and none was
+ # read from a file, query the user
+ if not generator:
+ pageTitle = wikipedia.input(u'On which disambiguation page do you want to
work?')
+ page = wikipedia.Page(wikipedia.getSite(), pageTitle)
+ generator = iter([page])
+
+ bot = DisambiguationRobot(always, alternatives, getAlternatives, generator, primary,
main_only, minimum = minimum)
+ bot.run()
+
+
+
+if __name__ == "__main__":
+ try:
+ main()
+ finally:
+ wikipedia.stopme()