def __init__(self, page, filename, summary, dry, always):
     self.page = pywikibot.Page( pywikibot.getSite(), page )
     self.filename = filename
     self.summary = summary
     if not self.summary:
         self.summary = pywikibot.translate(pywikibot.getSite(), self.msg)
     pywikibot.setAction( self.summary )

 def run(self):
     # Set the edit summary message
     pipes = ', '.join(self.filters)
     pywikibot.setAction(pywikibot.translate(pywikibot.getSite(), self.msg)
                         % pipes)
     for page in self.generator:
         self.treat(page)

    def run(self):
        comment = wikipedia.translate(wikipedia.getSite(), msg)
        wikipedia.setAction(comment)

        for page in self.generator:
            if self.done: break
            self.treat(page)

def process_article(page, tag):
		EditMsg = "Robot: Tagging {{Film|%s}}" %tag
		wikipedia.setAction(EditMsg)
		try:
			wikitext = page.get()
		except wikipedia.NoPage:
			page.put("{{Film|%s}}" %tag)
			return
		except wikipedia.IsRedirectPage:
			return
		if re.search(tag,wikitext,re.I):
			print "Skipping " + str(page)
			return
		# Fix Casing (Reduces the number of possible expressions)
		wikitext = re.compile(r'\{\{\s*(template:|)film', re.IGNORECASE).sub(r'{{Film', wikitext)
		state0 = wikitext
 
		# Add tf parameter
		wikitext = re.compile(r'\{\{\s*film(.*?)\}\}', re.IGNORECASE).sub(r'{{Film\1|%s}}' %tag, wikitext)
 
		wikipedia.showDiff(state0, wikitext)
 
		if (wikitext != state0):
			try:
				print 'Going to edit %s' %str(page)
				wikipedia.output(u'WRITE:	Adding %s bytes.' % str(len(wikitext)-len(state0)))
				page.put(wikitext)	
			except KeyboardInterrupt:
				sys.exit()

 def run(self):
     for page in self.generator:
         if page.isRedirectPage():
             page = page.getRedirectTarget()
         page_t = page.title()
         # Show the title of the page we're working on.
         # Highlight the title in purple.
         wikipedia.output(u"\n>>> \03{lightpurple}%s\03{default} <<<"
                          % page_t)
         page_cap = wikipedia.Page(wikipedia.getSite(), page_t.title().capitalize())
         if not page_cap.exists():
             wikipedia.output(u'%s doesn\'t exist' % page_cap.title())
             if not self.acceptall:
                 choice = wikipedia.inputChoice(
                         u'Do you want to create a redirect?',
                         ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
                 if choice == 'a':
                     self.acceptall = True
             if self.acceptall or choice == 'y':
                 try:
                     wikipedia.setAction(
                         wikipedia.translate(wikipedia.getSite(), msg)
                         % page_t)
                     page_cap.put(u"#REDIRECT [[%s]]" % page_t)
                     print
                 except:
                     wikipedia.output(
                         u"An error occurred. Retrying in 15 seconds...")
                     time.sleep(15)
                     continue
         else:
             wikipedia.output(u'%s already exists, skipping...\n'
                              % page_t.title())

    def run(self):
        comment = i18n.twtranslate(self.site, 'noreferences-add-tag')
        pywikibot.setAction(comment)

        for page in self.generator:
            # Show the title of the page we're working on.
            # Highlight the title in purple.
            pywikibot.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
                             % page.title())
            try:
                text = page.get()
            except pywikibot.NoPage:
                pywikibot.output(u"Page %s does not exist?!"
                                 % page.title(asLink=True))
                continue
            except pywikibot.IsRedirectPage:
                pywikibot.output(u"Page %s is a redirect; skipping."
                                 % page.title(asLink=True))
                continue
            except pywikibot.LockedPage:
                pywikibot.output(u"Page %s is locked?!"
                                 % page.title(asLink=True))
                continue
            if pywikibot.getSite().sitename() == 'wikipedia:en' and page.isIpEdit():
                pywikibot.output(
                    u"Page %s is edited by IP. Possible vandalized" % page.title(asLink=True))
                continue
            if self.lacksReferences(text):
                newText = self.addReferences(text)
                self.save(page, newText)

 def setSummaryMessage(self, disambPage, new_targets=[], unlink=False,
                       dn=False):
     # TODO: setSummaryMessage() in solve_disambiguation now has parameters
     # new_targets and unlink. Make use of these here.
     comment = pywikibot.translate(self.mysite, self.msg) \
               % disambPage.title()
     pywikibot.setAction(comment)

    def run(self):
        comment = pywikibot.translate(pywikibot.getSite(), msg)
        pywikibot.setAction(comment)

        for page in self.generator:
            if self.done: break
            self.treat(page)

