Help:Gebruik van bots

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:

1. Maak voor het gemak een nieuwe map voor de bot, bijvoorbeeld C:\Bot (Windows) of ~/Pywikibot (Linux)
2. Enkel Windows: Installeer vervolgens de programmeertaal Python, die te vinden is op Python.org, instructies hiervoor vindt u aldaar. Dit kan in de door het installatieprogramma aangegeven map, maar ook bijvoorbeeld in de map C:\Bot\Python. Deze programmeertaal is op Linux meestal standaard aanwezig.
3. Installeer daarna de Pywikibot-code in bijvoorbeeld C:\Bot\Pywikibot (Windows) of ~/Pywikibot (Linux).
   • Universele optie(enkel bij het helemaal zelf opzetten van uw bot): U kunt het Pywikibot-pakket downloaden via pypi, dit is een softwarepakket standaard meegeleverd in de meeste python installaties. U kunt het dan downloaden door in de Command prompt in te typen "pip install pywikibot". Nu kan u het softwarepakket gebruiken door deze te importeren in uw python bestand.
   • Windows, optie 1: U kunt het Pywikibot-pakket downloaden van Pywikibot en dit gedownloade tar.gz-compressie-bestand uitpakken met datacompressiesoftware (meestal standaard aanwezig).
   • Windows, optie 2: De Pywikibot-code, die te vinden is op https://svn.mediawiki.org/viewvc/Pywikibot/ ^{4 augustus 2018: deze link is verouderd}, is te downloaden via een SVN-programma, hiervoor is TortoiseSVN te gebruiken. Via SVN beschikt u altijd over de recentste versie, via de site zelf kan dit een dag achterlopen en is het bijhouden moeilijker. U wordt aangeraden om SVN te gebruiken, de meest recente versie is meteen via een SVN-programma te downloaden van wikimedia.org. Linux is meestal standaard uitgerust met SVN via de terminal.
   • Linux: Dit doet u door een terminal te starten en svn checkout https://svn.wikimedia.org/svnroot/Pywikibot/trunk/Pywikibot Pywikibot^{4 augustus 2018: deze link is verouderd} op te geven vanuit uw homedirectory.

Universeel

Voer pip install pywikibot -U uit in de command prompt.

Windows

Download een nieuwe nightly of werk het programma bij met uw SVN-programma.

Linux

Voer svn update uit vanuit ~/Pywikibot.

• Maak via Speciaal:Userlogin een gebruikersnaam aan voor uw bot. Bij voorkeur een naam waaruit blijkt dat het gaat om een bot, bijvoorbeeld BotGebruikersnaam.
• Maak een tekstbestand aan met de naam "user-config.py" in de map met de Pywikibot-software en plaats de onderstaande tekst, waar "BotGebruikersnaam" vervangen is door de gebruikersnaam van je bot.

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

• Nu moet de bot inloggen.
  • Windows: Start een DOS-scherm (vanuit Windows (via "Start", "Run..." en typ cmd) of een ander programma dat deze mogelijkheid biedt) en ga naar de map waar de code van Pywikibot in staat. Dat doet u door middel van het commando cd, en wel als volgt:

cd C:\Bot\Pywikibot

• • Windows: Nu is het zaak onze bot in te loggen. Dit hoeft doorgaans maar eenmalig en voert u eenvoudig uit door het daartoe geschreven Python-script uit te voeren:

python pwb.py login.py

• • Linux: Start een terminal en ga naar ~/Pywikibot.
  • Linux: Voer python pwb.py login.py uit.
