Datasets:
License:
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]*$") | |
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]) | |
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() | |