def main():
    genFactory = pagegenerators.GeneratorFactory()
    pageName = ''
    summary = None
    always = False
    undelete = False
    generator = None

    # read command line parameters
    local_args = pywikibot.handleArgs()
    mysite = pywikibot.Site()

    for arg in local_args:
        if arg == '-always':
            always = True
        elif arg.startswith('-summary'):
            if len(arg) == len('-summary'):
                summary = pywikibot.input(u'Enter a reason for the deletion:')
            else:
                summary = arg[len('-summary:'):]
        elif arg.startswith('-images'):
            pywikibot.output('\n\03{lightred}-image option is deprecated. '
                             'Please use -imageused instead.\03{default}\n')
            local_args.append('-imageused' + arg[7:])
        elif arg.startswith('-undelete'):
            undelete = True
        else:
            genFactory.handleArg(arg)
            found = arg.find(':') + 1
            if found:
                pageName = arg[found:]

        if not summary:
            if pageName:
                if arg.startswith('-cat') or arg.startswith('-subcats'):
                    summary = i18n.twtranslate(mysite, 'delete-from-category',
                                               {'page': pageName})
                elif arg.startswith('-links'):
                    summary = i18n.twtranslate(mysite, 'delete-linked-pages',
                                               {'page': pageName})
                elif arg.startswith('-ref'):
                    summary = i18n.twtranslate(mysite, 'delete-referring-pages',
                                               {'page': pageName})
                elif arg.startswith('-imageused'):
                    summary = i18n.twtranslate(mysite, 'delete-images',
                                               {'page': pageName})
            elif arg.startswith('-file'):
                summary = i18n.twtranslate(mysite, 'delete-from-file')
    generator = genFactory.getCombinedGenerator()
    # We are just deleting pages, so we have no need of using a preloading
    # page generator to actually get the text of those pages.
    if generator:
        if summary is None:
            summary = pywikibot.input(u'Enter a reason for the %sdeletion:'
                                      % ['', 'un'][undelete])
        bot = DeletionRobot(generator, summary, always, undelete)
        bot.run()
    else:
        # Show help text from the top of this file
        pywikibot.showHelp()

    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 testSemiLocalized(self):
     self.assertEqual(i18n.twtranslate('en', 'test-semi-localized'),
                      u'test-semi-localized EN')
     self.assertEqual(i18n.twtranslate('nl', 'test-semi-localized'),
                      u'test-semi-localized NL')
     self.assertEqual(i18n.twtranslate('fy', 'test-semi-localized'),
                      u'test-semi-localized NL')

 def delete_redirect(self, page, summary_key):
     """Delete the redirect page."""
     assert page.site == self.site, (
         'target page is on different site {0}'.format(page.site))
     reason = i18n.twtranslate(self.site, summary_key)
     if page.site.logged_in(sysop=True):
         page.delete(reason, prompt=False)
     elif i18n.twhas_key(page.site,
                         'redirect-broken-redirect-template'):
         pywikibot.output(u"No sysop in user-config.py, "
                          u"put page to speedy deletion.")
         try:
             content = page.get(get_redirect=True)
         except pywikibot.SectionError:
             content_page = pywikibot.Page(page.site,
                                           page.title(withSection=False))
             content = content_page.get(get_redirect=True)
         # TODO: Add bot's signature if needed (Bug: T131517)
         content = i18n.twtranslate(
             page.site,
             'redirect-broken-redirect-template') + '\n' + content
         try:
             page.put(content, reason)
         except pywikibot.PageSaveRelatedError as e:
             pywikibot.error(e)
     else:
         pywikibot.output(
             u'No speedy deletion template available')

    def save(self, title, contents):
        """Upload page content."""
        mysite = pywikibot.Site()

        page = pywikibot.Page(mysite, title)
        self.current_page = page

        if self.getOption('summary'):
            comment = self.getOption('summary')
        else:
            comment = i18n.twtranslate(mysite, 'pagefromfile-msg')

        comment_top = comment + " - " + i18n.twtranslate(
            mysite, 'pagefromfile-msg_top')
        comment_bottom = comment + " - " + i18n.twtranslate(
            mysite, 'pagefromfile-msg_bottom')
        comment_force = "%s *** %s ***" % (
            comment, i18n.twtranslate(mysite, 'pagefromfile-msg_force'))

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

        if page.exists():
            if not self.getOption('redirect') and page.isRedirectPage():
                pywikibot.output(u"Page %s is redirect, skipping!" % title)
                return
            pagecontents = page.get(get_redirect=True)
            nocontent = self.getOption('nocontent')
            if nocontent and (
                    nocontent in pagecontents or
                    nocontent.lower() in pagecontents):
                pywikibot.output('Page has %s so it is skipped' % nocontent)
                return
            if self.getOption('append') == 'top':
                pywikibot.output(u"Page %s already exists, appending on top!"
                                 % title)
                contents = contents + pagecontents
                comment = comment_top
            elif self.getOption('append') == 'bottom':
                pywikibot.output(u"Page %s already exists, appending on bottom!"
                                 % title)
                contents = pagecontents + contents
                comment = comment_bottom
            elif self.getOption('force'):
                pywikibot.output(u"Page %s already exists, ***overwriting!"
                                 % title)
                comment = comment_force
            else:
                pywikibot.output(u"Page %s already exists, not adding!" % title)
                return
        else:
            if self.getOption('autosummary'):
                comment = ''
                config.default_edit_summary = ''

        self.userPut(page, page.text, contents,
                     summary=comment,
                     minor=self.getOption('minor'),
                     show_diff=False,
                     ignore_save_related_errors=True)

    def run(self):
        newCat = pywikibot.Category(self.site, self.newCatTitle)
        reason = i18n.twtranslate(self.site, 'category-was-moved') \
                     % {'newcat': self.newCatTitle, 'title': self.newCatTitle}

        self.editSummary = i18n.twtranslate(site, 'category-changing') \
                               % {'oldcat':self.oldCat.title(),
                                  'newcat':newCat.title()}

        copied = False
        oldMovedTalk = None
        if self.oldCat.exists():
            copied = copyAndKeep(self.oldCat, self.newCatTitle)
            if copied:
                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):
        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, sim=False, msg=None, EditFlags=bot_config['EditFlags']):
        """Run SubsterBot()."""

        pywikibot.output(
            u'\03{lightgreen}* Processing Template Backlink List:\03{default}')

        if sim:
            self.pagegen = ['dummy']

        for page in self.pagegen:
            # setup source to get data from
            if sim:
                content = sim['content']
                params = [sim]
            else:
                pywikibot.output(u'Getting page "%s" via API from %s...'
                                 % (page.title(asLink=True), self.site))

                # get page content and operating mode
                content = self.load(page)
                params = self.loadTemplates(
                    page,
                    self._bot_config['TemplateName'],
                    default=self._bot_config['param_default'])

            if not params:
                continue

            (substed_content, substed_tags) = self.subContent(content, params)

            # output result to page or return directly
            if sim:
                return substed_content
            else:
                # if changed, write!
                if (substed_content != content):
                #if substed_tags:
                    self.outputContentDiff(content, substed_content)

                    head = i18n.twtranslate(self.site.lang,
                                            'thirdparty-drtrigonbot-sum_disc-summary-head')
                    if msg is None:
                        msg = i18n.twtranslate(self.site.lang,
                                               'thirdparty-drtrigonbot-subster-summary-mod')
                    flags = copy.deepcopy(EditFlags)
                    if page.title() in self._flagenable:
                        flags.update(self._flagenable[page.title()])
                    pywikibot.output(u'Flags used for writing: %s' % flags)
                    self.save(page, substed_content,
                              (head + u' ' + msg)
                              % {'tags': ", ".join(substed_tags)},
                              **flags)

                    # DRTRIGON-130: data repository (wikidata) output to items
                    if self.site.is_data_repository():
                        data = self.data_convertContent(substed_content)
                        self.data_save(page, data)
                else:
                    pywikibot.output(u'NOTHING TO DO!')

    def treat_page(self):
        """Upload page content."""
        page = self.current_page
        title = page.title()
        # save the content retrieved from generator
        contents = page.text
        # delete page's text to get it from live wiki
        del page.text

        if self.getOption('summary'):
            comment = self.getOption('summary')
        else:
            comment = i18n.twtranslate(self.site, 'pagefromfile-msg')

        comment_top = comment + " - " + i18n.twtranslate(
            self.site, 'pagefromfile-msg_top')
        comment_bottom = comment + " - " + i18n.twtranslate(
            self.site, 'pagefromfile-msg_bottom')
        comment_force = "%s *** %s ***" % (
            comment, i18n.twtranslate(self.site, 'pagefromfile-msg_force'))

        if page.exists():
            if not self.getOption('redirect') and page.isRedirectPage():
                pywikibot.output(u"Page %s is redirect, skipping!" % title)
                return
            pagecontents = page.text
            nocontent = self.getOption('nocontent')
            if nocontent and (
                    nocontent in pagecontents or
                    nocontent.lower() in pagecontents):
                pywikibot.output('Page has %s so it is skipped' % nocontent)
                return
            if self.getOption('append'):
                separator = self.getOption('append')[1]
                if separator == r'\n':
                    separator = '\n'
                if self.getOption('append')[0] == 'top':
                    above, below = contents, pagecontents
                    comment = comment_top
                else:
                    above, below = pagecontents, contents
                    comment = comment_bottom
                pywikibot.output('Page {0} already exists, appending on {1}!'.format(
                                 title, self.getOption('append')[0]))
                contents = above + separator + below
            elif self.getOption('force'):
                pywikibot.output(u"Page %s already exists, ***overwriting!"
                                 % title)
                comment = comment_force
            else:
                pywikibot.output(u"Page %s already exists, not adding!" % title)
                return
        else:
            if self.getOption('autosummary'):
                comment = config.default_edit_summary = ''

        self.put_current(contents, summary=comment,
                         minor=self.getOption('minor'),
                         show_diff=self.getOption('showdiff'))

 def testLocalized(self):
     """Test fully localized entry."""
     self.assertEqual(i18n.twtranslate('en', 'test-localized'),
                      u'test-localized EN')
     self.assertEqual(i18n.twtranslate('nl', 'test-localized'),
                      u'test-localized NL')
     self.assertEqual(i18n.twtranslate('fy', 'test-localized'),
                      u'test-localized FY')

 def testSemiLocalized(self):
     """Test translating with fallback to alternative language."""
     self.assertEqual(i18n.twtranslate('en', 'test-semi-localized'),
                      u'test-semi-localized EN')
     self.assertEqual(i18n.twtranslate('nl', 'test-semi-localized'),
                      u'test-semi-localized NL')
     self.assertEqual(i18n.twtranslate('fy', 'test-semi-localized'),
                      u'test-semi-localized NL')

    def __init__(self, **kwargs):
        """Constructor."""
        self.availableOptions.update({
            'tiny': False,  # use Non-empty category redirects only
            'delay': 7,  # cool down delay in days
        })
        super(CategoryRedirectBot, self).__init__(**kwargs)
        self.cooldown = self.getOption('delay')
        self.site = pywikibot.Site()
        self.catprefix = self.site.namespace(14) + ":"
        self.log_text = []
        self.edit_requests = []
        self.problems = []
        self.template_list = []
        self.cat = None
        self.log_page = pywikibot.Page(self.site,
                                       u"User:%(user)s/category redirect log"
                                       % {'user': self.site.username()})

        # Localization:

        # Category that contains all redirected category pages
        self.cat_redirect_cat = {
            'commons': "Category:Category redirects",
            'meta': 'Category:Maintenance of categories/Soft redirected categories',
            'ar': u"تصنيف:تحويلات تصنيفات ويكيبيديا",
            'cs': 'Kategorie:Údržba:Zastaralé kategorie',
            'da': "Kategori:Omdirigeringskategorier",
            'en': "Category:Wikipedia soft redirected categories",
            'es': "Categoría:Wikipedia:Categorías redirigidas",
            'fa': u"رده:رده‌های منتقل‌شده",
            'hi': 'श्रेणी:विकिपीडिया श्रेणी अनुप्रेषित',
            'hu': "Kategória:Kategóriaátirányítások",
            'ja': "Category:移行中のカテゴリ",
            'no': "Kategori:Wikipedia omdirigertekategorier",
            'pl': "Kategoria:Przekierowania kategorii",
            'pt': "Categoria:!Redirecionamentos de categorias",
            'ru': "Категория:Википедия:Категории-дубликаты",
            'sco': "Category:Wikipaedia soft redirectit categories",
            'simple': "Category:Category redirects",
            'sh': u"Kategorija:Preusmjerene kategorije Wikipedije",
            'sr': 'Категорија:Википедијине меко преусмерене категорије',
            'vi': u"Thể loại:Thể loại đổi hướng",
            'zh': u"Category:已重定向的分类",
            'ro': 'Categorie:Categorii de redirecționare',
        }

        # Category that contains non-empty redirected category pages
        self.tiny_cat_redirect_cat = 'Q8099903'

        self.move_comment = 'category_redirect-change-category'
        self.redir_comment = 'category_redirect-add-template'
        self.dbl_redir_comment = 'category_redirect-fix-double'
        self.maint_comment = 'category_redirect-comment'
        self.edit_request_text = i18n.twtranslate(
            self.site, 'category_redirect-edit-request') + u'\n~~~~'
        self.edit_request_item = i18n.twtranslate(
            self.site, 'category_redirect-edit-request-item')

    def __init__(self, oldcat, newcat=None, batch=False, comment='',
                 inplace=False, move_oldcat=True, delete_oldcat=True,
                 title_regex=None, history=False, pagesonly=False):
        """Stores all given parameters in the objects attributes.

        @param oldcat: The move source.
        @param newcat: The move target.
        @param batch: If True the user has not to confirm the deletion.
        @param comment: The edit summary for all pages where the
            category is changed.
        @param inplace: If True the categories are not reordered.
        @param move_oldcat: If True the category page (and talkpage) is
            copied to the new category.
        @param delete_oldcat: If True the oldcat page and talkpage are
            deleted (or nominated for deletion) if it is empty.
        @param title_regex: Only pages (and subcats) with a title that
            matches the regex are moved.
        @param history: If True the history of the oldcat is posted on
            the talkpage of newcat.
        @param pagesonly: If True only move pages, not subcategories.
        """
        self.site = pywikibot.Site()
        # Create attributes for the categories and their talk pages.
        self.oldcat = self._makecat(oldcat)
        self.oldtalk = self.oldcat.toggleTalkPage()
        if newcat:
            self.newcat = self._makecat(newcat)
            self.newtalk = self.newcat.toggleTalkPage()
        else:
            self.newcat = None
            self.newtalk = None
        # Set boolean settings.
        self.inplace = inplace
        self.move_oldcat = move_oldcat
        self.delete_oldcat = delete_oldcat
        self.batch = batch
        self.title_regex = title_regex
        self.history = history
        self.pagesonly = pagesonly
        # Set edit summary for changed pages.
        self.comment = comment
        if not self.comment:
            if self.newcat:
                template_vars = { \
                    'oldcat': self.oldcat.title(
                    withNamespace=False),
                    'newcat': self.newcat.title(
                    withNamespace=False)}
                self.comment = i18n.twtranslate(self.site,
                                                'category-replacing',
                                                template_vars)
            else:
                template_vars = {'oldcat': self.oldcat.title( \
                    withNamespace=False)}
                self.comment = i18n.twtranslate(self.site,
                                                'category-removing',
                                                template_vars)

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

 def testNonLocalized(self):
     """Test translating non localized entries."""
     self.assertEqual(i18n.twtranslate('en', 'test-non-localized'),
                      u'test-non-localized EN')
     self.assertEqual(i18n.twtranslate('fy', 'test-non-localized'),
                      u'test-non-localized EN')
     self.assertEqual(i18n.twtranslate('nl', 'test-non-localized'),
                      u'test-non-localized EN')
     self.assertEqual(i18n.twtranslate('ru', 'test-non-localized'),
                      u'test-non-localized EN')

    def _hist(self):
        """Private function to copy the history of the to-be-deleted category.

        Do not use this function from outside the class. It adds a table with
        the history of the old category on the new talk page.
        """
        history = self.oldcat.getVersionHistoryTable()
        title = i18n.twtranslate(self.site, "category-section-title", {"oldcat": self.oldcat.title()})
        self.newtalk.text = "%s\n== %s ==\n%s" % (self.newtalk.text, title, history)
        comment = i18n.twtranslate(self.site, "category-version-history", {"oldcat": self.oldcat.title()})
        self.newtalk.save(comment)

 def _hist(self):
     """Private function to create a history table with the history
     of the old category on the new talk page.
     Do not use this function from outside the class.
     """
     history = self.oldcat.getVersionHistoryTable()
     title = i18n.twtranslate(self.site, 'category-section-title',
                              {'oldcat': self.oldcat.title()})
     self.newtalk.text = "%s\n== %s ==\n%s" % (self.newtalk.text,
                                               title, history)
     comment = i18n.twtranslate(self.site, 'category-version-history',
                                {'oldcat': self.oldcat.title()})
     self.newtalk.save(comment)

    def __init__(self):
        self.cooldown = 7 # days
        self.site = pywikibot.getSite()
        self.site.login()
        self.catprefix = self.site.namespace(14)+":"
        self.log_text = []
        self.edit_requests = []
        self.log_page = pywikibot.Page(self.site,
                        u"User:%(user)s/category redirect log" %
                            {'user': self.site.user()})

        # Localization:

        # Category that contains all redirected category pages
        self.cat_redirect_cat = {
            'wikipedia': {
                'ar': u"تصنيف:تحويلات تصنيفات ويكيبيديا",
                'cs': u"Kategorie:Zastaralé kategorie",
                'da': "Kategori:Omdirigeringskategorier",
                'en': "Category:Wikipedia soft redirected categories",
                'es': "Categoría:Wikipedia:Categorías redirigidas",
                'fa': u"رده:رده‌های منتقل شده",
                'hu': "Kategória:Kategóriaátirányítások",
                'ja': "Category:移行中のカテゴリ",
                'no': "Kategori:Wikipedia omdirigertekategorier",
                'pl': "Kategoria:Przekierowania kategorii",
                'pt': "Categoria:!Redirecionamentos de categorias",
                'ru': "Категория:Википедия:Категории-дубликаты",
                'simple': "Category:Category redirects",
                'vi': u"Thể loại:Thể loại đổi hướng",
                'zh': u"Category:已重定向的分类",
            },
            'commons': {
                'commons': "Category:Category redirects"
            }
        }

        self.move_comment = 'category_redirect-change-category'
        self.redir_comment = 'category_redirect-add-template'
        self.dbl_redir_comment = 'category_redirect-fix-double'
        self.maint_comment = 'category_redirect-comment'
        self.edit_request_text = i18n.twtranslate(
                                     self.site.lang,
                                     'category_redirect-edit-request') + \
                                     u'\n~~~~'
        self.edit_request_item = i18n.twtranslate(
                                     self.site.lang,
                                     'category_redirect-edit-request-item')

 def __init__(self, generator, img, info, imdb):
     """
     Constructor. Parameters:
         @param generator: The page generator that determines on which pages
                           to work.
         @type generator: generator.
     """
     self.generator = generator
     # Set the edit summary message
     self.summary = i18n.twtranslate(pywikibot.getSite(), 'basic-changing')
     
     self.chrome = filmsettings.getChrome()
     self.img = img
     self.info = info
     self.imdb = imdb
     self.imdbNum = 0
     self.templateRegex = re.compile("{{.*}}") #This is how templates are in wikipedia
     self.referenceRegex = re.compile("(<ref.*?/(ref)?>)+")
     self.commentRegex = re.compile("<!--.*?-->")
     self.wikilinkRegex = re.compile("\[\[.*\|.*\]\]")
     
     infoTemp = pywikibot.Page(pywikibot.getSite(), "Template:Infobox_film/doc").get()
     infoTempStart = infoTemp.find("{{Infobox film") + 2
     bracketCount = 2
     infoTempEnd = infoTempStart
     while bracketCount != 0 :
       infoTempEnd += 1
       if infoTemp[infoTempEnd:infoTempEnd+1] == "{":
         bracketCount += 1
       elif infoTemp[infoTempEnd:infoTempEnd+1] == "}":
         bracketCount -= 1
     self.infoboxTemplate = re.sub(self.commentRegex, "", infoTemp[infoTempStart - 2:infoTempEnd+1])

    def __init__(self, generator, **kwargs):
        """Constructor."""
        self.availableOptions.update({
            'verbose': True,
        })
        super(NoReferencesBot, self).__init__(**kwargs)

        self.generator = pagegenerators.PreloadingGenerator(generator)
        self.site = pywikibot.Site()
        self.comment = i18n.twtranslate(self.site, 'noreferences-add-tag')

        self.refR = re.compile('</ref>', re.IGNORECASE)
        self.referencesR = re.compile('<references.*?/>', re.IGNORECASE)
        self.referencesTagR = re.compile('<references>.*?</references>',
                                         re.IGNORECASE | re.DOTALL)
        try:
            self.referencesTemplates = referencesTemplates[
                self.site.family.name][self.site.code]
        except KeyError:
            self.referencesTemplates = []
        try:
            self.referencesText = referencesSubstitute[
                self.site.family.name][self.site.code]
        except KeyError:
            self.referencesText = u'<references />'