Scripts/RojaStringRemixer.py

import multiprocessing
import pathlib
import re
import time
import traceback

import orjson
import tqdm
import typer
from bs4 import BeautifulSoup, Tag
from markdownify import MarkdownConverter, chomp

CONCURRENT = 64


class WikiConverter(MarkdownConverter):
    def convert_a(self, el, text, convert_as_inline):
        prefix, suffix, text = chomp(text)
        if not text:
            return ""
        return "%s%s%s" % (prefix, text, suffix)

    integer_rgx = re.compile("^[0-9]*$")

    @staticmethod
    def is_intable(string: str):
        if not string or not string.isdigit():
            return False
        if WikiConverter.integer_rgx.match(string):
            return True

    def convert_img(self, el, text, convert_as_inline):
        convert_as_inline = True
        alt = el.attrs.get("alt", None) or ""
        if (
            convert_as_inline
            and el.parent.name not in self.options["keep_inline_images_in"]
        ):
            return alt
        return alt

    def convert_li(self, el, text, convert_as_inline):
        parent = el.parent
        if parent is not None and parent.name == "ol":
            start = parent.get("start")
            if start and WikiConverter.is_intable(start.strip()):
                start = int(start.strip())
            else:
                start = 1
            bullet = "%s." % (start + parent.index(el))
        else:
            depth = -1
            while el:
                if el.name == "ul":
                    depth += 1
                el = el.parent
            bullets = self.options["bullets"]
            bullet = bullets[depth % len(bullets)]
        return "%s %s\n" % (bullet, (text or "").strip())


class MultilangWikipediaProcessor:
    def __init__(self) -> None:
        self.md = WikiConverter()

    def is_stub(self, soup: BeautifulSoup):
        for plainlinks in soup.select(".metadata.plainlinks"):
            if "stub" in plainlinks.get("id", "") or "stub" in plainlinks.get(
                "class", []
            ):
                return True
        return False

    def rital_ambox(self, input_soup: BeautifulSoup):
        ambox_classes = []
        
        for ambox in selects:
            if ambox is not None:
                ambox_classes.append(ambox.get("class"))
        for ambox in selects:
            ambox.decompose()
        return input_soup, ambox_classes

    def rital_ombox(self, input_soup: BeautifulSoup):
        ombox_classes = []
        selects = input_soup.select('table[class~="ombox"]')
        for ombox in selects:
            if ombox is not None:
                ombox_classes.append(ombox["class"])
        for ombox in selects:
            ombox.decompose()
        return input_soup, ombox_classes

    def table_filtration(self, input_soup: BeautifulSoup, title):
        for table in input_soup.select("table"):
            tds = len(table.find_all("td"))
            texsize = len(table.get_text().replace(" ", ""))
            if tds >= texsize and texsize < 50:
                print(table.get_text().replace(" ", ""))
                print("Removing table from", title, ". TD exceeds Content")
        return input_soup

    all_selectors = [
        "style",  # Remove styling
        "sup.reference",  # Seems to still exist across
        "table.nomobile",  # Seems to still exist across
    ]

    def process_infobox(self, infobox: Tag):
        return str(infobox)

    def process_figures(self, figure: Tag):
        figure_data = {}
        fig_a = figure.find("a")
        fig_cap = figure.find("figcaption")
        if fig_a:
            figure_data["file_url"] = fig_a.get("href", None)
        else:
            figure_data["file_url"] = None
        if fig_cap:
            figure_data["caption"] = fig_cap.get_text()
        else:
            figure_data["caption"] = None
        if figure_data["caption"] == figure_data["file_url"] is None:
            return None
        return figure_data

    def convert_soup(self, input_soup: BeautifulSoup):
        [i.unwrap() for i in input_soup.select('[data-mw^="interface"]')]
        [i.decompose() for i in input_soup.select(", ".join(self.all_selectors))]
        title = input_soup.select_one("title").extract()
        # titletext = title.get_text()

        for i in input_soup.select(".mw-collapsible"):
            hidden = i.select_one("div.hidden-content")
            if hidden:
                # Expose collapsed content
                hidden["class"].remove("hidden-content")
        for i in input_soup.select("[data-mw]"):
            i["data-mw"] = ""

        ifbs = [i.extract() for i in input_soup.select("table.infobox")]
        ifbs += [i.extract() for i in input_soup.select("table.sidebar.vcard.hlist")]
        ifbs += [i.extract() for i in input_soup.select("table.infobox.vcard")]
        ifbs = [self.process_infobox(ifb) for ifb in ifbs]
        figures = [
            self.process_figures(fig.extract())
            for fig in input_soup.select('figure[typeof^="mw:File/Thumb"]')
        ]

        return input_soup, ifbs, figures, title

    def convert(self, wiki_data: bytes):
        data = orjson.loads(wiki_data.rstrip(b"\n"))
        try:
            templates = [
                ":".join(template["name"].split(":")[1:])
                for template in data.get("templates", [])
            ]
            categories = [
                ":".join(category["name"].split(":")[1:])
                for category in data.get("categories", [])
            ]
            if not data["article_body"].get("wikitext"):
                return None
            soup = BeautifulSoup(data["article_body"]["html"], "lxml")
            is_stub = self.is_stub(soup)
            soup, infobox, figures, title = self.convert_soup(soup)

            # soup, issues, issue_selectors = self.remove_templates(soup, all_templates)
            soup, amboxes = self.rital_ambox(soup)
            soup, omboxes = self.rital_ombox(soup)
            soup = self.table_filtration(soup, title)
            text = (
                self.md.convert_soup(soup)
                .strip()
                .replace("\n\n", "\n")
                .replace("\n\n\n", "\n\n")
            )
            return orjson.dumps(
                {
                    "id": data["identifier"],
                    "title": data["name"],
                    "url": data["url"],
                    "stub": is_stub,
                    "template": templates,
                    "category": categories,
                    "license": [lic["name"] for lic in data["license"]],
                    "text": text,
                    "wikitext": data["article_body"].get("wikitext"),
                    "lang": data["in_language"]["identifier"],
                    "abstract": data.get("abstract", ""),
                    "boxes_filters": amboxes + omboxes,
                    "infobox_html": infobox,
                    "figures_dict": figures,
                }
            )
        except Exception as e:
            print(f"Exception at Soup Conversion: {e} [{data['name']}]")
            return None


