epilogue/archive_generator.py

@@ -2,26 +2,17 @@ import os
 import logging
 import shutil
 
-from itertools import chain
 from traceback import print_exc
 
 import chevron
 import bbcode
 import html
 
-from .wiki import Template, Renderer, Linker, reformat_page_title, NAMESPACES as WIKI_NAMESPACES
+from .wiki import Template, Renderer, reformat_page_title, NAMESPACES as WIKI_NAMESPACES
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("ArchiveGenerator")
 
-DEX_LANGUAGES = ["", "DE", "ES", "FR", "IT", "JP", "KO"]
-DEX_TYPES = [
-    "GlitchDex", "AttackDex", "DexDex", "AreaDex", "TrainerDex", "FieldMoveDex", "ItemDex", "FamilyDex", "DecDex", "DayDex",
-    "MDIGlitchDex", "MetascriptDex", "TMHMDex", "StatDex", "PosterDex", "TypeDex", "UnownDex", "DollDex", "DefaultNameDex",
-    "BattleTypeDe", "BadgeDescriptionDex", "FacingDex"
-]
-DEXES = list(chain.from_iterable([[f"{dex_type}{language}" for dex_type in DEX_TYPES] for language in DEX_LANGUAGES]))
-
 def prepare_thread (thread):
     thread.subject = html.unescape(thread.subject)
     return thread
@@ -61,15 +52,14 @@ class ArchiveGenerator():
 
         categories = {}
         templates = dict([(page.title.split(":")[1], Template(page.get_latest().text)) for page in wiki.get_pages() if page.namespace == WIKI_NAMESPACES['TEMPLATE']])
-        linker = Linker(directory_names=DEXES)
-        wikitext_renderer = Renderer(templates, linker)
+        wikitext_renderer = Renderer(templates)
         for page in wiki.get_pages():
             try:
                 if page.namespace != WIKI_NAMESPACES['MAIN']:
                     continue
 
-                page_out = linker.translate_page_title(page.title)
-                base = "./"
+                page_out = "{}.html".format(page.title).replace(" ", "_")
+                base = ""
                 if "/" in page_out:
                     base = "../" * page_out.count("/")
                     try:
@@ -79,11 +69,11 @@ class ArchiveGenerator():
                 if page.redirect:
                     logger.info("Archiving redirect page (%s -> %s) to %s", page.title, page.redirect, page_out)
                     renderer.render_template_to_file("redirect", page_out, {
-                        "target": f"{base}{linker.translate_page_title(page.redirect)}"
+                        "target": f"{base}{reformat_page_title(page.redirect)}.html"
                     })
                 else:
                     logger.info("Archiving page %s to %s", page.title, page_out)
-                    (rendered, page_categories) = wikitext_renderer.render(page.get_latest().text, base, page=page)
+                    (rendered, page_categories) = wikitext_renderer.render(page.get_latest().text, page=page)
 
                     for category in page_categories:
                         if not category in categories:

epilogue/wiki.py

