Add hacky support for huge files

process.py

@@ -10,70 +10,80 @@ import sys
 import re
 from html2text import html2text
 from datasets import load_dataset
+from lxml import etree
+from tqdm import tqdm
+import subprocess
+from merge_parquets import merge_parquet_dir
 
-CACHE_DIR = "xml/"
+
+XML_DIR = "./xml"
 SOURCE = "stackexchange-{0}"
 MAX_ANSWERS = 10
 QUESTION_SCORE_TRESHOLD = 0
 ANSWER_SCORE_TRESHOLD = 0
 HF_DATASET = "donfu/oa-stackexchange"
-
-xml_format_map = {
-    "Id": int,
-    "PostTypeId": int,
-    "CreationDate": str,
-    "Score": int,
-    "ViewCount": int,
-    "Body": str,
-    "AnswerCount": int,
-    "CommentCount": int,
-    "ContentLicense": str,
-    "AcceptedAnswerId": int,
-    "ParentId": int,
-}
+PARQUET_FILE = "{0}.parquet"
 
 
 def main():
     datasets = sys.argv[1:] if len(sys.argv) > 1 else list_cached_datasets()
+    if "temp" in datasets:
+        process_temp_datasets()
     for dataset in datasets:
         process_dataset(dataset)
 
 
 def list_cached_datasets():
-    xml_files = glob.glob(f"{CACHE_DIR}/*.xml")
+    xml_files = glob.glob(f"{XML_DIR}/*.xml")
     datasets = [os.path.splitext(os.path.basename(file))[0] for file in xml_files]
     datasets.sort()
     return datasets
 
 
 def process_dataset(dataset):
-    xml_file = f"{CACHE_DIR}/{dataset}.xml"
+    xml_file = f"{XML_DIR}/{dataset}.xml"
+    parquet_file = PARQUET_FILE.format(dataset)
     source = SOURCE.format(dataset)
-    if os.path.exists(xml_file):
-        df = xml_to_df(xml_file, source)
-        oa = convert_to_oa(df)
+    if os.path.exists(xml_file) and not os.path.exists(parquet_file):
+        df = parse_xml(xml_file)
+        oa = convert_to_oa(df, source)
         save_parquet(oa, dataset)
         # upload_hf(dataset)
     else:
         print(f"XML file {xml_file} not found, please download first. Skipping...")
 
 
-def convert_to_oa(all):
+def process_temp_datasets():
+    parquet_files = glob.glob(f"temp/?.parquet")
+    for file in parquet_files:
+        print("Reading parquet file: ", file)
+        df = pd.read_parquet(file)
+        print("Converting to Open Assistant format...")
+        oa = convert_to_oa(df, SOURCE.format("stackoverflow"))
+        num = re.search(r"\d", file)[0]
+        parquet_file = f"so/stackoverflow-{num}.parquet"
+        df.to_parquet(parquet_file, row_group_size=100, engine="pyarrow", index=False)
+        print("Wrote parquet file: ", parquet_file)
+
+    merge_parquet_dir("so", "stackoverflow.parquet")
+
+
+def convert_to_oa(all, source):
     """
     Convert dataframe to Open Assistant format with INSTRUCTION, RESPONSE, SOURCE, METADATA columns
 
     Only include questions with an AcceptedAnswerId
     """
