User talk:Chris G/Archives/2007/October

#####################################
##(C) Arknascar44                  ##
##Distributed under the MIT License##
#####################################

# Some credit for this program goes to Misza13's archivebot.py

__version__ = '$Id: ANIbot.py 3998 2007-08-07 20:28:27Z wikipedian $'
import re,sys,wikipedia,pagegenerators
import re, time, locale, traceback, string
for arg in wikipedia.handleArgs():
    wikipedia.output(u"Unknown argument: %s" % arg)
    wikipedia.stopme()
    sys.exit(1)

mysite = wikipedia.getSite()
if mysite.loggedInAs():
    wikipedia.output(u"You are logged in on %s as %s." % (repr(mysite), mysite.loggedInAs()))
else:
    wikipedia.output(u"You are not logged in on %s." % repr(mysite))
    
class GoToANI(object):
    """
    A short class that takes the bot to the AN/I page.
    """
    ani = "Wikipedia:Administrators' noticeboard/Incidents"
    self = ani
class ResolvedThread(object):
    """
    A thread on AN/I that has been marked with the {{resolved}} template
    """
    def __init__(self, title):
        self.title = title
        self.content = ""
        self.timestamp = None

    def __repr__(self):
        return '%s("%s",%d bytes)' % (self.__class__.__name__,self.title,len(self.content))

    def feedLine(self, line):
        if not self.content and not line:
            return
        self.content += line + '\n'
        #Update timestamp
        TM = re.search(r'(\d\d):(\d\d), (\d\d?) (\w+) (\d\d\d\d) \(.*?\)', line)
        if not TM:
            TM = re.search(r'(\d\d):(\d\d), (\w+) (\d\d?), (\d\d\d\d) \(.*?\)', line)
        if TM:
            TIME = txt2timestamp(TM.group(0),"%H:%M, %d %B %Y (%Z)")
            if not TIME:
                TIME = txt2timestamp(TM.group(0),"%H:%M, %d %b %Y (%Z)")
            if not TIME:
                TIME = txt2timestamp(TM.group(0),"%H:%M, %b %d %Y (%Z)")
            if not TIME:
                TIME = txt2timestamp(TM.group(0),"%H:%M, %b %d, %Y (%Z)")
            if TIME:
                self.timestamp = max(self.timestamp,time.mktime(TIME))

    def size(self):
        return len(self.title) + len(self.content) + 12

    def toText(self):
        return "== " + self.title + ' ==\n\n' + '{{resolved}}' or '{{resolved|%s}}' + self.content

class Archiver(object):
    """
    Class that archives resolved threads.
    """
    msg = {
        'en': u'Archiving resolved discussion on [[WP:ANI]] (BOT)',
    }
    def run(self, archive, thread):
        """
        Runs the archiver
        """
        subpage= '/IncidentArchive'
        archive = self.page.title+ ani%s % (subpage) [:len(self.Page.title)]
        text = page.get(archive)
        newtext = text + toText
        try:
            page.put(newtext) and wikipedia.output(u'Archiving thread...')
        except wikipedia.EditConflict:
            wikipedia.output(u'Skipping %s because of edit conflict' % (page.title()))
        
def main():
    from optparse import OptionParser
    parser = OptionParser(usage='usage: %prog [options] [LINKPAGE(s)]')
    parser.add_option('-f', '--file', dest='filename',
            help='load list of pages from FILE', metavar='FILE')
    parser.add_option('-p', '--page', dest='pagename',
            help='archive a single PAGE', metavar='PAGE')
    parser.add_option('-n', '--namespace', dest='namespace', type='int',
            help='only archive pages from a given namespace')
    parser.add_option('-s', '--salt', dest='salt',
            help='specify salt')
    parser.add_option('-F', '--force', action='store_true', dest='force',
            help='override security options')
    parser.add_option('-c', '--calc', dest='calc',
            help='calculate key for PAGE and exit', metavar='PAGE')
    parser.add_option('-l', '--locale', dest='locale',
            help='switch to locale LOCALE', metavar='LOCALE')
    (options, args) = parser.parse_args()

    if options.locale:
        locale.setlocale(locale.LC_TIME,options.locale) #Required for english month names

    if options.calc:
        if not options.salt:
            parser.error('you must specify a salt to calculate a key')
        s = new_hash()
        s.update(options.salt+'\n')
        s.update(options.calc+'\n')
        wikipedia.output(u'key = ' + s.hexdigest())
        return

    if options.salt:
        salt = options.salt
    else:
        salt = ''

    if options.force:
        force = True
    else:
        force = False

    for a in args:
        pagelist = []
        if not options.filename and not options.pagename:
            for pg in wikipedia.Page(Site,a).getReferences(follow_redirects=False,
                pagelist.append(pg)
        if options.filename:
            for pg in file(options.filename,'r').readlines():
                pagelist.append(wikipedia.Page(Site,pg))
        if options.pagename:
            pagelist.append(wikipedia.Page(Site,options.pagename))

        pagelist = sorted(pagelist)
        if not options.namespace == None:
            pagelist = [pg for pg in pagelist if pg.namespace()==options.namespace]

        for pg in pagelist:
            try: #Catching exceptions, so that errors in one page do not bail out the entire process
                Archiver = PageArchiver(pg, a, salt, force)
                Archiver.run()
                time.sleep(10)
            except:
                wikipedia.output(u'Error occured while processing page [[%s]]' % pg.title())
                traceback.print_exc()


if __name__ == '__main__':
    main()
    wikipedia.stopme()