def process_article(page):
		EditMsg = "Robot: Substituting {{[[Template:RS500|RS500]]}} and common fixes"
		wikipedia.setAction(EditMsg)
		try:
			wikitext = page.get()
		except wikipedia.NoPage:
			return
		except wikipedia.IsRedirectPage:
			return
		# Fix Casing (Reduces the number of possible expressions)
		# Common fixes
#		wikitext = commonfixes.fix(wikitext)
		# State point.  Count any changes as needing an update if they're after this line
		state0 = wikitext
 
		# Add |Iran=yes
		wikitext = re.compile(r'\{\{\s*rs500(.*?)\}\}', re.IGNORECASE).sub(r'{{subst:RS500\1}}', wikitext)
 
		wikipedia.showDiff(page.get(), wikitext)
		if (wikitext != state0):
			try:
				wikipedia.output(u'WRITE:	Adding %s bytes.' % str(len(wikitext)-len(page.get())))
#				print 'Waiting 2.5 seconds'
#				time.sleep(2.5)
				page.put(wikitext)	
			except TypeError:
				print 'Skipping TypeError'
				return

 def __init__(self, page, filename, summary, overwrite):
     self.page = pywikibot.Page( pywikibot.getSite(), page )
     self.filename = filename
     self.summary = summary
     self.overwrite = overwrite
     if not self.summary:
         self.summary = pywikibot.translate(pywikibot.getSite(), self.msg)
     pywikibot.setAction( self.summary )

def treat(to_pl, fromsite):
    try:
        to_text = to_pl.get()
        interwikis = to_pl.interwiki()
    except wikipedia.IsRedirectPage:
        print "Can't work on redirect page."
        return
    except wikipedia.NoPage:
        print "Page not found."
        return
    from_pl = None
    for interwiki in interwikis:
        if interwiki.site() == fromsite:
            from_pl = interwiki
    if from_pl is None:
        print "Interwiki link to %s not found." % repr(fromsite)
        return
    from_text = from_pl.get()
    wikipedia.setAction(wikipedia.translate(mysite.lang, msg) + from_pl.aslink())
    # search start of table
    table = get_table(from_text)
    if not table:
        wikipedia.output(u"No table found in %s" % (from_pl.aslink()))
        return

    print_debug(u"Copying images")
    if copy_images:
        # extract image links from original table
        images=imagelinks(fromsite, table)
        for image in images:
            # Copy the image to the current wikipedia, copy the image description page as well.
            # Prompt the user so that he can translate the filename.
            new_filename = lib_images.transfer_image(wikipedia.Page(fromsite, image), debug)
            # if the upload succeeded
            if new_filename:
                old_image_tag = wikipedia.Page(fromsite, image).title()
                new_image_tag = wikipedia.Page(mysite, mysite.image_namespace() + ":" + new_filename).title()
                print_debug(u"Replacing " + old_image_tag + " with " + new_image_tag)
                # We want to replace "Image:My pic.jpg" as well as "image:my_pic.jpg", so we need a regular expression.
                old_image_tag = old_image_tag.replace(" ", "[ \_]")
                old_image_tag = "[" + old_image_tag[0].upper() + old_image_tag[0].lower() + "]" + old_image_tag[1:]
                #todo: regex for first letter of filename, i.e. first letter after the colon
                rOld_image_tag = re.compile(old_image_tag)
                table = re.sub(old_image_tag, new_image_tag, table)


    translated_table = translator.translate(table, type, fromsite.lang, debug, mysite.lang)
    if not translated_table:
        print "Could not translate table."
        return

    print_debug(u"\n" + translated_table)
    # add table to top of the article, seperated by a blank lines
    to_text = translated_table + "\n\n" + to_text
    if not debug:
        # save changes on Wikipedia
        to_pl.put(to_text, minorEdit='0')