• Er wordt nu gevraagd om de naam en het gekozen wachtwoord van het gebruikersprofiel van de bot. Nu bent u ingelogd op de Nederlandstalige Wikipedia.
• Als dit niet lukt kan je altijd -all -force -pass:xxx proberen toe te voegen, waar xxx je wachtwoord is. (Veiliger is -all -pass, dan wordt er om je password gevraagd maar is deze niet zichtbaar op het scherm.

• Plaats op de gebruikerspagina van je bot ook een verwijzing naar jouw gebruikerspagina. Je kan dit gemakkelijk doen door {{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

• waarbij xxx de naam is van de doorverwijspagina die u wilt afhandelen.
• volgende opties kunnen worden meegegeven:

• -pos:XXXX, hiermee wordt een alternatieve doorverwijsoptie meegegeven
• -min:n (met n een getal) (voornamelijk handig in combinatie met -start) zorgt dat alleen doorverwijspagina's met minimaal n links worden bewerkt
• -main zorgt dat alleen links vanaf de hoofdnaamruimte verwerkt worden

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:

Een getal: wijzig de link zodanig dat het verwijst naar de pagina die met het getal correspondeert.

r+x (waarbij x een getal is): wijzig zowel de link als de tekst van de link op die wijze.

s: wijzig deze link niet.

n: wijzig deze hele pagina niet.

u: maak van deze tekst een niet-linkende tekst.

m: toon een groter deel van de tekst van de pagina, zodat u meer gegevens heeft om te beslissen. (Dit kan herhaaldelijk gebruikt worden, de hoeveelheid tekst wordt elke keer bij benadering verdubbeld.)

l: geef de lijst van mogelijke links nog een keer.

a: geef een nieuwe mogelijke link op.

e: ga over tot handmatige bewerking van de pagina (u krijgt dan iets dat vergelijkbaar is met het wijzig-scherm in uw browser).

q: beëindig het programma.

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:

• double - lost de problemen met redirects op die naar andere redirects verwijzen
• broken - deze actie verwijdert redirects die naar niet-bestaande pagina's wijzen. Dit kan alleen door moderators worden gedaan.

-argument:

• xml - haal informatie van een lokale XML-dump (http://download.wikimedia.org), of met "-xml:filename.xml" van een lokale, op de harde schijf van de computer, opgeslagen XML-dump. Zonder dit argument zal de informatie van een speciale pagina worden gehaald.

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:

• replace.py -xml:pages_current.xml -namespace:0 "produkt" "product"
• replace.py -cat:Belarus "Belarus" "Wit-Rusland"

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):

• -xml = Haal de informatie uit de lokaal opgeslagen sqldump, aldus: "-xml:filenaam" - bijvoorbeeld -xml:pages_current.xml.
• -file = Bewerk een aantal pagina's dat gegeven is in een lokale tekstfile, aldus: "-file:filenaam". De robot leest elke [[wiki link]] aangegeven in deze file.
• -cat = Bewerk alle pagina's die in een bepaalde categorie worden opgevoerd, aldus: "-cat:categoryname".
• -page = Bewerk een enkel artikel, aldus: "-page:artikelnaam". Als je deze parameter meerdere keren ingeeft dan kan de bot in 1 keer meerdere pagina's afhandelen.

De volgende opties kunnen meegegeven worden:

• -regex = staat voor regular expressions. Als dit niet in de syntaxis wordt opgenomen wordt alleen tekst gelezen.
• -except:XYZ - Artikelen met XYZ moeten niet veranderd worden. Hierbij is XYZ een reguliere uitdrukking. XYZ geldt niet voor titels van artikelen, alleen voor tekst binnen artikelen.
• -fix:XYZ - een van de voorgedefinieerde taken uitvoeren, bijvoorbeeld HTML-tags naar wiki-syntaxis omzetten.
• -namespace:n - werkt alleen met een xmldump, 0 staat voor de artikelen (mag meerdere malen worden opgenomen om meerdere namespaces te selecteren).
• -always - niet navragen of de verandering moet worden uitgevoerd maar altijd uitvoeren.

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:

• table2wiki.py "artikelnaam"

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):

• table2wiki.py -xml:20050406_cur_table.xml -lang:nl

-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:

• upload.py afbeelding.png
• upload.py http://www.ergens.nl/afbeelding.png
• upload.py -wiki:xx afbeelding.png

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:

• brackethttp
• catall
• category
• check_extern
• editarticle
• getimages
• imageharvest
• imagetransfer
• login (één keer uitvoeren voor elke taal)
• replace
• solve_disambiguation
• table2wiki
• template
• test
• touchall
• upload
• warnfile
• windows_chars

De volgende scripts zijn hulpprogramma's die bestanden aanmaken voor andere bots:

• extract_names
• extract_wikilinks
• splitwarning

De volgende scripts gebruiken SQL-dumps:

• find
• redirect

De volgende scripts zijn verouderd, of zijn slechts voor een specifiek doel of een specifieke taal gemaakt en niet bruikbaar voor de Nederlandstalige Wikipedia:

• copy_table
• pagelist
• saveHTML
• sqldump
• us-states
• WdT

De volgende Python-bestanden zijn geen bots, maar worden gebruikt door andere bots:

• catlib
• commons_family
• config
• date
• family
• gui
• lib_images
• logger
• mediawiki_messages
• meta_family
• titletranslate
• translator
• unequal
• WdTXMLParser
• wikibooks_family
• wikipedia
• wikipedia_cd_fork_family
• wikipedia_family
• wikiquote_family
• wikitravel_family
• wiktionary
• wiktionary_family
• xmltest

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:

• Mac OS X:
  • Bij Mac OS X maakt het programma Teksteditor een pagina in RTF-formaat aan. Dit is niet bruikbaar voor een user-config.py bestand. Gebruik om user-config.py aan te maken een programma als BBEdit of TextMate.
  • Bij Mac OS X is python al geïnstalleerd, dus dat is niet meer nodig, en het aanroepen van een script gaat via de terminal (programma's → hulpprogramma's → terminal) en dan navigeer je naar de map, zoals uitgelegd. Het script voer je uit met het commando python script.py

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/&lt;/</sg;
	$text =~ s/&gt;/>/sg;
	$text =~ s/&apos;/'/sg;
	$text =~ s/"/"/sg;
	$text =~ s/&amp;/&/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();

• Om dit script te kunnen uitvoeren is een Perl-programma nodig. Onder windows kan ActivePerl gebruikt worden. Dit programma kan gedownload worden en dan volgens instructies van het installatieprogramma geïnstalleerd worden.
• De scriptfile zoals hier te vinden is, wordt via een editor als een .pl file opgeslagen (bijv: conversie.pl) in de c:/perl/bin directory.
• Na het downloaden van de XML-file (nlwiki-latest-pages-articles.xml.bz2) moet deze eerst unzipped worden. Dit kan bijvoorbeeld in de directory van de bot (c:/nlpy bijvoorbeeld)
• Hierna wordt een DOS-schermpje geopend. Ga met het commando cd naar de bot-directory
• Voor het omzetten van XML in SQL geef volgend commando: type nlwiki-latest-pages-articles.xml | c:\perl\bin\perl c:\perl\bin\conversie.pl > nlwiki-latest-pages-articles.sql
• De script geeft een foutmelding(en) die beginnen met "duplicate key". Die kan je negeren
• De SQL-file nlwiki-latest-pages-articles.sql kan gebruikt worden voor MySQL

• Help:Overzicht van soorten Wikipediagebruikers
• Help:Terminologie op Wikipedia
• Wikipedia:Bots
• Wikipedia:Verzoekpagina voor bots
• Wikipedia:Meldingen botimport nieuwe artikelen
• Wikipedia:Botcafé
• Wikipedia:Taalcafé - voor alle veranderingen die betrekking hebben op taal, zoals spelling & hoofdletters.
• Sjabloon:Nobots - een manier om bots te vragen van een pagina (bijvoorbeeld een gebruikerspagina) af te blijven

• De categorie Pywikibot op Meta-Wiki bevat een aantal artikelen die extra informatie geven.
• Website van Pywikibot op Sourceforge
• MediaWiki API Gegevens uit de database opvragen vanuit een programma/bot.
• English Pywikibot API Docs (en) - De Engelse documentatie van Pywikibot API.

{[Navigatie Wikipedia-bots}}