def __init__(self, generator, **kwargs):
        self.availableOptions.update({
            'enablePage': None,    # Check if someone set an enablePage or not
            'disambigPage': None,  # If no disambigPage given, not use it.
        })
        super(LonelyPagesBot, self).__init__(**kwargs)
        self.generator = generator

        # Take the configurations according to our project
        self.site = pywikibot.Site()
        if self.getOption('enablePage'):
            self.options['enablePage'] = pywikibot.Page(
                self.site, self.getOption('enablePage'))
        self.comment = i18n.twtranslate(
            self.site, 'lonelypages-comment-add-template')
        self.commentdisambig = i18n.twtranslate(
            self.site, 'lonelypages-comment-add-disambig-template')
        self.template = i18n.translate(self.site, template)
        self.exception = i18n.translate(self.site, exception_regex)
        if self.template is None or self.exception is None:
            pywikibot.showHelp()
            sys.exit(u'Missing configuration for site %s' % self.site)
        # DisambigPage part
        if self.getOption('disambigPage') is not None:
            self.disambigpage = pywikibot.Page(self.site, self.getOption('disambigPage'))
            try:
                self.disambigtext = self.disambigpage.get()
            except pywikibot.NoPage:
                pywikibot.output(u"%s doesn't esist, skip!" % self.disambigpage.title())
                self.disambigtext = ''
            except pywikibot.IsRedirectPage:
                pywikibot.output(u"%s is a redirect, don't use it!"
                                 % self.disambigpage.title())
                self.options['disambigPage'] = None

    def __init__(self, generator, old_image, new_image=None, **kwargs):
        """
        Constructor.

        @param generator: the pages to work on
        @type  generator: iterable
        @param old_image: the title of the old image (without namespace)
        @type  old_image: unicode
        @param new_image: the title of the new image (without namespace), or
                          None if you want to remove the image
        @type  new_image: unicode or None
        """
        self.availableOptions.update({
            'summary': None,
            'loose': False,
        })
        super(ImageRobot, self).__init__(**kwargs)

        self.generator = generator
        self.site = pywikibot.Site()
        self.old_image = old_image
        self.new_image = new_image

        if not self.getOption('summary'):
            if self.new_image:
                self.options['summary'] = i18n.translate(self.site, self.msg_replace,
                                                         fallback=True) \
                % (self.old_image, self.new_image)
            else:
                self.options['summary'] = i18n.translate(self.site, self.msg_remove,
                                                         fallback=True) \
                % self.old_image

    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.Site()
        if summary:
            self.editSummary = summary
        elif self.newImage:
            self.editSummary = i18n.translate(mysite, self.msg_replace,
                                              fallback=True) \
            % (self.oldImage, self.newImage)
        else:
            self.editSummary = i18n.translate(mysite, self.msg_remove,
                                              fallback=True) \
            % self.oldImage

 def testSemiLocalized(self):
     self.assertEqual(i18n.translate('en', self.msg_semi_localized),
                      u'test-semi-localized EN')
     self.assertEqual(i18n.translate('nl', self.msg_semi_localized),
                      u'test-semi-localized NL')
     self.assertEqual(i18n.translate('fy', self.msg_semi_localized),
                      u'test-semi-localized NL')

 def testLocalized(self):
     self.assertEqual(i18n.translate('en', self.msg_localized),
                      u'test-localized EN')
     self.assertEqual(i18n.translate('nl', self.msg_localized),
                      u'test-localized NL')
     self.assertEqual(i18n.translate('fy', self.msg_localized),
                      u'test-localized FY')

 def run(self):
     """Start the bot."""
     template_image = i18n.translate(self.site,
                                     template_to_the_image)
     template_user = i18n.translate(self.site,
                                    template_to_the_user)
     summary = i18n.translate(self.site, comment, fallback=True)
     if not all([template_image, template_user, comment]):
         raise pywikibot.Error(u'This script is not localized for %s site.'
                               % self.site)
     self.summary = summary
     generator = pagegenerators.UnusedFilesGenerator(site=self.site)
     generator = pagegenerators.PreloadingGenerator(generator)
     for image in generator:
         if not image.exists():
             pywikibot.output(u"File '%s' does not exist (see bug 69133)."
                              % image.title())
             continue
         # Use fileUrl() and fileIsShared() to confirm it is local media
         # rather than a local page with the same name as shared media.
         if (image.fileUrl() and not image.fileIsShared() and
                 u'http://' not in image.text):
             if template_image in image.text:
                 pywikibot.output(u"%s done already"
                                  % image.title(asLink=True))
                 continue
             self.append_text(image, u"\n\n" + template_image)
             uploader = image.getFileVersionHistory().pop(0)['user']
             user = pywikibot.User(image.site, uploader)
             usertalkpage = user.getUserTalkPage()
             msg2uploader = template_user % {'title': image.title()}
             self.append_text(usertalkpage, msg2uploader)

 def testNoEnglish(self):
     self.assertEqual(i18n.translate('en', self.msg_no_english),
                      u'test-no-english JA')
     self.assertEqual(i18n.translate('fy', self.msg_no_english),
                      u'test-no-english JA')
     self.assertEqual(i18n.translate('nl', self.msg_no_english),
                      u'test-no-english JA')