def main():
    summary_commandline,template,gen = None,None,None
    exceptions,PageTitles,namespaces = [],[],[]
    cat=''
    autoText,autoTitle = False,False
    genFactory = pagegenerators.GeneratorFactory()
    arg=False#------if you dont want to work with arguments leave it False if you want change it to True---
    if arg==False:
        for arg in wikipedia.handleArgs():
            if arg == '-autotitle':
                autoTitle = True
            elif arg == '-autotext':
                autoText = True
            elif arg.startswith( '-page:' ):
                if len(arg) == 6:
                    PageTitles.append(wikipedia.input( u'Which page do you want to chage?' ))
                else:
                    PageTitles.append(arg[6:])
            elif arg.startswith( '-cat:' ):
                if len(arg) == 5:
                    cat=wikipedia.input( u'Which Category do you want to chage?' )
                else:
                    cat='Category:'+arg[5:]
            elif arg.startswith( '-template:' ):
                if len(arg) == 10:
                    template.append(wikipedia.input( u'Which Template do you want to chage?' ))
                else:
                    template.append('Template:'+arg[10:])
            elif arg.startswith('-except:'):
                exceptions.append(arg[8:])
            elif arg.startswith( '-namespace:' ):
                namespaces.append( int( arg[11:] ) )
            elif arg.startswith( '-ns:' ):
                namespaces.append( int( arg[4:] ) )    
            elif arg.startswith( '-summary:' ):
                wikipedia.setAction( arg[9:] )
                summary_commandline = True
            else:
                generator = genFactory.handleArg(arg)
                if generator:
                    gen = generator
    else:
        PageTitles = [raw_input(u'Page:> ').decode('utf-8')]
    if cat!='':
        facatfalist=facatlist(cat)
        if facatfalist!=False:
            run(facatfalist)    
    if PageTitles:
        pages = [wikipedia.Page(faSite,PageTitle) for PageTitle in PageTitles]
        gen = iter( pages )
    if not gen:
        wikipedia.stopme()
        sys.exit()
    if namespaces != []:
        gen = pagegenerators.NamespaceFilterPageGenerator( gen,namespaces )
    preloadingGen = pagegenerators.PreloadingGenerator( gen,pageNumber = 60 )#---number of pages that you want load at same time
    run(preloadingGen)

def main():
	yearnumber = 1998
	yearset1 = yearnumber - 1
	if yearnumber >= 2000:
		yearset2 = yearnumber - 2000
	else:
		yearset2 = yearnumber - 1900
	if yearset2 < 10:
		yearset2 = "0" + str(yearset2)
	yearsetfinal = str(yearset1) + "–" + str(yearset2)
	loopsat = True # loop
	
	for arg in wikipedia.handleArgs():
		if arg.startswith('-year'):
			if len(arg) == 5:
				yearnumber = int(wikipedia.input('What year do you want to start at?'))
			elif len(arg) > 5:
				yearnumber = int(arg[6:])

	while loopsat == True: #start loop
		if yearnumber >= 2011:
			return
		listpage = wikipedia.Page(site, "DFB Cup " + yearsetfinal)
		if listpage.exists() == True:
			wikipedia.setAction("Making redirects per [[Wikipedia:Bot requests/Archive 22#DFB_Cups|Botreq]]")
			wikipedia.output("> The target for [[" + str(yearnumber) + " DFB Cup Final]] exists")
			rd = "#REDIRECT [[DFB Cup " + yearsetfinal + "#Final]]"
			p1 = wikipedia.Page(site, str(yearnumber) + " DFB Cup Final")
			pagelist = [p1]

			for i in pagelist:
				if i.exists() == False:
					wikipedia.output(">>Creating [[%s]]" % i.title() )
					i.put(rd)
				else:
					wikipedia.output(">>[[en:%s]] already exsists" % i.title() )
		else:
			wikipedia.output(">DFB Cup " + yearsetfinal + " does not exist")
		#Redefine values
		yearnumber = yearnumber + 1
		yearset1 = yearnumber - 1
		yearset2 = yearnumber - 1900
		if yearnumber >= 2000:
			yearset2 = yearnumber - 2000
		else:
			yearset2 = yearnumber - 1900
		if yearset2 < 10:
			yearset2 = "0" + str(yearset2)
			yearsetfinal = str(yearset1) + "-" + str(yearset2)
        if '<div class="usermessage">' in text: #check talk page for messages
			wikipedia.output(u'NOTE: You have unread messages on %s' % self)
			wikipedia.crash() #stop

	wikipedia.output("Done!")
	wikipage = "User:Legoktm/BOTFAQ/Code/redir.py"
	code = "redir.py"
	legoktm.upload(wikipage, code)

def createcat(cat,txt,action):
		wikipedia.setAction(action)
		p=wikipedia.Page(site,"Category:"+cat)
		ptxt="Creating category "+cat
		print Fore.GREEN+"-"*len(ptxt)
		print ptxt
		print "-"*len(ptxt),Fore.WHITE
		sleep(30)
		p.put(txt)
		return

