import multiprocessing
import pathlib
import re
import string
import traceback
from multiprocessing import Queue
import markdownify
import orjson
import tqdm
from bs4 import BeautifulSoup, Comment, NavigableString, Tag
from markdownify import chomp
if __name__ == "__main__":
multiprocessing.set_start_method("forkserver")
queue = Queue(maxsize=64)
class WikiConverter(markdownify.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
if (
convert_as_inline
and el.parent.name not in self.options["keep_inline_images_in"]
):
return ""
return ""
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())
wk = WikiConverter()
def table_filtration(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:
table.decompose()
if tds > 20:
# print("Decompose Excessive td")
table.decompose()
# print(table.get_text().replace(" ", ""))
# print("Removing table from", title, ". TD exceeds Content")
return input_soup
def soup_data(data: BeautifulSoup, title: str):
soup = data
# Navigation elements
[toc.decompose() for toc in soup.find_all("div", attrs={"class": "toc"})]
[toc.decompose() for toc in soup.select("[class*='nav']")]
# [toc.decompose() for toc in soup.select(".navbox")]
# Edit Section
[element.decompose() for element in soup.select(".mw-editsection")]
# Remove styles
[element.decompose() for element in soup.select("style")]
[element.decompose() for element in soup.select("sup.reference")]
# star-citizen.wiki.
[element.decompose() for element in soup.select(".thumbcaption")]
# Images and pictures are not under licenses typically.
[toc.decompose() for toc in soup.select("audio")]
[toc.decompose() for toc in soup.select("picture")]
[toc.decompose() for toc in soup.select("img")]
[toc.decompose() for toc in soup.select("[class*='video']")]
# Blazblue.wiki
[toc.decompose() for toc in soup.select("[class*='tooltip']")]
[toc.decompose() for toc in soup.select("video")]
[
toc.decompose()
for toc in soup.select(".no-featured-video .featured-video-player-container")
]
# print(soup)
cleaned_soup = table_filtration(soup, title)
composed_data = (
re.sub(r"\n\s*\n", "\n\n", wk.convert_soup(cleaned_soup))
.replace("\n |\n|", " |\n")
.strip()
)
return composed_data
raw_puncts = string.punctuation + "｛｝（）［］【】、，゠＝…‥。「」『』〝〟"
puncts = str.maketrans("", "", raw_puncts)
cpl = re.compile(r"\n\s*\n")
dbg_q = multiprocessing.Queue()
def debug_queue():
try:
with open("debug.txt", "w", encoding="utf-8") as f:
while True:
z = dbg_q.get()
if z is None or z == "None":
break
f.write(z + "\n")
f.flush()
except Exception as e:
print(e)
# Filters based on classes
msgbox = set(["mbox", "notice", "hidden", "plainlinks"])
msgbox2 = set(["mbox", "notice", "stub-box", "plainlinks"])
msgbox3 = set(["notice", "metadata", "plainlinks"])
# Aggressive class filter.
msgbox_agressive = set(
[
"mbox-w",
"mbox",
"msgbox",
"notice-container",
"notice",
"message-box",
"boilerplate",
"ambox",
"ombox",
]
)
wikistub = set(["wikistub"])
def get_text_cleaned(elem):
return (
cpl.sub("\n\n", elem.get_text(" "))
.replace("\n", " ")
.replace(" ", " ")
.replace(" ", " ")
.lower()
)
def get_plain_text_clean(data: str):
return (
cpl.sub("\n\n", data.translate(puncts))
.replace("\n", " ")
.replace(" ", " ")
.replace(" ", " ")
.lower()
)
t_stubs = 0
f_stubs = 0
t_lock = multiprocessing.Lock()
def t_inc(idx: int):
global t_stubs
with t_lock:
t_stubs += idx
f_lock = multiprocessing.Lock()
def f_inc(idx: int):
global f_stubs
with f_lock:
f_stubs += idx
def stub_removal(soup: str, debug=None):
b_soup = BeautifulSoup(soup, "lxml")
a = get_text_cleaned(b_soup)
if "this article is a stub" in a:
parser = b_soup.select_one(".mw-parser-output")
if parser is None:
return b_soup, []
pruned = []
for child in parser.children:
if child is None:
continue
if isinstance(child, Comment):
continue
if isinstance(child, NavigableString):
# print("Nav string?")
# print(child)
# print("===========")
continue
if not isinstance(child, Tag):
# print(type(child))
continue
classes = set(i.lower() for i in child.get("class", []))
styles = child.get("style", "")
has_border = False
if styles:
styles = {
i.split(":")[0]: ":".join(i.split(":")[1:])
for i in child.get("style", "").split(";")
}
has_border = any(
[
styles.get("border"),
styles.get("border-width") and styles.get("border-style"),
styles.get("border-top"),
styles.get("border-bottom"),
styles.get("border-left"),
styles.get("border-right"),
styles.get("background"),
]
)
# print(styles)
child_text = get_text_cleaned(child)
has_stub_word = "stub" in child_text and "this article" in child_text
c_name = "" if not child.name else child.name
if not has_stub_word:
continue
if (
len(classes.intersection(msgbox)) == len(msgbox)
or len(classes.intersection(msgbox2)) == len(msgbox2)
or len(classes.intersection(msgbox3)) == len(msgbox3)
): # Seems to be safe.
child.decompose()
pruned.append("mbox")
elif len(classes.intersection(msgbox_agressive)) > 0: # Aggressive
child.decompose()
# dbg_q.put(f'[I aggressive "mbox3_aggressive" prune]: {debug}')
pruned.append("mbox3_aggressive")
elif len(classes.intersection(wikistub)) == 1: # Seems to be safe.
child.decompose()
pruned.append("wikistub[gods-games-we-play]")
elif "table" in c_name: # Bit risky, but i guess it works?
pruned.append("table[stub-word]")
child.decompose()
elif "dl" in c_name: # Seems to be safe.
if len(child.find_all("dd", recursive=False)) == 1:
pruned.append("dl > dd")
child.decompose()
elif "div" in c_name:
inner_elements = [
i for i in child.find_all(recursive=False) if isinstance(i, Tag)
]
if len(inner_elements) == 0:
# print(child.find_all(recursive=False))
# dbg_q.put(f"[No Inner Element()?]: {len(inner_elements)}")
continue
stub_inner = get_text_cleaned(inner_elements[0])
has_stub_word = "stub" in stub_inner and "this article"
if len(inner_elements) == 0 or len(inner_elements) > 2:
# dbg_q.put(
# f"[W No Prune len()? has_stub_word]: {debug} {has_stub_word} {len(inner_elements)}"
# )
continue
if (
inner_elements[0].name
and inner_elements[0].name == "table"
and has_stub_word
):
pruned.append("table[stub-word]")
child.decompose()
elif has_border and inner_elements[0].name.lower() in [
"div",
"p",
"span",
]:
# dbg_q.put(f'[I Risky "has_border" prune]: {debug}')
pruned.append("risky[border]")
else:
# dbg_q.put(
# f"[W No Prune div? has_stub_word]: {debug} {has_stub_word} {inner_elements[0].name}"
# )
pruned.append("?")
elif "p" in c_name: # Really risky. will try logging it first.
child.decompose()
# dbg_q.put(f'[I Risky "p" prune]: {debug}')
f_inc(1)
pruned.append("risky[p]")
elif "center" in c_name: # Really risky. will try logging it first.
# dbg_q.put(f'[I Risky "center" prune]: {debug}')
child.decompose()
f_inc(1)
pruned.append("risky[center]")
if pruned:
t_inc(len(pruned))
# print("Pruned", pruned, debug)
return b_soup, pruned
else:
# dbg_q.put(f"[W No Prune?]: {debug}")
# print(f"[W No Prune?]: {debug}")
return b_soup, []
return b_soup, []
def writer(fp: str, writer_queue: multiprocessing.Queue):
pbar = tqdm.tqdm()
try:
with open(fp, "wb") as fl:
while True:
q = writer_queue.get(block=True)
if q is None or isinstance(q, str) and q == "None":
print("Q Empty, exit.")
break
elif isinstance(q, bytes):
fl.write(q)
fl.write(b"\n")
pbar.update(1)
except Exception as e:
print("Writer Crashed?")
traceback.print_exception(e)
def mt_fn(bytes_data: bytes, write_queue: multiprocessing.Queue):
data = orjson.loads(bytes_data)
dbg = f"domain: {data['domain']} title: {data['page']}"
if "parse" not in data["content"]:
print(
"Missing parse content",
"domain",
data["domain"],
"title",
data["page"],
)
return
lower_title = data["page"].lower()
if (
lower_title.startswith("forum:")
or lower_title.startswith("discussion:")
or lower_title.startswith("thread:")
or lower_title.startswith("comments:")
or lower_title.startswith("comment:")
):
return
if lower_title.endswith("gallery"):
return
soup = data["content"]["parse"]["text"]["*"]
cats = ",".join([z["*"] for z in data["content"]["parse"]["categories"]]).lower()
unstubbed_soup, removed = stub_removal(soup, debug=dbg)
text = soup_data(unstubbed_soup, data["page"])
unpunct = get_plain_text_clean(text)
if len(unpunct) > 64:
# print(text[:64])
write_queue.put(
orjson.dumps(
{
"text": text,
"meta": {
"title": data["page"],
"domain": data["domain"],
"cats": cats,
"removed": removed,
},
}
)
)
def err_handler(e):
if "KeyboardInterrupt" not in str(e):
traceback.print_exception(e)
def main():
with multiprocessing.Pool(processes=64) as pool:
managed = multiprocessing.Manager()
writer_out = managed.Queue()
write_proc = multiprocessing.Process(
target=writer, args=("test.jsonl", writer_out), daemon=False
)
# debug_tasks.start()
write_proc.start()
tasks = []
for file in pathlib.Path("v2.5-chunks-roblox-filter").iterdir():
with open(file, "rb") as f:
iter_wrapper = f # tqdm.tqdm(f)
for line in iter_wrapper:
tasks.append(
pool.apply_async(
mt_fn, args=(line, writer_out), error_callback=err_handler
)
)
if len(tasks) >= 100000:
print("Waiting for Chunked task to complete.")
for task in tasks:
if task.ready():
continue
task.wait()
tasks = []
print("[I] ========== Task gen done", file)
print("Waiting for Chunked task to complete.")
for task in tasks:
if task.ready():
continue
task.wait()
print("Cleanup")
# print("Stubs", t_stubs, "FStubs", f_stubs)
dbg_q.put("None")
# debug_tasks.join()
writer_out.put("None")
# while not writer_out.empty():
# print(f"Waiting for empty writer {writer_out.qsize()} items left")
# time.sleep(5)
write_proc.join()
pool.close()
pool.join()
if __name__ == "__main__":
main()