User:Robert Ullmann/spork

Definition from Wiktionary, the free dictionary
Jump to navigation Jump to search

program notes[edit]

spork is a program that looks for words used in the English Wikipedia, and adds citations entries to the wikt


spork maintains a persistent (on-disk) cache of words in the wikt that have English sections. It then looks at random 'pedia entries, and checks every lower case word longer than 3 letters. If the word is not in the wikt, it offers to create a Citations: namespace entry, which then shows up in Category:New words from Wikipedia. If the 'pedia has spelled the word incorrectly, a replacement can be supplied, and the program will then set up an edit on the article for approval.

The cache is updated with several steps:

  1. if the word is present in the disk cache, the word exists
  2. else spork reads some of an XML dump (if available), and then checks to see if the word has been found
  3. else it reads a few entries from a likely category, to see if it find the word
  4. else it looks for the specific entry in the wikt, checking for an English section

While this may seem convoluted, it serves a number of purposes. The XML file is not needed, and it doesn't matter greatly if it is stale, even a year old will help, but not affect the validity. So one doesn't need to worry about going to retrieve the XML frequently; getting one when setting up will be fine. It may be the daily, the WMF "pages-articles" or the WMF "pages-meta-current" dump; the "history" dump will not work.

If not found, spork will read a likely category, reading a few entries (20) and adding them to the cache; as these are English POS categories, it need not read each entry to check for the English section. This updates the cache more quickly than looking at each entry individually.

Finally, as it will resort to reading the entry, it will be completely up to date, including entries not categorized, before asking about creating a citation.


# -*- coding: utf-8  -*-

This bot looks for new words in the Wikipedia, by wandering around.

No command line arguments.


import wikipedia
import sys
import re
import pickle
import xmldate
from time import sleep
import socket
from random import choice

# API acceleration, may be present:
    from mwapi import getwikitext, getedit
except Exception, e:
    print "(module mwapi not found, using pybot calls)"
    def getwikitext(p): return p.get()
    def getedit(p): return p.get()

def safe(s):
    return pickle.dumps(s)[1:-5]

# English = { }
# English dictionary, try on disk
import shelve
English ="spork-English-cache")

# rather than look at each word individually, we look at a likely category first.
# this will get us a number of words at a time
# we don't want to read the entire cats at startup, would take too long, and be
# redundant if the cache has been built up
# when new words (or English sections) are added, we automatically find them
# if we start with an empty cache, we collect a large number of words quickly
# some words (pronouns, determiners, numbers) are in categories we don't look at,
# we just find those one at a time as there aren't enough to grab blocks of cat

recword = re.compile(r'title="([a-z]+)"')
reisenword = re.compile(r'[a-z]+$')

POS = ['noun', 'plural', 
       'verb', 'verb form', 'third-person singular form', 'past participle', 'present participle',
       'simple past form',
       'adjective', 'adjective superlative form', 'adjective comparative form',
       'adverb' ]

# keep track of 3-4 letter suffixes found, preset some 1-2 (good numbers for English)

suffixes = {  's':'plural',
              'es':'third-person singular form',
              'd':'simple past form',
              'ed':'past participle',
              'st':'adjective superlative form',
              'er':'adjective comparative form',
              'th':'verb form',
              'ng':'present participle' }

def herdcats(word, site):

    if not reisenword.match(word): return # also means we don't worry about urlencode

    # grab a bunch of a cat that might include word, add to cache

    # have we seen this suffix? pp is possible-pos
    pp = [ ]
    if word[-4:] in suffixes: pp.append(suffixes[word[-4:]])
    if word[-3:] in suffixes: pp.append(suffixes[word[-3:]])
    if word[-2:] in suffixes: pp.append(suffixes[word[-2:]])
    if word[-1:] in suffixes: pp.append(suffixes[word[-1:]])
    if pp: pos = choice(pp)
    else: pos = choice(POS)

    # go get the cat

    print "        (reading cat English %ss)" % pos
        cname = 'Category:English_' + pos.replace(' ', '_') + 's'
        cat = site.getUrl( \
"/w/api.php?action=query&list=categorymembers&cmtitle=%s&cmlimit=20&cmstartsortkey=%s&format=xml" % (cname, word))
    except Exception, e:
        print "trouble getting a part of a cat", str(e)
        cat = ''

    k = 0
    for w in recword.findall(cat):
        if len(w) < 4: continue
        sw = safe(w)
        if w == word:
            print "        (found %s in cat)" % sw
            if not reisenword.match(w): continue
            if sw not in English or not English[sw]:
                print "        (added %s to cache)" % sw
                k += 1
        English[sw] = True
        suffixes[w[-4:]] = pos
        suffixes[w[-3:]] = pos
        # (don't "learn" 1-2)

    # if we didn't find it, remove the offending suffixes entry
    if safe(word) not in English:
        if word[-4:] in suffixes and suffixes[word[-4:]] == pos: del suffixes[word[-4:]]
        if word[-3:] in suffixes and suffixes[word[-3:]] == pos: del suffixes[word[-3:]]


    # if k: print "        (added %d to cache)" % k