def main():
    always = False

    for arg in pywikibot.handleArgs():
        if arg == '-always':
            always = True

    mysite = pywikibot.Site()
    # If anything needs to be prepared, you can do it here
    template_image = i18n.translate(pywikibot.Site(),
                                    template_to_the_image)
    template_user = i18n.translate(pywikibot.Site(),
                                   template_to_the_user)
    except_text_translated = i18n.translate(pywikibot.Site(), except_text)
    if not(template_image and template_user and except_text_translated):
        pywikibot.warning(u'This script is not localized for %s site.' % mysite)
        return
    generator = pagegenerators.UnusedFilesGenerator()
    generator = pagegenerators.PreloadingGenerator(generator)
    for image in generator:
        if (except_text_translated.encode('utf-8')
                not in image.getImagePageHtml() and
                u'http://' not in image.text):
            pywikibot.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
                             % image.title())
            if template_image in image.text:
                pywikibot.output(u"%s done already"
                                 % image.title(asLink=True))
                continue
            appendtext(image, u"\n\n" + template_image, always)
            uploader = image.getFileVersionHistory().pop(0)['user']
            user = pywikibot.User(mysite, uploader)
            usertalkpage = user.getUserTalkPage()
            msg2uploader = template_user % {'title': image.title()}
            appendtext(usertalkpage, msg2uploader, always)

 def run(self):
     template_image = i18n.translate(self.site,
                                     template_to_the_image)
     template_user = i18n.translate(self.site,
                                    template_to_the_user)
     except_text_translated = i18n.translate(self.site, except_text)
     summary = i18n.translate(self.site, comment, fallback=True)
     if not all([template_image, template_user, except_text_translated, comment]):
         raise pywikibot.Error(u'This script is not localized for %s site.'
                               % self.site)
     self.summary = summary
     generator = pagegenerators.UnusedFilesGenerator(site=self.site)
     generator = pagegenerators.PreloadingGenerator(generator)
     for image in generator:
         if not image.exists():
             pywikibot.output(u"File '%s' does not exist (see bug 69133)."
                              % image.title())
             continue
         if (except_text_translated.encode('utf-8')
                 not in image.getImagePageHtml() and
                 u'http://' not in image.text):
             if template_image in image.text:
                 pywikibot.output(u"%s done already"
                                  % image.title(asLink=True))
                 continue
             self.append_text(image, u"\n\n" + template_image)
             uploader = image.getFileVersionHistory().pop(0)['user']
             user = pywikibot.User(image.site, uploader)
             usertalkpage = user.getUserTalkPage()
             msg2uploader = template_user % {'title': image.title()}
             self.append_text(usertalkpage, msg2uploader)

    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()
        self._use_fake_user_agent = config.fake_user_agent_default.get('reflinks', False)
        # 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')

        local = i18n.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()

        self.site_stop_page = i18n.translate(self.site, stop_page)
        if self.site_stop_page:
            self.stop_page = pywikibot.Page(self.site, self.site_stop_page)
            if self.stop_page.exists():
                self.stop_page_rev_id = self.stop_page.latest_revision_id
            else:
                pywikibot.warning('The stop page %s does not exist'
                                  % self.stop_page.title(asLink=True))

        # Regex to grasp content-type meta HTML tag in HTML source
        self.META_CONTENT = re.compile(br'(?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(
            br'(?is)<script[^>]*>.*?</script>|<style[^>]*>.*?</style>|'
            br'<!--.*?-->|<!\[CDATA\[.*?\]\]>')

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

 def testNonLocalized(self):
     self.assertEqual(i18n.translate('en', self.msg_non_localized),
                      u'test-non-localized EN')
     self.assertEqual(i18n.translate('fy', self.msg_non_localized),
                      u'test-non-localized EN')
     self.assertEqual(i18n.translate('nl', self.msg_non_localized),
                      u'test-non-localized EN')
     self.assertEqual(i18n.translate('ru', self.msg_non_localized),
                      u'test-non-localized EN')

    def reportBadAccount(self, name=None, final=False):
        # Queue process
        if name:
            if globalvar.confirm:
                answer = pywikibot.input_choice(
                    "%s may have an unwanted username, do you want to report " "this user?" % name,
                    [("Yes", "y"), ("No", "n"), ("All", "a")],
                    "n",
                    automatic_quit=False,
                )
                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("%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, i18n.translate(self.site, report_page))
            if rep_page.exists():
                text_get = rep_page.get()
            else:
                text_get = "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("%s is already in the report page." % username)
                else:
                    # Adding the log.
                    rep_text += i18n.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, summary=com, force=True, minorEdit=True)
                showStatus(5)
                pywikibot.output("Reported")
            self.BAQueue = list()
        else:
            return True

 def testNoEnglish(self):
     """Test translate with missing English text."""
     self.assertEqual(i18n.translate('en', self.msg_no_english,
                                     fallback=True),
                      u'test-no-english JA')
     self.assertEqual(i18n.translate('fy', self.msg_no_english,
                                     fallback=True),
                      u'test-no-english JA')
     self.assertEqual(i18n.translate('nl', self.msg_no_english,
                                     fallback=True),
                      u'test-no-english JA')

 def testSemiLocalized(self):
     """Test translate by fallback to an alternative language."""
     self.assertEqual(i18n.translate('en', self.msg_semi_localized,
                                     fallback=True),
                      u'test-semi-localized EN')
     self.assertEqual(i18n.translate('nl', self.msg_semi_localized,
                                     fallback=True),
                      u'test-semi-localized NL')
     self.assertEqual(i18n.translate('fy', self.msg_semi_localized,
                                     fallback=True),
                      u'test-semi-localized NL')

 def testLocalized(self):
     """Test fully localized translations."""
     self.assertEqual(i18n.translate('en', self.msg_localized,
                                     fallback=True),
                      u'test-localized EN')
     self.assertEqual(i18n.translate('nl', self.msg_localized,
                                     fallback=True),
                      u'test-localized NL')
     self.assertEqual(i18n.translate('fy', self.msg_localized,
                                     fallback=True),
                      u'test-localized FY')