-    create_metadata = lambda row: {
-        "tags": row["Tags_q"]
-        .replace("-", " ")
+    convert_tags = (
+        lambda raw: raw.replace("-", " ")
         .replace("><", ", ")
         .replace("<", "")
         .replace(">", "")
-        if isinstance(row["Tags_q"], str)
-        else "",
-        "score": row["Score_q"],
-        "views": row["ViewCount_q"],
+    )
+    create_metadata = lambda row: {
+        "tags": convert_tags(row["Tags_q"]),
+        "question_score": row["Score_q"],
+        "answer_score": row["Score_a"],
     }
     questions = all[all["AcceptedAnswerId"] != 0]
     merged = pd.merge(
@@ -84,11 +94,13 @@ def convert_to_oa(all):
         right_on="Id",
         suffixes=("_q", "_a"),
     )
+    del all
+
     merged["INSTRUCTION"] = (
         merged["Title_q"] + "\n" + merged["Body_q"].apply(to_markdown)
     )
     merged["RESPONSE"] = merged["Body_a"].apply(to_markdown)
-    merged["SOURCE"] = merged["DataSource_q"]
+    merged["SOURCE"] = source
     merged["METADATA"] = merged.apply(create_metadata, axis=1)
 
     return merged[["INSTRUCTION", "RESPONSE", "SOURCE", "METADATA"]]
@@ -99,63 +111,142 @@ def save_parquet(df, dataset):
     Save Dataframe to Parquet. See here for specs:
     https://projects.laion.ai/Open-Assistant/docs/data/datasets#creating-a-dataset-on-hugging-face
     """
-    parquet_file = f"{dataset}.parquet"
+    parquet_file = PARQUET_FILE.format(dataset)
     df.to_parquet(parquet_file, row_group_size=100, engine="pyarrow", index=False)
-    print("Converted data into parquet format: " + parquet_file)
+    print(f"Converted {len(df)} instructions into {parquet_file}")
 
 
 def upload_hf(dataset):
     """
     Upload to Hugging Face
     """
-    parquet_file = f"{dataset}.parquet"
+    parquet_file = PARQUET_FILE.format(dataset)
     dataset = load_dataset("parquet", data_files=parquet_file, name=dataset)
     dataset.push_to_hub(HF_DATASET, max_shard_size="500MB")
     print("Uploaded to Hugging Face: " + HF_DATASET)
 
 
-def xml_to_df(path: str, source: str):
+# Define a custom SAX ContentHandler to extract data from the XML file
+class StackExchangeHandler:
+    def __init__(self, total_rows):
+        self.total_rows = total_rows
+        self.progress_bar = tqdm(total=self.total_rows)
+        self.df = pd.DataFrame(
+            columns=[
+                "Id",
+                "PostTypeId",
+                "Body",
+                "Title",
+                "Tags",
+                "Score",
+                "AcceptedAnswerId",
+                "ParentId",
+            ]
+        )
+
+    def startElement(self, name, attrs):
+        if name == "row":
+            row = {}
+            row["Id"] = int(attrs.getValue("Id"))
+            row["PostTypeId"] = int(attrs.getValue("PostTypeId"))
+            row["Body"] = str(attrs.getValue("Body"))
+            row["Title"] = str(attrs.get("Title", ""))
+            row["Tags"] = str(attrs.get("Tags", ""))
+            row["Score"] = int(attrs.get("Score", 0))
+            row["ParentId"] = int(attrs.get("ParentId", 0))
+            row["AcceptedAnswerId"] = int(attrs.get("AcceptedAnswerId", 0))
+
+            self.df = pd.concat(
+                [self.df, pd.DataFrame([row], columns=self.df.columns)],
+                ignore_index=True,
+            )
+            self.progress_bar.update(1)
+
+
+def parse_xml(path: str):
     """
-    Collect and Manually import XML into Dataframe
-
-    pd.read_xml() errors when XML trees are too large, this is just a hack to
-    download a XML file and parse into a Dataframe. **Not Tested on huge XML files**
-
-    Parameters:
-    response (Requests.Response): Requests response object with the XML data
-
-    Returns:
-    df (DataFrame): A Dataframe from the XML file
+    Parse (very large) XML files with sax parser and load it into a pandas Dataframe
     """
-    with open(path, "rb") as f:
-        soup = bs(f, "xml")
-        posts = soup.find_all("row")
-
-        all_posts = [post.attrs for post in posts]
-
-        df = pd.DataFrame(all_posts)
-        df.AnswerCount.fillna(0, inplace=True)
-        df.ViewCount.fillna(0, inplace=True)
-        df.AcceptedAnswerId.fillna(0, inplace=True)
-        df.ParentId.fillna(0, inplace=True)
-        df["DataSource"] = source
-        df = df.astype(xml_format_map)
-        return df
+    total_rows = int(subprocess.getoutput(f"grep -c '<row' {path}"))
+    print(f"Parsing {total_rows} rows from {path}...")
+    columns = "Id PostTypeId Body Title Tags Score AcceptedAnswerId ParentId"
+    rows = []
+    if total_rows > 50000000:
+        huge_file = True
+        temp_file = 1
+        os.makedirs("temp", exist_ok=True)
+
+    context = etree.iterparse(path, events=("start", "end"))
+
+    for event, element in tqdm(
+        context, total=total_rows * 2
+    ):  # somehow it does not work just with start event, hence *2
+        if event == "start" and element.tag == "row":
+            row = [
+                int(element.get("Id")),
+                int(element.get("PostTypeId")),
+                element.get("Body"),
+                element.get("Title", ""),
+                element.get("Tags", ""),
+                int(element.get("Score", 0)),
+                int(element.get("AcceptedAnswerId", 0)),
+                int(element.get("ParentId", 0)),
+            ]
+            rows.append(row)
+            if huge_file and len(rows) >= 10000000:
+                df = pd.DataFrame(rows, columns=columns.split())
+                df.to_parquet(
+                    f"temp/{temp_file}.parquet", engine="pyarrow", index=False
+                )
+                print(f"Wrote temp/{temp_file}.parquet file")
+                rows = []
+                temp_file += 1
+                del df
+            element.clear()
+            element.getparent().remove(element)
+
+    df = pd.DataFrame(rows, columns=columns.split())
+    if huge_file:
+        df.to_parquet(f"temp/{temp_file}.parquet", engine="pyarrow", index=False)
+        del rows
+        del df
+        print("Merging all temp files...")
+        merge_parquet_dir("temp", "temp/merged.parquet")
+        df = pd.read_parquet("temp/merged.parquet")
+        print(f"Loaded full dataset with {len(df)} rows")
+
+    return df
 
 
 remove_markdown_links_pattern = r"\[([^\]]+)\]\(([^\)]+)\)"
 remove_remaining_links = r"https?:\/\/[^\s]+"
 
 
+def remove_emojis(string):
+    emoji_pattern = re.compile(
+        "["
+        "\U0001F600-\U0001F64F"  # emoticons
+        "\U0001F300-\U0001F5FF"  # symbols & pictographs
+        "\U0001F680-\U0001F6FF"  # transport & map symbols
+        "\U0001F1E0-\U0001F1FF"  # flags (iOS)
+        "\U00002702-\U000027B0"
+        "\U000024C2-\U0001F251"
+        "]+",
+        flags=re.UNICODE,
+    )
+    return emoji_pattern.sub(r"", string)
+
+
 # Replace HTML content to markdown but remove links
 def to_markdown(text):
-    text = html2text(text, bodywidth=0).strip()
+    try:
+        text = html2text(text, bodywidth=0).strip()
+    except Exception as e:
+        print(e)
+        text = re.sub(r"<[^>]*>", "", str(text))
     text = re.sub(remove_markdown_links_pattern, r"\1", text)
-    text = re.sub(remove_remaining_links, "", text)
-
-    if "http" in text:
-        raise "Found http in markdown: " + text
-    return text
+    text = remove_emojis(text)
+    return re.sub(remove_remaining_links, "", text)
 
 
 if __name__ == "__main__":