# read from XML file if available

import xmlreader
xml = None
xent = 0
Xmlc = { }
xmlp = False

# words from XML dump
reaz = re.compile(r"[a-z]+$")

def initxml():
    global xml, xent, xmlp

        dump = xmlreader.XmlDump("en-wikt.xml")
        xml = iter(dump.parse())
        xent = 0
        # read one (that will not be present) so the message will come at the beginning
        # also this is where the file is opened:
        xmlp = True # perhaps ...
    except Exception, e:
        print "can't open en-wikt.xml", str(e)
        xml = None
        xmlp = False

def readxml(word):
    global xml, xent, xmlp

    if not xmlp: return # have no xml file from start, do nothing

    r = 1000

    # first, read 1000 entries (counting all)
    while xml and r > 0:

            entry =
        except StopIteration:
            print "        (end of XML file, %d read)" % xent
            xml = None

        xent += 1
        if xent%5000 == 0: print "        (read %d from xml)" % xent

        r -= 1  # countdown reads

        if ':' in entry.title: continue
        if not reaz.match(entry.title): continue
        if "==English==" not in entry.text: continue

        # record in internal cache (spread disk db out over time)
        Xmlc[entry.title] = True

    # now see if we have found anything to add to permanent cache
    # up to 20 words, starting with the same 4 letters (5 works better? lots of words)
    # this gives us a reasonable chance of hitting the word and a reasonable rate of discarding others

    dels = set()
    k = 20

    for title in Xmlc:
        if word[:5] != title[:5]: continue

        sw = safe(title)
        if sw in English and English[sw]: continue

        k -= 1  # count new English words

        English[sw] = True
        if title == word:
            print "        (found %s in xml)" % sw
            print "        (added %s from xml)" % sw

        if not k: break

    # delete titles processed from internal cache
    for title in dels: del Xmlc[title]

    # dbg
    print "        (%d in internal xml cache)" % len(Xmlc)