@@ -32,7 +32,6 @@ INTERWIKI_NAMESPACES = {
 
 FILE_NAMESPACES = ["File:", "Image:"]
 CATEGORY_NAMESPACE = "Category:"
-CATEGORY_LINK_NAMESPACE = f":{CATEGORY_NAMESPACE}"
 
 class Wiki():
     def __init__ (self, xml_path):
@@ -86,11 +85,10 @@ class Contributor():
                 self.username = child.text
 
 class Renderer():
-    def __init__ (self, templates={}, linker=None):
+    def __init__ (self, templates={}):
         self.templates = templates
-        self.linker = linker if linker else Linker()
 
-    def render (self, wikitext, base="", *args, **kwargs):
+    def render (self, wikitext, *args, **kwargs):
         categories = []
         wikitext = self.transclude_templates(wikitext, *args, **kwargs)
         
@@ -102,15 +100,11 @@ class Renderer():
             wikitext.remove(link)
             categories.append(link.title[len(CATEGORY_NAMESPACE):])
         
-        rendered = [render(wikitext, base, self.linker)]
+        rendered = [render(wikitext)]
         if categories:
             rendered.append('<h2>Categories</h2><ul class="categories">')
             for category in categories:
-                rendered.append('<li><a href="{}Category:{}.html">{}</a></li>'.format(
-                    base,
-                    reformat_page_title(category),
-                    category
-                ))
+                rendered.append('<li><a href="Category:{}.html">{}</a></li>'.format(reformat_page_title(category), category))
             rendered.append("</ul>")
         
         return ("".join(rendered), categories)
@@ -131,32 +125,23 @@ class Renderer():
             except ValueError: pass
         return wikitext
 
-def render (wikitext, base="", linker=None):
+def render (wikitext):
     rendered = []
-
-    if not linker:
-        linker = Linker()
-
     for node in wikitext.ifilter(False):
         # node types:
         # https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.nodes.html#module-mwparserfromhell.nodes.text
         node_type = type(node)
         if node_type is Wikilink:
-            image_name = linker.translate_image_title(node.title)
+            image_name = translate_image_title(node.title)
             if image_name:
-                rendered.append('<img src="{}{}" />'.format(
-                    base,
+                rendered.append('<img src="{}" />'.format(
                     image_name,
-                    render(mwparserfromhell.parse(node.text), base, linker)
+                    render(mwparserfromhell.parse(node.text))
                 ))
             else:
-                url = linker.translate_interwiki_title(node.title)
-                if not url:
-                    url = f"{base}{linker.translate_page_title(node.title)}"
-                
                 rendered.append('<a href="{}">{}</a>'.format(
-                    url,
-                    render(node.text if node.text else node.title, base, linker)
+                    translate_page_title(node.title),
+                    render(node.text if node.text else node.title)
                 ))
         elif node_type is ExternalLink:
             rendered.append('<a href="{}">{}</a>'.format(
@@ -166,13 +151,13 @@ def render (wikitext, base="", linker=None):
         elif node_type is Tag:
             rendered.append("<{}>{}</{}>".format(
                 render(node.tag),
-                render(node.contents, base, linker),
+                render(node.contents),
                 render(node.tag)
             ))
         elif node_type is Heading:
             rendered.append("<h{}>{}</h{}>".format(
                 node.level,
-                render(node.title, base, linker),
+                render(node.title),
                 node.level
             ))
         elif node_type is Text:
@@ -180,40 +165,20 @@ def render (wikitext, base="", linker=None):
 
     return "".join(rendered).strip().replace("\n\n", "<br /><br />")
 
-class Linker():
-    def __init__ (self, file_namespaces=FILE_NAMESPACES, interwiki_namespaces=INTERWIKI_NAMESPACES, directory_names=[]):
-        self.file_namespaces = file_namespaces
-        self.interwiki_namespaces = interwiki_namespaces
-        self.directory_names = directory_names
-
-    def translate_interwiki_title (self, page_title):
-        for namespace, url in self.interwiki_namespaces.items():
+def translate_page_title (page_title):
+    for namespace, url in INTERWIKI_NAMESPACES.items():
         if page_title.startswith(namespace):
             return url.format(page_title[len(namespace):])
 
-    def translate_page_title (self, page_title):
-        if page_title.startswith(CATEGORY_LINK_NAMESPACE):
-            page_title = page_title[1:]
+    return "{}.html".format(reformat_page_title(page_title))
 
-        directory_name = ""
-        for name in self.directory_names:
-            if page_title.startswith(f"{name}/"):
-                directory_name = name
-                page_title = page_title[len(directory_name) + 1:]
-                break
-
-        return f"{reformat_page_title(directory_name)}{'/' if directory_name else ''}{reformat_page_title(page_title)}.html"
-
-    def translate_image_title (self, page_title):
-        for namespace in self.file_namespaces:
+def translate_image_title (page_title):
+    for namespace in FILE_NAMESPACES:
         if page_title.startswith(namespace):
             return reformat_page_title(page_title[len(namespace):])
 
 def reformat_page_title (page_title):
-    if not page_title:
-        return ""
-    
-    return f"{page_title[0].upper()}{page_title[1:].replace(' ', '_').replace('/', '%2F')}"
+    return "{}{}".format(page_title[0].upper(), page_title[1:].replace(" ", "_"))
 
 class Template():
     def __init__ (self, wikicode):