def __init__(self, generator, dry, always):
        """
        Constructor. Parameters:
            * generator - The page generator that determines on which pages
                          to work on.
            * dry       - If True, doesn't do any real changes, but only shows
                          what would have been changed.
            * always    - If True, don't prompt for each redirect page.
        """
        self.generator = generator
        self.dry = dry
        self.always = always
        self.lang = pywikibot.getSite().lang
        
        # Set the edit summary message
        self.summary = pywikibot.translate(pywikibot.getSite(), self.msg)
        self.templates = pywikibot.translate(pywikibot.getSite(), self.taxoboxTemplates)
        self.templateParameters = pywikibot.translate(pywikibot.getSite(), self.sciNameParameters)

        # Initialize the cache
        try:
            self.cache = pickle.load(file(self.cacheFilename, 'rb'))
        except:
            self.cache = {}
        if not self.lang in self.cache:
            self.cache[self.lang] = {}

 def treat(self):
     page = pywikibot.Page(self.site, self.your_page)
     if page.exists():
         pywikibot.output(
             u"\nWikitable on \03{lightpurple}%s\03{default} will be " u"completed with:\n" % self.your_page
         )
         text = page.get()
         newtext = self.newraw()
         pywikibot.output(newtext)
         choice = pywikibot.inputChoice(u"Do you want to add these on wikitable?", ["Yes", "No"], ["y", "N"], "N")
         text = text[:-3] + newtext
         summ = pywikibot.translate(self.site, summary_update)
         if choice == "y":
             try:
                 page.put(u"".join(text), summ)
             except:
                 pywikibot.output(u"Impossible to edit. It may be an " u"edit conflict. Skipping...")
     else:
         pywikibot.output(
             u"\nWikitable on \03{lightpurple}%s\03{default} will be " u"created with:\n" % self.your_page
         )
         newtext = self.newtable() + self.newraw()
         pywikibot.output(newtext)
         summ = pywikibot.translate(self.site, summary_creation)
         choice = pywikibot.inputChoice(u"Do you want to accept this page creation?", ["Yes", "No"], ["y", "N"], "N")
         if choice == "y":
             try:
                 page.put(newtext, summ)
             except pywikibot.LockedPage:
                 pywikibot.output(u"Page %s is locked; skipping." % title)
             except pywikibot.EditConflict:
                 pywikibot.output(u"Skipping %s because of edit conflict" % title)
             except pywikibot.SpamfilterError, error:
                 pywikibot.output(u"Cannot change %s because of spam " u"blacklist entry %s" % (title, error.url))

    def reportBadAccount(self, name=None, final=False):
        #Queue process
        if name:
            if globalvar.confirm:
                answer = pywikibot.inputChoice(
                    u'%s may have an unwanted username, do you want to report '
                    u'this user?' % name,
                    ['Yes', 'No', 'All'], ['y', 'N', 'a'], 'N')
                if answer in ['a', 'all']:
                    answer = 'y'
                    globalvar.confirm = False
            else:
                answer = 'y'

            if answer.lower() in ['yes', 'y'] or not globalvar.confirm:
                showStatus()
                pywikibot.output(
                    u'%s is possibly an unwanted username. It will be reported.'
                    % name)
                if hasattr(self, '_BAQueue'):
                    self._BAQueue.append(name)
                else:
                    self._BAQueue = [name]

        if len(self._BAQueue) >= globalvar.dumpToLog or final:
            rep_text = ''
            # name in queue is max, put detail to report page
            pywikibot.output("Updating badname accounts to report page...")
            rep_page = pywikibot.Page(self.site,
                                      pywikibot.translate(self.site,
                                                          report_page))
            if rep_page.exists():
                text_get = rep_page.get()
            else:
                text_get = u'This is a report page for the Bad-username, please translate me. --~~~'
            pos = 0
            # The talk page includes "_" between the two names, in this way i
            # replace them to " ".
            for usrna in self._BAQueue:
                username = pywikibot.url2link(usrna, self.site, self.site)
                n = re.compile(re.escape(username), re.UNICODE)
                y = n.search(text_get, pos)
                if y:
                    pywikibot.output(u'%s is already in the report page.'
                                     % username)
                else:
                    # Adding the log.
                    rep_text += pywikibot.translate(self.site, report_text) % username
                    if self.site.code == 'it':
                        rep_text = "%s%s}}" % (rep_text, self.bname[username])

            com = i18n.twtranslate(self.site, 'welcome-bad_username')
            if rep_text != '':
                rep_page.put(text_get + rep_text, comment=com, force=True,
                             minorEdit=True)
                showStatus(5)
                pywikibot.output(u'Reported')
            self.BAQueue = list()
        else:
            return True

    def __init__(self, generator, oldImage, newImage=None, summary='',
                 always=False, loose=False):
        """
        Arguments:
            * generator - A page generator.
            * oldImage  - The title of the old image (without namespace)
            * newImage  - The title of the new image (without namespace), or
                          None if you want to remove the image.
        """
        self.generator = generator
        self.oldImage = oldImage
        self.newImage = newImage
        self.editSummary = summary
        self.summary = summary
        self.always = always
        self.loose = loose

        # get edit summary message
        mysite = pywikibot.getSite()
        if summary:
            self.editSummary = summary
        elif self.newImage:
            self.editSummary = pywikibot.translate(mysite, self.msg_replace) \
            % (self.oldImage, self.newImage)
        else:
            self.editSummary = pywikibot.translate(mysite, self.msg_remove) \
            % self.oldImage

    def __init__(self, generator, **kwargs):
        """
        - generator : Page generator

        """
        self.availableOptions.update({
            'ignorepdf': False,  # boolean
            'limit': None,  # int, stop after n modified pages
            'summary': None,
        })

        super(ReferencesRobot, self).__init__(**kwargs)
        self.generator = generator
        self.site = pywikibot.Site()
        # Check
        manual = 'mw:Manual:Pywikibot/refLinks'
        code = None
        for alt in [self.site.code] + i18n._altlang(self.site.code):
            if alt in localized_msg:
                code = alt
                break
        if code:
            manual += '/%s' % code
        if self.getOption('summary') is None:
            self.msg = i18n.twtranslate(self.site, 'reflinks-msg', locals())
        else:
            self.msg = self.getOption('summary')
        self.stopPage = pywikibot.Page(self.site,
                                       pywikibot.translate(self.site, stopPage))

        local = pywikibot.translate(self.site, badtitles)
        if local:
            bad = '(' + globalbadtitles + '|' + local + ')'
        else:
            bad = globalbadtitles
        self.titleBlackList = re.compile(bad, re.I | re.S | re.X)
        self.norefbot = noreferences.NoReferencesBot(None, verbose=False)
        self.deduplicator = DuplicateReferences()
        try:
            self.stopPageRevId = self.stopPage.latestRevision()
        except pywikibot.NoPage:
            pywikibot.output(u'The stop page %s does not exist'
                             % self.stopPage.title(asLink=True))
            raise

        # Regex to grasp content-type meta HTML tag in HTML source
        self.META_CONTENT = re.compile(r'(?i)<meta[^>]*content\-type[^>]*>')
        # Extract the encoding from a charset property (from content-type !)
        self.CHARSET = re.compile(r'(?i)charset\s*=\s*(?P<enc>[^\'";>/]*)')
        # Extract html title from page
        self.TITLE = re.compile(r'(?is)(?<=<title>).*?(?=</title>)')
        # Matches content inside <script>/<style>/HTML comments
        self.NON_HTML = re.compile(
            r'(?is)<script[^>]*>.*?</script>|<style[^>]*>.*?</style>|<!--.*?-->|<!\[CDATA\[.*?\]\]>')

        # Authorized mime types for HTML pages
        self.MIME = re.compile(
            r'application/(?:xhtml\+xml|xml)|text/(?:ht|x)ml')

    def setSummaryMessage(self, disambPage, new_targets=[], unlink=False,
                          dn=False):
        # make list of new targets
        targets = ''
        for page_title in new_targets:
            targets += u'[[%s]], ' % page_title
        # remove last comma
        targets = targets[:-2]

        if not targets:
            targets = i18n.twtranslate(self.mysite, 'solve_disambiguation-unknown-page')

        # first check whether user has customized the edit comment
        if (self.mysite.family.name in config.disambiguation_comment and
                self.mylang in config.disambiguation_comment[self.mysite.family.name]):
            try:
                self.comment = pywikibot.translate(
                    self.mysite,
                    config.disambiguation_comment[self.mysite.family.name]
                ) % (disambPage.title(), targets)

            # Backwards compatibility, type error probably caused by too
            # many arguments for format string
            except TypeError:
                self.comment = pywikibot.translate(
                    self.mysite,
                    config.disambiguation_comment[self.mysite.family.name]
                ) % disambPage.title()
        elif disambPage.isRedirectPage():
            # when working on redirects, there's another summary message
            if unlink and not new_targets:
                self.comment = i18n.twtranslate(
                    self.mysite,
                    'solve_disambiguation-redirect-removed',
                    {'from': disambPage.title()}
                )
            elif dn and not new_targets:
                self.comment = i18n.twtranslate(
                    self.mysite,
                    'solve_disambiguation-redirect-adding-dn-template',
                    {'from': disambPage.title()}
                )
            else:
                self.comment = i18n.twtranslate(self.mysite, 'solve_disambiguation-redirect-resolved', {'from': disambPage.title(), 'to': targets})
        else:
            if unlink and not new_targets:
                self.comment = i18n.twtranslate(self.mysite, 'solve_disambiguation-links-removed', {'from': disambPage.title()})
            elif dn and not new_targets:
                self.comment = i18n.twtranslate(self.mysite, 'solve_disambiguation-adding-dn-template', {'from': disambPage.title()})
            else:
                self.comment = i18n.twtranslate(self.mysite, 'solve_disambiguation-links-resolved', {'from': disambPage.title(), 'to': targets})

 def run(self):
     while True:
         wait = False
         now = time.strftime("%d %b %Y %H:%M:%S (UTC)", time.gmtime())
         localSandboxTitle = pywikibot.translate(self.site, sandboxTitle)
         if type(localSandboxTitle) is list:
             titles = localSandboxTitle
         else:
             titles = [localSandboxTitle,]
         for title in titles:
             sandboxPage = pywikibot.Page(self.site, title)
             try:
                 text = sandboxPage.get()
                 translatedContent = pywikibot.translate(self.site, content)
                 translatedMsg = i18n.twtranslate(self.site,
                                                  'clean_sandbox-cleaned')
                 subst = 'subst:' in translatedContent
                 if text.strip() == translatedContent.strip():
                     pywikibot.output(u'The sandbox is still clean, no change necessary.')
                 elif subst and sandboxPage.userName() == self.site.user():
                     pywikibot.output(u'The sandbox might be clean, no change necessary.')
                 elif text.find(translatedContent.strip()) <> 0 and not subst:
                     sandboxPage.put(translatedContent, translatedMsg)
                     pywikibot.showDiff(text, translatedContent)
                     pywikibot.output(u'Standard content was changed, sandbox cleaned.')
                 else:
                     edit_delta = datetime.datetime.utcnow() - \
                                 pywikibot.Timestamp.fromISOformat(sandboxPage.editTime())
                     delta = self.getOption('delay_td') - edit_delta
                     #Is the last edit more than 'delay' minutes ago?
                     if delta <= datetime.timedelta(0):
                         sandboxPage.put(translatedContent, translatedMsg)
                         pywikibot.showDiff(text, translatedContent)
                     else: #wait for the rest
                         pywikibot.output(u'Sandbox edited %.1f minutes ago...' % \
                                             (edit_delta.seconds / 60.0))
                         pywikibot.output(u'Sleeping for %d minutes.' % (delta.seconds/60))
                         time.sleep(delta.seconds)
                         wait = True
             except pywikibot.EditConflict:
                 pywikibot.output(u'*** Loading again because of edit conflict.\n')
         if self.getOption('no_repeat'):
             pywikibot.output(u'\nDone.')
             return
         elif not wait:
             if self.getOption('hours') < 1.0:
                 pywikibot.output('\nSleeping %s minutes, now %s' % ((self.getOption('hours')*60), now))
             else:
                 pywikibot.output('\nSleeping %s hours, now %s' % (self.getOption('hours'), now))
             time.sleep(self.getOption('hours') * 60 * 60)

 def changeCommonscat(self, page=None, oldtemplate=u'', oldcat=u'',
                      newtemplate=u'', newcat=u'', linktitle=u'',
                      description=u''):
     """ Change the current commonscat template and target. """
     if oldcat == '3=S' or linktitle == '3=S':
         return  # additional param on de-wiki, TODO: to be handled
     if not linktitle and (page.title().lower() in oldcat.lower() or
                           oldcat.lower() in page.title().lower()):
         linktitle = oldcat
     if linktitle and newcat != page.title(withNamespace=False):
         newtext = re.sub(u'(?i)\{\{%s\|?[^{}]*(?:\{\{.*\}\})?\}\}'
                          % oldtemplate,
                          u'{{%s|%s|%s}}' % (newtemplate, newcat, linktitle),
                          page.get())
     elif newcat == page.title(withNamespace=False):
         newtext = re.sub(u'(?i)\{\{%s\|?[^{}]*(?:\{\{.*\}\})?\}\}'
                          % oldtemplate,
                          u'{{%s}}' % newtemplate,
                          page.get())
     elif oldcat.strip() != newcat:  # strip trailing white space
         newtext = re.sub(u'(?i)\{\{%s\|?[^{}]*(?:\{\{.*\}\})?\}\}'
                          % oldtemplate,
                          u'{{%s|%s}}' % (newtemplate, newcat),
                          page.get())
     else:  # nothing left to do
         return
     if self.summary:
         comment = self.summary
     else:
         comment = pywikibot.translate(page.site,
                                       msg_change,
                                       fallback=True) % {'oldcat': oldcat,
                                                         'newcat': newcat}
     self.save(newtext, page, comment)

