| Overzicht hulppagina's |
|---|
| Wikipedia-terminologie |
Met een bot kunnen lastige taken makkelijker worden uitgevoerd. Sommige taken geheel automatisch, andere half-automatisch. Om op de Nederlandstalige Wikipedia een bot te gebruiken is wel enige software nodig. Kennis van programmeren is nuttig maar niet noodzakelijk.
Er zijn twee soorten bots: deze mét en deze zonder botstatus, ook wel botbit genoemd. Een botbit maakt de wijzigingen van die bot in de eerste plaats onzichtbaar op de recente wijzigingen. Verzoeken voor een botbitje kunnen worden geplaatst op Wikipedia:Aanmelding botgebruikers. Als je begint met het gebruik van een bot, is het niet noodzakelijk om meteen een botstatus aan te vragen. Het is aan te raden om eerst te leren omgaan met je bot. Let wel: je mag dan slechts één wijziging per minuut doen met je bot.
Op de Nederlandstalige Wikipedia is het gebruik van bots weinig aan regels gebonden. Let evenwel op wanneer u bots gebruikt op anderstalige Wikipedia's, bijvoorbeeld de Engelstalige Wikipedia: daar gelden andere richtlijnen. Deze zijn ingevoerd omdat men daar het aantal bots probeert te beperken, omdat te veel bots het systeem kunnen vertragen.
Er draaien reeds veel mensen een bot op de Nederlandstalige Wikipedia (zie hier), zodat de behoefte aan nieuwe botgebruikers niet erg groot is. Voor het succesvol draaien van een bot (dus zonder fouten) is een goede kennis van Wikipedia noodzakelijk. Een ervaring van drie maanden met veel dagelijkse edits kan als richtlijn dienen. De meeste zaken (zoals doorverwijspagina's) worden al regelmatig gecontroleerd. Versterking kan op zich geen kwaad, maar bedenk dat het ook mogelijk is om op andere manieren meer aan de Nederlandstalige Wikipedia bij te dragen (kijk voor ideeën in het gebruikersportaal).
Het inzetten van een aangemelde bot om op grote schaal nieuwe artikelen te genereren zorgt ervoor dat de nieuwe artikelen niet in de recente wijzigingen te zien zijn. Het is daarom gewenst dit botproces onder de normale gebruikersnaam te doen zodat de nieuw aangemaakte artikelen direct te zien zijn en een bot tijdig kan worden gestopt, en vooraf toestemming vragen aan de gemeenschap op Wikipedia:Meldingen botimport nieuwe artikelen.
Om te beginnen met een bot moet er eerst software geïnstalleerd worden. Als dat gedaan is maken we een nieuwe gebruiker aan voor onze bot en voeren we nog een paar formaliteiten uit.
Veelgebruikte software voor een Wikipedia-bot is Pywikibot. Daarover gaat de komende handleiding. Er wordt van uitgegaan dat u Windows of Linux gebruikt, anders kunt u verderop kijken voor instructies. Om een Pywikibot-bot te kunnen gebruiken, moet u de volgende stappen volgen:
Voer pip install pywikibot -U uit in de command prompt.
Download een nieuwe nightly of werk het programma bij met uw SVN-programma.
Voer svn update uit vanuit ~/Pywikibot.
usernames['wikipedia']['nl']='BotGebruikersnaam' mylang='nl'
Indien uw bot (nog) geen botbitje heeft, mag de bot maximaal 1 keer per minuut een wijziging aanbrengen. Plaats hiervoor ook onderstaande regel in "user-config.py":
put_throttle = 60
cd C:\Bot\Pywikibot
python pwb.py login.py
((Bot|jouw gebruikersnaam)) te plaatsen. Indien gewenst kan er ook een stopknop geplaatst worden met het sjabloon ((Noodrem)).Je bot is nu geïnstalleerd en klaar voor gebruik.
Uitleg enkel voor Windows. Herhaal voor Linux dezelfde stappen als om in te loggen, maar voer een ander script uit. Open wederom een DOS-scherm, bijvoorbeeld met cmd.exe, en ga naar de map met de Pywikibot-code:
cd C:\Bot\Pywikibot
Nu kunt u een script uitvoeren om uw bot aan het werk te zetten. De verschillende scripts hebben verschillende functies, die vaak bovenaan het script kort worden besproken. U kunt deze (Engelstalige) omschrijving krijgen door de naam van het script plus de tekst -help in te voeren (bijvoorbeeld lonelypages.py -help). Hieronder worden enkele kort uitgelegd.
Met deze functie kunnen doorverwijspagina's worden afgehandeld. Er wordt voor gezorgd dat links in artikelen direct naar het juiste artikel wijzen, en niet via een doorverwijspagina.
Type het volgende in:
solve_disambiguation.py -optie xxx
In plaats van een paginanaam kunt u ook -start:xxx opgeven; in dat geval zal de bot door de lijst van doorverwijspagina's lopen, in alfabetische volgorde vanaf de aangegeven waarde.
De bot zal even zoeken en wellicht een aantal pagina's vinden die naar de doorverwijspagina verwijzen. Het is nu de taak van de botbestuurder om de juiste betekenis toe te kennen aan de doorverwijzingsterm in de gevonden artikelen. Deze functie is half-automatisch, en na elke aangepaste pagina kan de volgende pagina worden voorzien van de juiste doorverwijsbetekenis.
Per gevonden verwijzing zijn de volgende codes beschikbaar:
Met deze functie kunnen categorieën worden aangepast.
Met
category.py add
kunnen categorieën automatisch worden toegevoegd aan een lijst van artikelen.
Met
category.py move
kunnen categorieën automatisch worden verplaatst en hernoemd. Dit is vooral makkelijk wanneer er een spelfout in de categorienaam staat.
Type
category.py
in voor een complete lijst met alle opties.
redirect.py actie [-argument]
actie:
-argument:
Replace.py is uitstekend geschikt om veel gemaakte taalfouten te verbeteren. Tevens is het makkelijk als binnen een file veel keer dezelfde fout is gemaakt en je bijvoorbeeld 10 keer dezelfde benaming van een vlag wilt veranderen naar de nieuwe naam.
Voor de taalfouten is het noodzakelijk dat je een recente xml-dump gebruikt. Hoe daaraan te komen vindt men hieronder bij #Dumpfile.
Een aantal voorbeelden van een syntaxis:
De eerste "tekst" (de foute) is de tekst die vervangen wordt door de tweede "tekst".
De volgende commando's worden gegeven om de plaats aan te geven waar de bot moet werken (je moet 1 van deze 4 kiezen):
De volgende opties kunnen meegegeven worden:
Opmerking: wanneer men Xxx -> xxx uitvoert, kan men die vervanging laten voorafgaan door een replace.py werkend de links naar Xxx (-ref:Xxx) waarbij je [[Xxx|xxx]] vervangt door [[xxx]]. Wanneer men dit immers niet doet, krijgt men na de vervanging [[xxx|xxx]] (twee keer hetzelfde dus). Dat heeft geen enkel nut, maakt de pagina langer en kan verwarrend werken ten opzichte van nieuwe gebruikers die dit zien in het 'bewerk'-venster en denken dat dit zo moet.
Voorbeeld van de eenvoudigste syntax:
Op deze manier wordt maar 1 artikel veranderd.
Het proces kan ook geautomatiseerd aflopen voor de gehele nl:wikipedia, daarvoor is een xml-dump nodig (zie bij replace.py hoe dat te verkrijgen is):
-xml = naam van de xmldump en met -lang:nl geef je aan dat in de samenvatting tekst Nederlands wordt gebruikt.
Let op: elke verandering moet gecontroleerd worden. Deze bot is niet geheel vrij van bugs. Hij geeft weliswaar aan dat er mogelijke fouten zijn opgetreden, maar waakzaamheid is gewenst.
Upload.py zorgt voor het uploaden van afbeeldingen. Er zijn drie mogelijkheden:
Het eerste commando uploadt een afbeelding dat momenteel op uw harde schijf staat, het tweede een afbeelding op een willekeurige URI, het derde een afbeelding op een van de andere Wikipedia's. Upload.py werkt niet wanneer uw bot niet is ingelogd (in tegenstelling tot de andere bots, die werken dan wel, maar doen hun wijzigingen anoniem, wat als niet netjes wordt beschouwd).
pagefromfile.py zorgt voor het uploaden van nieuwe artikelen in een door de gebruiker voorbereid bestand.
Het (Utf) tekstbestand moet als volgt worden aangemaakt. Elk artikel moet worden afgebakend met een start-code (b.v. Start) en een eindcode (b.v End). Als artikel-titel wordt de tekst tussen ''' gebruikt. Er kunnen dus vele artikelen in 1 bestand staan.
Start '''Boek A''' is geschreven door schrijver B in 1990. End Start '''Boek C''' is geschreven door schrijver B in 1990. End
Er zijn nog een heel stel andere scripts. U kunt bekijken wat ze doen en hoe ze bediend moeten worden in het bovenste (Engels- in plaats van Pythontalige) deel van de broncode (of, als het dan nog niet duidelijk is, kunt u het André Engels vragen). Op het moment van schrijven zijn de volgende bots bruikbaar:
De volgende scripts zijn hulpprogramma's die bestanden aanmaken voor andere bots:
De volgende scripts gebruiken SQL-dumps:
De volgende scripts zijn verouderd, of zijn slechts voor een specifiek doel of een specifieke taal gemaakt en niet bruikbaar voor de Nederlandstalige Wikipedia:
De volgende Python-bestanden zijn geen bots, maar worden gebruikt door andere bots:
Redirects die vallen in de categorie Redirect voor omgekeerde redirect constructie zijn daar bewust neergezet om duidelijk te maken dat in een hoofdbetekenisconstructie de betreffende link is gecontroleerd op correctheid. Het is de bedoeling dat deze redirects niet worden 'gefixt'. (zie Wikipedia:Stemlokaal/Modificatie Amsterdamconstructies)
Hoewel het bovenstaande voor Windows is geschreven, gaat het bij Unix-gebaseerde besturingssystemen zoals Linux vrijwel hetzelfde. Enkele verschillen zijn:
De laatste dumpfile van Wikipedia is beschikbaar in XML-formaat op deze plaats: https://download.wikimedia.org/nlwiki/latest/ . Voor de meeste toepassingen volstaat het downloaden van nlwiki-latest-pages-articles.xml.bz2.
Vroeger werd ook een SQL-bestand voorzien, maar deze wordt niet meer geactualiseerd: het laatste bestand is van 23-06-2005. Indien u MySQL wil gebruiken is een SQL-file echter nodig. Hiertoe kan XML2SQL gebruikt worden, of kan het volgende Perl-script uitgevoerd worden.
#!/usr/bin/perl
sub xmlunesc {
my $text = shift;
$text =~ s/</</sg;
$text =~ s/>/>/sg;
$text =~ s/'/'/sg;
$text =~ s/"/"/sg;
$text =~ s/&/&/sg;
$text;
}
sub sqlesc {
my $text = shift;
$text =~ s/\\/\\\\/sg;
$text =~ s/\n/\\n/sg;
$text =~ s/\r/\\r/sg;
$text =~ s/\0/\\0/sg;
$text =~ s/\x1A/\\Z/sg;
$text =~ s/"/\\"/sg;
$text =~ s/'/\\'/sg;
$text;
}
sub xmlsiteinfo {
while($xml =~ /<namespace key="(.*?)"(?: \/>|>(.*?)<\/namespace>)/sg) {
$namespace{$2} = $1 if defined $2;
}
$xml = "";
}
sub xmlrevision {
$xml =~ s/<revision>(.*?)<\/revision>//s;
my ($revcontent, $rev) = ($1, {});
xmlpage() unless defined $page;
$xml = "";
while($revcontent =~ /<(id|timestamp|contributor|minor|comment|text)(?: xml:space="preserve"| type="(.*?)")*(?:\s*\/>|>(.*?)<\/\1>)/sg) {
my ($tag, $type, $content) = ($1, $2, $3);
$content = "" unless defined $content;
if($tag =~ /^text/) {
$rev->{"text"} = xmlunesc($content);
} elsif($tag eq "contributor") {
if($content =~ /<username>(.*?)<\/username><id>(.*?)<\/id>/) {
$rev->{"user_text"} = xmlunesc($1);
$rev->{"user"} = $2;
} elsif($content =~ /<ip>(.*?)<\/ip>/) {
$rev->{"user_text"} = xmlunesc($1);
$rev->{"user"} = 0;
} else {
$rev->{"user_text"} = "_";
$rev->{"user"} = 0;
}
} elsif($tag eq "comment") {
$rev->{"comment"} = xmlunesc($content);
} elsif($tag eq "timestamp") {
$content =~ /^(....)-(..)-(..)T(..):(..):(..)Z$/;
$rev->{"timestamp"} = "$1$2$3$4$5$6";
$rev->{"inverse_timestamp"} = $rev->{"timestamp"};
$rev->{"inverse_timestamp"} =~ tr/0123456789/9876543210/;
$page->{"touched"} = $rev->{"timestamp"};
} else {
$rev->{$tag} = $content;
}
}
revision($page, $rev);
}
sub xmlpage {
while($xml =~ s/<(title|id|restrictions)(?:\s*\/>|>(.*?)<\/\1>)//s) {
my ($tag, $content) = ($1, $2);
if($tag eq "title") {
$content = xmlunesc($content);
if($content =~ /(.+?):(.+)/ && defined $namespace{$1}) {
$page->{"namespace"} = $namespace{$1};
$content = $2;
} else {
$page->{"namespace"} = 0;
}
}
$page->{$tag} = defined $content ? $content : "";
}
}
sub revision {
my ($page, $rev) = @_;
my $is_redirect = $rev->{"text"} =~ /^# ?redirect/i;
my $len = length($rev->{"text"});
return unless defined $page->{"title"};
my $title = $page->{"title"};
$title =~ s/\s/_/sg;
if(defined $pageid{$page->{"id"))) {
print STDERR "duplicate key cur_id: ".$page->{"id"}."\n";
return;
}
$ntdp = $page->{"namespace"}."+".$page->{"title"};
if(defined $ntdp{$ntdp}) {
print STDERR "duplicate key name_title_dup_prevention: $ntdp\n";
return;
}
$rev->{"comment"} = "" unless defined $rev->{"comment"};
$sql = sprintf "(%d,%d,'%s','%s','%s',%d,'%s','%s','%s',%d,%d,%d,%d,%f,'%s','%s')",
$page->{"id"}, $page->{"namespace"}, sqlesc($title),
sqlesc($rev->{"text"}), sqlesc($rev->{"comment"}), $rev->{"user"},
sqlesc($rev->{"user_text"}), $rev->{"timestamp"},
sqlesc($page->{"restrictions"}), 0, $is_redirect, defined $rev->{"minor"},
0, rand(), $rev->{"inverse_timestamp"}, $page->{"touched"};
# Um Hauptspeicherbedarf um ca. 40% zu verringern kann man die folgende
# Zeile auskommentieren. Das ist problemlos möglich, solange sich MySQL nicht
# über einen doppelten Key beschwert und das Einlesen des Dumps abbricht.
$pageid{$page->{"id"))++;
$ntdp{$ntdp}++;
sqlflush() if $lsql+length($sql)>1000000;
push @sql, $sql;
$lsql += length($sql);
}
sub sqlflush {
if(@sql>0) {
print "INSERT INTO `cur` VALUES " . join(",", @sql) . ";\n";
@sql = ();
$lsql = 0;
}
}
sub sqlheader {
print <<"ABC";
DROP TABLE IF EXISTS `cur`;
CREATE TABLE `cur` (
`cur_id` int(8) unsigned NOT NULL auto_increment,
`cur_namespace` tinyint(2) unsigned NOT NULL default '0',
`cur_title` varchar(255) binary NOT NULL default '',
`cur_text` mediumtext NOT NULL,
`cur_comment` tinyblob NOT NULL,
`cur_user` int(5) unsigned NOT NULL default '0',
`cur_user_text` varchar(255) binary NOT NULL default '',
`cur_timestamp` varchar(14) binary NOT NULL default '',
`cur_restrictions` tinyblob NOT NULL,
`cur_counter` bigint(20) unsigned NOT NULL default '0',
`cur_is_redirect` tinyint(1) unsigned NOT NULL default '0',
`cur_minor_edit` tinyint(1) unsigned NOT NULL default '0',
`cur_is_new` tinyint(1) unsigned NOT NULL default '0',
`cur_random` double unsigned NOT NULL default '0',
`inverse_timestamp` varchar(14) binary NOT NULL default '',
`cur_touched` varchar(14) binary NOT NULL default '',
UNIQUE KEY `cur_id` (`cur_id`),
UNIQUE KEY `name_title_dup_prevention` (`cur_namespace`,`cur_title`),
KEY `cur_title` (`cur_title`),
KEY `cur_timestamp` (`cur_timestamp`),
KEY `cur_random` (`cur_random`),
KEY `name_title_timestamp` (`cur_namespace`,`cur_title`,`inverse_timestamp`),
KEY `user_timestamp` (`cur_user`,`inverse_timestamp`),
KEY `usertext_timestamp` (`cur_user_text`,`inverse_timestamp`),
KEY `jamesspecialpages` (`cur_is_redirect`,`cur_namespace`,`cur_title`,`cur_timestamp`)
) TYPE=InnoDB PACK_KEYS=1;
/*!40000 ALTER TABLE `cur` DISABLE KEYS */;
LOCK TABLES `cur` WRITE;
ABC
}
sub sqlfooter {
print "UNLOCK TABLES;\n";
print "/*!40000 ALTER TABLE `cur` ENABLE KEYS */;\n";
}
$lsql = 0;
sqlheader();
while(<>) {
$xml .= $_;
if(/^\s*<\/siteinfo>/) {
xmlsiteinfo();
}
next unless defined %namespace;
if(/^\s*<\/revision>/) {
xmlrevision();
} elsif(/^\s*<\/page>/) {
$xml = "";
$page = undef;
}
}
sqlflush();
sqlfooter();
{[Navigatie Wikipedia-bots))