def log(user, pages):
    talk = user.getUserTalkPage()
    titles = [page.title() for page in pages]
    notice = translate(talk.site, msg['notice']).format(titles=titles)
    text = talk.get(force=True)
    if notice in talk.text:
        pywikibot.output(u'\03{lightgreen}already logged')
        return
    header = translate()
    talk.text += u'\n\n== {} ==\n\n{} --~~~~'.format(header, notice)
    pywikibot.showDiff(text, talk.text)
    comment = translate(talk.site, msg['comment'], [bot_link(user.site)])
    talk.save(comment=comment, minor=False, botflag=True)

    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 = i18n.translate(
                    self.mysite,
                    config.disambiguation_comment[self.mysite.family.name],
                    fallback=True) % (disambPage.title(), targets)

            # Backwards compatibility, type error probably caused by too
            # many arguments for format string
            except TypeError:
                self.comment = i18n.translate(
                    self.mysite,
                    config.disambiguation_comment[self.mysite.family.name],
                    fallback=True) % 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 __init__(self, generator, **kwargs):
        """- generator : Page generator."""
        self.availableOptions.update(
            {"ignorepdf": False, "limit": None, "summary": None}  # boolean  # int, stop after n modified pages
        )

        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, i18n.translate(self.site, stopPage))

        local = i18n.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.latest_revision_id
        except pywikibot.NoPage:
            pywikibot.output("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(br"(?i)<meta[^>]*content\-type[^>]*>")
        # Extract the encoding from a charset property (from content-type !)
        self.CHARSET = re.compile(br'(?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(
            br"(?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 testNonLocalized(self):
     """Test translate with missing localisation."""
     self.assertEqual(i18n.translate('en', self.msg_non_localized,
                                     fallback=True),
                      u'test-non-localized EN')
     self.assertEqual(i18n.translate('fy', self.msg_non_localized,
                                     fallback=True),
                      u'test-non-localized EN')
     self.assertEqual(i18n.translate('nl', self.msg_non_localized,
                                     fallback=True),
                      u'test-non-localized EN')
     self.assertEqual(i18n.translate('ru', self.msg_non_localized,
                                     fallback=True),
                      u'test-non-localized EN')

    def run(self):
        for user in self.parseNewUserLog():
            #print user.name()
            if user.isBlocked():
                #showStatus(3)
                pywikibot.output(u"%s is blocked; skipping." % user.name())
                continue
            if "bot" in user.groups():
                #showStatus(3)
                pywikibot.output(u"%s is a bot; skipping." % user.name())
                continue
            if "bot" in user.name().lower():
                #showStatus(3)
                pywikibot.output(u"%s is probably a bot; skipping." % user.name())
                continue
            if user.editCount() >= globalsettings['reqEditCount']:
                #showStatus(2)
                pywikibot.output(u"%s has enough edits to be welcomed." % user.name())
                ustp =  user.getUserTalkPage()
                if ustp.exists():
                    #showStatus(3)
                    pywikibot.output(u"%s has been already welcomed; skipping." % user.name())
                    continue
                else:
                    welcome_text = i18n.translate(self.site, welcomemsg)
                    welcome_school_text = i18n.translate(self.site, welcomeschoolmsg)
                    if welcome_school_text != None:
                        discrim = i18n.translate(self.site, schooldiscriminator)
                        if discrim != None and re.match(discrim, user.name().lower()): #if the discriminator exists and is present in username
                            pywikibot.output(u"%s is a maybe a school related account; using school welcoming templatei instead." % user.name())
                            welcome_text = welcome_school_text
                    if globalsettings['randomSign'] and len(self.signList) > 0:
                        sign = choice(self.signList)
                    else:
                        sign = globalsettings['defaultSign']

                    welcome_text = (welcome_text % sign)
                    welcome_cmnt = u"Robot: " + i18n.twtranslate(self.site,'welcome-welcome')

                    #print welcome_text
                    #print welcome_cmnt
                    ustp.text = welcome_text
                    
                    try:
                        ustp.save(welcome_cmnt,minor=False)
                        pass
                    except pywikibot.EditConflict:
                        pywikibot.output(u"An edit conflict has occurred, "
                                             u"skipping %s." % user.name())