def appendtext(page, apptext):
    global always
    if page.isRedirectPage():
        page = page.getRedirectTarget().encode("utf-8")
    if not page.exists():
        if page.isTalkPage():
            text = u''
        else:
            raise pywikibot.NoPage(u"Page '%s' does not exist" % page.title())
    else:
        text = page.get()
    # Here you can go editing. If you find you do not
    # want to edit this page, just return
    oldtext = text
    text += apptext
    if text != oldtext:
        pywikibot.showDiff(oldtext, text)
        if not always:
            choice = pywikibot.inputChoice(
                u'Do you want to accept these changes?', ['Yes', 'No', 'All'],
                ['y', 'N', 'a'], 'N')
            if choice == 'a':
                always = True
        if always or choice == 'y':
            page.put(text, pywikibot.translate(pywikibot.getSite(), comment))

 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 __init__(self, **kwargs):
        super(SandboxBot, self).__init__(**kwargs)
        if self.getOption('delay') is None:
            d = min(15, max(5, int(self.getOption('hours') * 60)))
            self.availableOptions['delay_td'] = datetime.timedelta(minutes=d)
        else:
            d = max(5, self.getOption('delay'))
            self.availableOptions['delay_td'] = datetime.timedelta(minutes=d)

        self.site = pywikibot.Site()
        self.site.login()
        if self.getOption('user'):
            localSandboxTitle = pywikibot.translate(self.site,
                                                    user_sandboxTemplate,
                                                    fallback=False)
            localSandbox = pywikibot.Page(self.site, localSandboxTitle)
            content.update(user_content)
            sandboxTitle[self.site.lang] = [item.title() for item in
                                            localSandbox.getReferences(
                                                onlyTemplateInclusion=True)]
            if self.site.lang not in user_sandboxTemplate:
                content[self.site.code] = None
                pywikibot.output(
                    u'Not properly set-up to run in user namespace!')
        if sandboxTitle.get(self.site.code) is None or content.get(
                self.site.code) is None:
            pywikibot.output(u'This bot is not configured for the given site '
                             u'(%s), exiting.' % self.site)
            sys.exit(0)

 def run(self):
     for page in self.generator:
         try:
             # get the page, and save it using the unmodified text.
             # whether or not getting a redirect throws an exception
             # depends on the variable self.touch_redirects.
             text = page.get()
             originalText = text
             for url in weblinkchecker.weblinksIn(text,
                                                  withoutBracketed=True):
                 filename = url.split('/')[-1]
                 description = pywikibot.translate(pywikibot.getSite(), msg) % url
                 bot = upload.UploadRobot(url, description=description)
                 # TODO: check duplicates
                 #filename = bot.uploadImage()
                 #if filename:
                 #    text = text.replace(url, u'[[Image:%s]]' % filename) #
             # only save if there were changes
             #if text != originalText:
             #    page.put(text)
         except pywikibot.NoPage:
             print "Page %s does not exist?!" % page.title(asLink=True)
         except pywikibot.IsRedirectPage:
             print "Page %s is a redirect; skipping." \
                   % page.title(asLink=True)
         except pywikibot.LockedPage:
             print "Page %s is locked?!" % page.title(asLink=True)

 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 format_date(self, day, monthName, year):
     """
     return a string with the formated date (e.g. u'31. Dezember 2013')
     """
     l_dateformat = pywikibot.translate(self.site, dateformat,
             fallback=False)
     return l_dateformat.format(day=day, monthName=monthName, year=year)

    def __init__(self):
        self.site = pywikibot.Site()
        self.site.login()

        self.commons = self.site.image_repository()

        self.localtz = tz.gettz('Europe/Berlin')
        startdate = datetime(2014,  4, 26, 23, 59, 59, tzinfo=self.localtz)
        enddate   = datetime(2014,  4, 22, 23, 59, 59, tzinfo=self.localtz)

        self.reportPage = pywikibot.Page(self.site, redlinksPage)

        l_mainPageTitle = pywikibot.translate(self.site, mainPageTitle,
                fallback=False)
        self.mainPage = pywikibot.Page(self.site, l_mainPageTitle)
        self.mainversions = self.mainPage.getVersionHistory()

        NumTitle = u'Benutzer:SchirmerPower/Artikelanzahl tgl dewp (Hochrechnung)'
        NumPage = pywikibot.Page(self.site, NumTitle)
        self.numberofarticles = dict(re.findall(r'(\d{1,2}\.[\D\s]*?\d{4})\t(\d\.\d{3}\.\d{3})',
            NumPage.text))

        day = startdate
        while day != enddate:
            self.snap(day)
            day -= relativedelta(days=1)

        #print sump.encode('utf-8')
        print self.reportPage.text.encode('utf-8')