def spork():


    test = False
    sysop = True # use my regular login to create Citations: pages

    # make sure we are logged in
    site = wikipedia.getSite("en", "wiktionary")
    site.forceLogin(sysop = sysop)
    pedia = wikipedia.getSite("en", "wikipedia")


    entries = 0
    eng = 0

    # set some regex

    refirst = re.compile(r'<h1 class="firstHeading">(.*?)</h1>')
    resent = re.compile(r'[A-Z].*?[a-z\)]\.')
    # general pattern we are interested in
    reword = re.compile(r"[-\w']+", re.U)

    reartid = re.compile(r'var wgArticleId = "(\d*)"')

    # strip tags
    reanchor = re.compile(r'<a .*?>(.*?)</a>')
    reimg = re.compile(r'<img .*?>')
    rerefs = re.compile(r'<ref.*?>(.*?)</ref>')
    resuper = re.compile(r'<sup>(.*?)</sup>')
    resup2 = re.compile(r'<sup .*?>(.*?)</sup>')
    resub = re.compile(r'<sup>(.*?)</sup>')
    rebold = re.compile(r'<b>(.*?)</b>')
    reital = re.compile(r'<i>(.*?)</i>')
    respan = re.compile(r'<span .*?>(.*?)</span>')
    respan2 = re.compile(r'</span>')
    restrong = re.compile(r'<strong .*?>(.*?)</strong>')

    # now pick up random 'pedia articles

    hits = 0
    misses = 0

    while True:

        print "(cache hit ratio %.4f)" % (hits/(hits + misses + 0.0001)) # (no div by zero)

            art = pedia.getUrl("/w/index.php?title=Special:Random")
        except wikipedia.NoPage:
            print "Can't get random article from wikipedia"
            art = ''
        except KeyboardInterrupt:
            raise KeyboardInterrupt
        except Exception, e:
            print "some exception getting a page", str(e)

        # find page title:

        mo =
        if not mo:
            print "can't find page title?"
        article =
        mo =
        if mo: artid =
        else: artid = '?'
        print "article is %s (%s)" % (safe(article), safe(artid))

        kflag = False
        warts = set()

        # look for paragraphs:

        for line in art.splitlines():
            if not line.startswith( '<p>' ) or not line.endswith( '</p>' ): continue

            # strip some things
            line = reanchor.sub(r'\1', line)
            line = reimg.sub(r'', line)
            line = rerefs.sub(r'', line)
            # line = resuper.sub(r'(\1)', line)
            line = resup2.sub(r'', line)
            # line = resub.sub(r'(\1)', line)
            line = rebold.sub(r'\1', line)
            line = reital.sub(r'\1', line)

            # several times ...
            line = respan.sub(r'\1', line)
            line = respan.sub(r'\1', line)
            line = respan.sub(r'\1', line)
            line = respan.sub(r'\1', line)
            # clean up end tags
            line = respan2.sub(r'', line)

            line = restrong.sub(r'\1', line)

            # sentences:

            for sentence in resent.findall(line[3:-4]):

               print safe(sentence)

               for word in reword.findall(sentence):

                   if not word.islower(): continue
                   if word[0:1].isdigit(): continue
                   if '-' in word: continue # at least for now
                   if word.endswith("'s"): continue
                   if word.startswith("'"): word = word[1:]
                   if word.endswith("'"): word = word[:-1]
                   if not word: continue

                   # skip short words, not likely any three letter words are missing,
                   # and we don't need to look at (e.g.) "cm"
                   if len(word) < 4: continue

                   if word in warts: continue # seen already in this article

                   sw = safe(word) # make valid DB key

                   # continue if the word is present, and has English section
                   if sw in English and English[sw]:
                       hits += 1
                       if word in Xmlc: del Xmlc[word]  # discard, not useful
                   misses += 1

                   # candidate
                   print "   ", sw

                   readxml(word) # read some entries if an XML
                   if sw in English and English[sw]: continue

                   herdcats(word, site) # possibly add from cat
                   if sw in English and English[sw]: continue

                   # check for page in wikt (may be non-English, or since created)
                   page = wikipedia.Page(site, word)
                       wt = getwikitext(page)
                       if '==English==' in wt:
                           print "        (entry %s exists)" % sw
                           English[sw] = True
                       print "        (no English in entry)"
                       English[sw] = False
                   except wikipedia.NoPage:
                       English[sw] = False
                   except wikipedia.IsRedirectPage:
                       # [should treat as missing, but skip for now]
                       print "        (redirect)"
                       English[sw] = False  # no English in entry ...
                   except Exception, e:
                       print "some exception getting page: ", str(e)

                   English.sync() # reasonable place to do this

                   # check for citations page
                   cite = wikipedia.Page(site, "Citations:" + word)
                       ctext = getwikitext(cite)
                   except wikipedia.NoPage:
                       ctext = ''
                   except wikipedia.IsRedirectPage:
                       ctext = ''
                   except Exception, e:
                       print "some exception getting page: ", str(e)
                       ctext = ''

                   if ctext:
                       print "        (citations page exists)"

                   # maybe good to go?

                   sent = sentence.replace(word, "'''" + word + "'''")
                   ctext = """{{citation}}

* {{cite wikipedia
""" % (article, sent)

                   # ask if it is okay to write:

                   print "citation for %s: %s" % (safe(word), safe(sentence))
                   answer = wikipedia.input("add (y, n, s, k, wp replacement)?")
                   if answer == 'y':
                           wikipedia.setAction("citation from Wikipedia")
                               # re-init for create, a lot of time may have passed
                               cite = wikipedia.Page(site, "Citations:" + word)
                               ct = cite.get(sysop = sysop)
                               print "        (citations page exists now?)"
                           except wikipedia.NoPage:
                               pass # expected
                           except wikipedia.IsRedirectPage:
                               pass # will overwrite
                           cite.put(ctext, sysop=sysop, minorEdit=False)
                       except Exception, e:
                           print "some exception writing page: ", str(e)
                   if answer == 's': break # skip to next sentence
                   if answer == 'k':
                       kflag = True

                   # fix entry on 'pedia!
                   if len(answer) > 2:
                       wpage = wikipedia.Page(pedia, article)
                           wtext = getedit(wpage)
                           wnew = wtext.replace(word, answer)
                           wikipedia.showDiff(wtext, wnew)
                           a2 = wikipedia.input("okay?")
                           if a2 != 'y': continue
                           wikipedia.setAction("spelling %s to %s" % (word, answer))
                       except Exception, e:
                           print "some exception writing wikipedia: ", str(e)

                   # end of word

               if kflag: break
               # end of sentence

            if kflag: break
            # end of line
        # end of article loop
        # sleep(30)

    # done

def main():
    except KeyboardInterrupt:
        print "(syncing cache)"
        # (xml is open for read, let process rundown handle it)
        print "(exit)"

if __name__ == "__main__":