def main():
    genFactory = pagegenerators.GeneratorFactory()

    PageTitles = []
    xmlFilename = None
    always = False
    ignorepdf = False
    limit = None
    namespaces = []
    generator = None
    for arg in pywikibot.handleArgs():
        if arg.startswith('-namespace:'):
            try:
                namespaces.append(int(arg[11:]))
            except ValueError:
                namespaces.append(arg[11:])
        elif arg.startswith('-summary:'):
            pywikibot.setAction(arg[9:])
        elif arg == '-always':
            always = True
        elif arg == '-ignorepdf':
            ignorepdf= True
        elif arg.startswith('-limit:'):
            limit = int(arg[7:])
        elif arg.startswith('-xmlstart'):
            if len(arg) == 9:
                xmlStart = pywikibot.input(
                    u'Please enter the dumped article to start with:')
            else:
                xmlStart = arg[10:]
        elif arg.startswith('-xml'):
            if len(arg) == 4:
                xmlFilename = pywikibot.input(
                    u'Please enter the XML dump\'s filename:')
            else:
                xmlFilename = arg[5:]
        else:
            genFactory.handleArg(arg)

    if xmlFilename:
        try:
            xmlStart
        except NameError:
            xmlStart = None
        generator = XmlDumpPageGenerator(xmlFilename, xmlStart, namespaces)
    if not generator:
        generator = genFactory.getCombinedGenerator()
    if not generator:
        # syntax error, show help text from the top of this file
        pywikibot.showHelp('reflinks')
        return
    generator = pagegenerators.PreloadingGenerator(generator, pageNumber = 50)
    generator = pagegenerators.RedirectFilterPageGenerator(generator)
    bot = ReferencesRobot(generator, always, limit, ignorepdf)
    bot.run()

    def put(self, title, contents):
        mysite = wikipedia.getSite()

        page = wikipedia.Page(mysite, title)
        # Show the title of the page we're working on.
        # Highlight the title in purple.
        wikipedia.output(u">>> \03{lightpurple}%s\03{default} <<<" % page.title())

        if self.summary:
            comment = self.summary
        else:
            comment = wikipedia.translate(mysite, self.msg)

        comment_top = comment + " - " + wikipedia.translate(mysite, self.msg_top)
        comment_bottom = comment + " - " + wikipedia.translate(mysite, self.msg_bottom)
        comment_force = comment + " *** " + wikipedia.translate(mysite, self.msg_force) + " ***"

        # Remove trailing newlines (cause troubles when creating redirects)
        contents = re.sub('^[\r\n]*','', contents)

        if page.exists():
            if self.append == "Top":
                wikipedia.output(u"Page %s already exists, appending on top!" % title)
                contents = contents + page.get()
                comment = comment_top
            elif self.append == "Bottom":
                wikipedia.output(u"Page %s already exists, appending on bottom!" % title)
                contents = page.get() + contents
                comment = comment_bottom
            elif self.force:
                wikipedia.output(u"Page %s already exists, ***overwriting!" % title)
                comment = comment_force
            else:
                wikipedia.output(u"Page %s already exists, not adding!" % title)
                return
        else:
           if self.autosummary:
                comment = ''
                wikipedia.setAction('')

        if self.dry:
            wikipedia.output("*** Dry mode ***\n" + \
                "\03{lightpurple}title\03{default}: " + title + "\n" + \
                "\03{lightpurple}contents\03{default}:\n" + contents + "\n" \
                "\03{lightpurple}comment\03{default}: " + comment + "\n")
            return

        try:
            page.put(contents, comment = comment, minorEdit = self.minor)
        except wikipedia.LockedPage:
            wikipedia.output(u"Page %s is locked; skipping." % title)
        except wikipedia.EditConflict:
            wikipedia.output(u'Skipping %s because of edit conflict' % title)
        except wikipedia.SpamfilterError, error:
            wikipedia.output(u'Cannot change %s because of spam blacklist entry %s' % (title, error.url))