def main(*args):
    """
    Process command line arguments and invoke bot.

    If args is an empty list, sys.argv is used.

    @param args: command line arguments
    @type args: list of unicode
    """
    # Generate the question text
    questions = '\n'
    questionlist = {}
    pywikibot.handle_args(*args)
    site = pywikibot.Site()

    if (site.lang not in list(templates.keys()) and
            site.lang not in list(done.keys())):
        pywikibot.output(
            '\nScript is not localised for {0}. Terminating program.'
            ''.format(site))
    else:
        for i, t in enumerate(pywikibot.translate(site.lang, templates)):
            questions += (u'%s) %s\n' % (i, t))
            questionlist[i] = t
        bot = CleaningBot(questions, questionlist)
        bot.run()

    def run(self):
        site = pywikibot.getSite()
        newCat = catlib.Category(pywikibot.Link('Category:' + self.newCatTitle))
        # set edit summary message
        if not self.editSummary:
            self.editSummary = i18n.twtranslate(site, 'category-replacing',\
                                {'oldcat':self.oldCat.title(),
                                 'newcat':newCat.title()})

        # Copy the category contents to the new category page
        copied = False
        oldMovedTalk = None
        if self.oldCat.exists() and self.moveCatPage:
            copied = self.oldCat.copyAndKeep(
                            self.newCatTitle,
                            pywikibot.translate(site, cfd_templates),
                            i18n.twtranslate(site, 'category-renamed')
                     )
            # Also move the talk page
            if copied:
                reason = i18n.twtranslate(site, 'category-was-moved', \
                         {'newcat':self.newCatTitle, 'title':self.newCatTitle})
                oldTalk = self.oldCat.toggleTalkPage()
                if oldTalk.exists():
                    newTalkTitle = newCat.toggleTalkPage().title()
                    try:
                        talkMoved = oldTalk.move(newTalkTitle, reason)
                    except (pywikibot.NoPage, pywikibot.PageNotSaved), e:
                        #in order :
                        #Source talk does not exist, or
                        #Target talk already exists
                        pywikibot.output(e.message)
                    else:
                        if talkMoved:
                            oldMovedTalk = oldTalk

    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 __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 makelogpage(self, queue=None):
        if queue is None:
            queue = []
        if not globalvar.makeWelcomeLog or len(queue) == 0:
            return

        text = u''
        logg = pywikibot.translate(self.site, logbook)
        if not logg:
            return

        target = logg + '/' + time.strftime('%Y/%m/%d',
                                            time.localtime(time.time()))
        if self.site.code == 'it':
            target = logg + '/' + time.strftime('%d/%m/%Y',
                                                time.localtime(time.time()))

        logPage = pywikibot.Page(self.site, target)
        if logPage.exists():
            text = logPage.get()
        else:
            #make new log page
            showStatus()
            pywikibot.output(
                'Log page is not exist, getting information for page creation')
            text = pywikibot.translate(self.site, logpage_header)
            text += u'\n!%s' % self.site.namespace(2)
            text += u'\n!%s' % capitalize(
                self.site.mediawiki_message('contribslink'))

        for result in queue:
            # Adding the log... (don't take care of the variable's name...).
            luser = pywikibot.url2link(result.name(), self.site, self.site)
            text += u'\n{{WLE|user=%s|contribs=%d}}' % (
                luser, result.editCount())
        #update log page.
        while True:
            try:
                logPage.put(text, i18n.twtranslate(self.site,
                                                   'welcome-updating'))
                return True
            except pywikibot.EditConflict:
                pywikibot.output(u'An edit conflict has occured. Pausing for '
                                 u'10 seconds before continuing.')
                time.sleep(10)