import multiprocessing import random import traceback from lxml import etree import pathlib import orjson import tqdm import typer import urllib.parse from sqlitedict import SqliteDict app = typer.Typer() def fast_iter(context, func, *args, **kwargs): """ http://lxml.de/parsing.html#modifying-the-tree Based on Liza Daly's fast_iter http://www.ibm.com/developerworks/xml/library/x-hiperfparse/ See also http://effbot.org/zone/element-iterparse.htm """ for event, elem in context: func(elem, *args, **kwargs) # It's safe to call clear() here because no descendants will be # accessed elem.clear() # Also eliminate now-empty references from the root node to elem for ancestor in elem.xpath("ancestor-or-self::*"): while ancestor.getprevious() is not None: del ancestor.getparent()[0] del context @app.command() def decadence_fp(stack_folder: pathlib.Path, output_file: pathlib.Path): post_history = stack_folder / "PostHistory.xml" if not post_history.exists(): raise Exception() # posts_hist = {} print("Working on", stack_folder.name) sql_dict_posts = SqliteDict( f"tmp/{stack_folder.name}.hist.tmp.sqlite", flag="n", tablename="dict_hist" ) try: with tqdm.tqdm() as pbar: ctx = etree.iterparse(post_history, tag="row") def element_processor2(elem): p_type = int(elem.get("PostHistoryTypeId")) pid: str = elem.get("PostId") if p_type in range(1, 4): if pid in sql_dict_posts: post_data = sql_dict_posts[pid] else: post_data = sql_dict_posts[pid] = {} if p_type == 1: post_data["title"] = urllib.parse.unquote( elem.get("Text", "") ).replace("\r\n", "\n") elif p_type == 2: post_data["body"] = urllib.parse.unquote( elem.get("Text", "") ).replace("\r\n", "\n") elif p_type == 3: post_data["tags"] = urllib.parse.unquote( elem.get("Text", "") ).replace("\r\n", "\n") # print(post_data) sql_dict_posts[pid] = post_data pbar.update(1) elif p_type in range(4, 10): if pid in sql_dict_posts: post_data = sql_dict_posts[pid] else: # print(f"[W] {pid}, {stack_folder.name} appears to be a partial?") post_data = sql_dict_posts[pid] = {} post_data["partial"] = True if p_type in [4, 7]: post_data["title"] = urllib.parse.unquote( elem.get("Text", "") ).replace("\r\n", "\n") elif p_type in [5, 8]: post_data["body"] = urllib.parse.unquote( elem.get("Text", "") ).replace("\r\n", "\n") elif p_type in [6, 9]: post_data["tags"] = urllib.parse.unquote( elem.get("Text", "") ).replace("\r\n", "\n") sql_dict_posts[pid] = post_data pbar.update(1) elif p_type == 35: if pid in sql_dict_posts: post_data = sql_dict_posts[pid] else: print( f"[W] {pid}, {stack_folder.name} requested to be redirected but redirect doesn't seem to exist?" ) post_data = {} if not post_data.get("partial", False): print(f"[I] {pid}, {stack_folder.name} Not partial?") return print(post_data) elif p_type == 10: if pid not in sql_dict_posts: return post_data = sql_dict_posts[pid] if not post_data: raise Exception post_data["closed"] = True sql_dict_posts[pid] = post_data pbar.update(1) elif p_type == 11: if pid not in sql_dict_posts: return post_data = sql_dict_posts[pid] if not post_data: raise Exception post_data["closed"] = False sql_dict_posts[pid] = post_data pbar.update(1) elif p_type == 12: if pid not in sql_dict_posts: return post_data = sql_dict_posts[pid] if not post_data: raise Exception post_data["deleted"] = True sql_dict_posts[pid] = post_data pbar.update(1) elif p_type == 13: if pid not in sql_dict_posts: return post_data = sql_dict_posts[pid] if not post_data: raise Exception post_data["deleted"] = False sql_dict_posts[pid] = post_data pbar.update(1) elif p_type == 14: if pid not in sql_dict_posts: return post_data = sql_dict_posts[pid] if not post_data: raise Exception post_data["locked"] = True sql_dict_posts[pid] = post_data pbar.update(1) elif p_type == 15: if pid not in sql_dict_posts: return post_data = sql_dict_posts[pid] if not post_data: raise Exception post_data["locked"] = False sql_dict_posts[pid] = post_data pbar.update(1) # print(etree.tostring(element)) if pbar.n % 5000 == 0 and pbar.n != 0: # print(sql_dict_posts.conn.reqs.qsize()) sql_dict_posts.commit() # elem.clear() fast_iter(ctx, element_processor2) except Exception as e: print("[!] ERR: ", traceback.format_exception(e)) flagged = set() for k, v in sql_dict_posts.items(): if not v.get("body").strip(): flagged.add(k) if v.get("deleted", False): flagged.add(k) for fg in flagged: del sql_dict_posts[fg] sql_dict_posts.sync() print("Reconstruct done!") sql_dict_posts.close() @app.command() def decadence(stack_folder: pathlib.Path, output_file: pathlib.Path): posts = stack_folder / "Posts.xml" if not posts.exists(): raise Exception() # reconstruct = {} sql_dict_posts = SqliteDict( f"tmp/{stack_folder.name}.hist.tmp.sqlite", flag="r", tablename="dict_hist" ) main_qn_posts = SqliteDict( f"tmp/{stack_folder.name}.s2.hist.tmp.sqlite", flag="n", tablename="qa_items", ) print("processing", posts) try: # Prepare all the Main Question posts with tqdm.tqdm() as bar: ctx2 = etree.iterparse(posts, tag="row") sync = 0 def element_processor(element): nonlocal sync pid = element.get("Id") p_type = int(element.get("PostTypeId")) if p_type == 1: if pid not in sql_dict_posts: main_qn_posts[pid] = {"Stub":True} print( f"[!] Question: {int(element.get('Id'))} {stack_folder.name} does not exist but referanced?" ) return main_qn_posts[pid] = sql_dict_posts[pid] main_qn_posts[pid]["Stub"] = False main_qn_posts[pid]["Id"] = pid main_qn_posts[pid]["CreationDate"] = element.get("CreationDate") main_qn_posts[pid]["Score"] = int(element.get("Score")) main_qn_posts[pid]["Accepted"] = ( int(element.get("AcceptedAnswerId")) if element.get("AcceptedAnswerId") else None ) main_qn_posts[pid]["Counts"] = { "Views": int(element.get("ViewCount")) if element.get("ViewCount") else 0, "Answers": int(element.get("AnswerCount")) if element.get("AnswerCount") else 0, "Comments": int(element.get("CommentCount")) if element.get("CommentCount") else 0, } if sync >= 1000: sync = 0 # print("Sync.") main_qn_posts.sync() sync += 1 bar.update(1) fast_iter(ctx2, element_processor) main_qn_posts.sync() except Exception as e: print("[!] ERR: ", traceback.format_exception(e)) print("2nd Pass Posts Done") # Match all the Answer posts try: with tqdm.tqdm() as bar: ctx3 = etree.iterparse(posts, tag="row") sync = 0 def element_processor3(element): nonlocal sync pid = element.get("Id") p_type = int(element.get("PostTypeId")) if p_type == 2: parent_id = element.get("ParentId") if parent_id not in main_qn_posts: print( f"[!] Answer: {int(element.get('Id'))} {stack_folder.name} has no parent attached to it!" ) return root = main_qn_posts[parent_id] answers = root.setdefault("answers", []) if pid in sql_dict_posts: rec_answer = sql_dict_posts[pid] else: rec_answer = None if rec_answer is None: print( f"[!] Answer: {int(element.get('Id'))} {stack_folder.name} does not have a PostHistory.xml Assoc. with it!" ) root["answers"] = answers return rec_answer["Id"] = int(element.get("Id")) rec_answer["Score"] = ( int(element.get("Score")) if element.get("Score") else 0 ) rec_answer["Counts"] = { "Views": int(element.get("ViewCount")) if element.get("ViewCount") else 0, "Comments": int(element.get("CommentCount")) if element.get("CommentCount") else 0, } answers.append(rec_answer) root["answers"] = answers main_qn_posts[parent_id] = root if sync >= 1000: sync = 0 print("Sync.") main_qn_posts.sync() sync += 1 bar.update(1) fast_iter(ctx3, element_processor3) main_qn_posts.sync() except Exception as e: print("[!] ERR: ", traceback.format_exception(e)) print("2nd Pass done.", output_file.name) try: with open(output_file, "wb") as f: for k, v in main_qn_posts.items(): f.write(orjson.dumps(v) + b"\n") sql_dict_posts.close() pathlib.Path(f"tmp/{stack_folder.name}.hist.tmp.sqlite").unlink() except Exception as e: print("[!] ERR: ", traceback.format_exception(e)) @app.command() def convo_processor(base_file: pathlib.Path, qa_file: pathlib.Path): with open(qa_file, "wb") as fw: with open(base_file, "rb") as f: for line in f: data = orjson.loads(line) if "body" not in data or "title" not in data: continue if data["body"].lower().startswith(data["title"].lower()): question = f'{data["title"].strip()}\n\n{data["body"][len(data["title"]) :].strip()}' else: question = f'{data["title"].strip()}\n\n{data["body"].strip()}' if data.get("answers"): for answer in data.get("answers"): if "Score" not in answer: print("no score?",data) continue if answer["Score"] >= 0: zz = { "conversation": [ {"sender": "user", "message": question}, {"sender": "assistant", "message": answer}, ], "meta": { "q_score": data.get("Score",0), "a_score": answer["Score"], }, } fw.write(orjson.dumps(zz) + b"\n") pass @app.command() def qa_processor(base_file: pathlib.Path, qa_file: pathlib.Path, formats: pathlib.Path): question_formats = orjson.loads(formats.read_bytes()) with open(qa_file, "wb") as fw: with open(base_file, "rb") as f: for line in f: data = orjson.loads(line) if "body" not in data or "title" not in data: continue if data["body"].lower().startswith(data["title"].lower()): question = f'{data["title"].strip()}\n\n{data["body"][len(data["title"]) :].strip()}' else: question = f'{data["title"].strip()}\n\n{data["body"].strip()}' if data.get("answers"): for answer in data.get("answers"): if answer["Score"] >= 0: fmt = random.choice(question_formats) fmt = fmt.format(question=question, answer=answer["body"]) zz = { "text": fmt, "meta": { "q_score": data.get("Score",0), "a_score": answer["Score"], }, } fw.write(orjson.dumps(zz) + b"\n") pass def err_handler(e): traceback.print_exception(e) @app.command() def convo_stackstack(folder: pathlib.Path): with multiprocessing.Pool(processes=64) as pool: fn = [] for item in folder.iterdir(): if item.is_file() and item.suffix.endswith("jsonl"): # print(item) fn.append( pool.apply_async( convo_processor, ( item, pathlib.Path("convo-large") / pathlib.Path(f"{item.stem}_convo.jsonl") ), error_callback=err_handler) ) for f in fn: f.wait() pool.close() pool.join @app.command() def qa_stackstack(folder: pathlib.Path): with multiprocessing.Pool(processes=64) as pool: fn = [] for item in folder.iterdir(): if item.is_file() and item.suffix.endswith("jsonl"): # print(item) fn.append( pool.apply_async( qa_processor, ( item, pathlib.Path("qa-large") / pathlib.Path(f"{item.stem}_qa.jsonl"), pathlib.Path("staccato_format.json") ), error_callback=err_handler) ) for f in fn: f.wait() pool.close() pool.join() @app.command() def fp_stackstack(folder: pathlib.Path): with multiprocessing.Pool(processes=6) as pool: fn = [] for item in folder.iterdir(): if item.is_dir() and "meta." not in item.name: # print(item) fn.append( pool.apply_async( decadence_fp, ( item, pathlib.Path("large-parsed") / pathlib.Path(f"{item.name}_raw.jsonl"), ), ) ) for f in fn: f.wait() pool.close() pool.join() @app.command() def stackstack(folder: pathlib.Path): with multiprocessing.Pool(processes=8) as pool: fn = [] for item in folder.iterdir(): if item.is_dir() and "meta." not in item.name: # print(item) fn.append( pool.apply_async( decadence, ( item, pathlib.Path("large-parsed") / pathlib.Path(f"{item.name}_raw.jsonl"), ), ) ) for f in fn: f.wait() app()