queue = multiprocessing.Queue(maxsize=1024 * 1024)


def worker(worker_idx: int, prefix_path: pathlib.Path):
    if prefix_path.parent:
        prefix_path.parent.mkdir(exist_ok=True, parents=True)
    processor = MultilangWikipediaProcessor()
    prefix_path = prefix_path.with_name(
        f"{prefix_path.name}-{str(worker_idx).zfill(2)}.jsonl"
    )
    with open(prefix_path, "wb") as f:
        while True:
            data = queue.get()
            if data is None:
                break
            # print(data[:16])
            parsed = processor.convert(data)
            if parsed:
                f.write(parsed)
                f.write(b"\n")


app = typer.Typer()


def err_cb(err: Exception):
    print(traceback.format_exception(err)[0])


@app.command()
def main(folder: pathlib.Path, prefix_path: pathlib.Path, processes: int = 64):
    # orjson.loads()
    with multiprocessing.Pool(processes=processes) as pool:
        workers = [
            pool.apply_async(
                worker, args=(worker_idx, prefix_path), error_callback=err_cb
            )
            for worker_idx in range(processes)
        ]
        for file in pathlib.Path(folder).glob("*.ndjson"):
            with open(file, "rb") as fp:
                pbar = tqdm.tqdm(desc=f"{file.name}")
                for line in fp:
                    # print(line[:16])
                    queue.put(line)
                    pbar.update(1)
                print("processed", file.name)
                pbar.close()
        for _ in range(processes):
            queue.put(None)
        while not queue.empty():
            print("Waiting for empty queue")
            time.sleep(5)
        print("Queue is empty. Waiting for threads to finish.")
        patience = 120
        # processor_thr = 0.05
        while True:
            workers_done = 0
            for running_worker in workers:
                if running_worker.ready():
                    workers_done += 1
            if workers_done == processes:
                break
            if patience <= 0:
                # Screw it.
                pool.terminate()
                break
            else:
                if workers_done > processes // 1.5:
                    print("Waiting for dangling processes to complete.")
                    time.sleep(10)
                    patience -= 1

        # pool.join()


if __name__ == "__main__":
    app()