def main():
	gaia = wikipedia.getSite(code=u'en', fam=u'gaia')
	plot = wikipedia.getSite(code=u'en', fam=u'plotwiki')
	
	wikipedia.setAction(wikipedia.translate(gaia, msg))
	wikipedia.setAction(wikipedia.translate(plot, msg))
	
	final = u'<noinclude><!-- Do not edit this page, this page is automatically created by a Bot. -->\n'
	final+= u'==Most Recent Events==</noinclude>\n'
	
	nonrecent = u'<noinclude>==Older Events==\n'
	end = u'\n\'\'View everything here on the [[Plotwiki:|plotwiki...]]\'\'</noinclude>'
	
	moreYears = True
	year = 04
	
	events = []
	temp = []
	while moreYears:
		y = str(year)
		page = wikipedia.Page(plot, u'Template:Pnav%s' % y.zfill(2))
		
		try:
			text = page.get()
			
			r = sre.compile(u'^.*<span style=".*normal.*">(.*)</span>.*$', sre.UNICODE | sre.MULTILINE | sre.DOTALL)
			text = sre.sub(r, u'\\1', text)
			r = sre.compile(u'\s+\|\s+', sre.UNICODE | sre.MULTILINE | sre.DOTALL)
			pages = sre.split(r, text)
			
			r = sre.compile(u'\[\[([^|]*)(\|.*)?\]\]', sre.UNICODE)
			for p in pages:
				temp.append(sre.sub(r, u'\\1', p))
			
			year+=1
		except wikipedia.NoPage:
			moreYears = False
	for e in temp:
		if not e in events:
			events.append(e)
	
	events = reversed(list(events));
	x = 1
	for e in events:
		final+=u'* [[Plotwiki:%s|]]\n' % e
		x+=1
		if x==6:
			final+=nonrecent
	if x<=6:
		final+=end
	final+=end
	
	page = wikipedia.Page(gaia, u'Plotwiki Current Events')
	page.put(final)

 def run(self):
     # TODO: make all generators return a redicet type indicator,
     #        thus make them usabile with 'both'
     if self.action == 'double':
         # get summary text
         wikipedia.setAction(
             wikipedia.translate(wikipedia.getSite(), msg_double))
         self.fix_double_redirects()
     elif self.action == 'broken':
         self.delete_broken_redirects()
     elif self.action == 'both':
         self.fix_double_or_delete_broken_redirects()

def main():
    summary_commandline,gen,template = None,None,None
    namespaces,PageTitles,exceptions = [],[],[]    
    encat=''
    autoText,autoTitle = False,False
    recentcat,newcat=False,False
    genFactory = pagegenerators.GeneratorFactory()
    for arg in wikipedia.handleArgs():
        if arg == '-autotitle':
            autoTitle = True
        elif arg == '-autotext':
            autoText = True
        elif arg.startswith( '-except:' ):
            exceptions.append( arg[8:] )
            
        elif arg.startswith('-start'):
            firstPageTitle = arg[7:]
            if not firstPageTitle:
                firstPageTitle = wikipedia.input(
                    u'At which page do you want to start?')
            firstPageTitle = wikipedia.Page(fasite,firstPageTitle).title(withNamespace=False)
            gen = pagegenerators.AllpagesPageGenerator(firstPageTitle, 0,
                                        includeredirects=True)    
        elif arg.startswith( '-template:' ):
            template = arg[10:]
        elif arg.startswith( '-namespace:' ):
            namespaces.append( int( arg[11:] ) )
        elif arg.startswith( '-summary:' ):
            wikipedia.setAction( arg[9:] )
            summary_commandline = True
        else:
            generator = genFactory.handleArg( arg )
            if generator:
                gen = generator
    if not gen:
        wikipedia.stopme()
        sys.exit()
    if namespaces != []:
        gen = pagegenerators.PreloadingGenerator(gen,pageNumber = 60)    
        preloadingGen = pagegenerators.NamespaceFilterPageGenerator( gen,namespaces )
    else:
         preloadingGen = pagegenerators.PreloadingGenerator(gen,pageNumber = 60)
    _cache,last_timestamp=get_cache()
    add_text(preloadingGen)

    now = str(datetime.now())
    todaynum=int(now.split('-')[2].split(' ')[0])+int(now.split('-')[1])*30+(int(now.split('-')[0])-2000)*365

    if last_timestamp+3 < todaynum:
        put_cache(_cache,todaynum)
    else:
        put_cache({},0)

 def run(self):
 	self.count = { "target" : [], "done" : [] }
     pywikibot.setAction( self.summary )
     for page in self.generator:
         self.treat(page)
     if self.outputwiki:
         for page in sorted(set(self.count["target"])-set(self.count["done"])):
             print( (u"*%s" % page).encode('utf_8') )
     print "Done: %.01f%% (%d/%d)" % \
           ( 100*len(self.count["done"]) / float(len(self.count["target"])),
             len(self.count["done"]),
             len(self.count["target"]),
           )