Deal with huge files, cleanup, mrege

merge_parquets.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable, Iterable, TypeVar
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+def stream_to_parquet(path: Path, tables: Iterable[pa.Table]) -> None:
+    try:
+        first = next(tables)
+    except StopIteration:
+        return
+    schema = first.schema
+    with pq.ParquetWriter(path, schema) as writer:
+        writer.write_table(first)
+        for table in tables:
+            table = table.cast(schema)  # enforce schema
+            writer.write_table(table)
+
+
+def stream_from_parquet(path: Path) -> Iterable[pa.Table]:
+    reader = pq.ParquetFile(path)
+    for batch in reader.iter_batches():
+        yield pa.Table.from_batches([batch])
+
+
+def stream_from_parquets(paths: Iterable[Path]) -> Iterable[pa.Table]:
+    for path in paths:
+        yield from stream_from_parquet(path)
+
+
+T = TypeVar("T")
+
+
+def coalesce(
+    items: Iterable[T], max_size: int, sizer: Callable[[T], int] = len
+) -> Iterable[list[T]]:
+    """Coalesce items into chunks. Tries to maximize chunk size and not exceed max_size.
+    If an item is larger than max_size, we will always exceed max_size, so make a
+    best effort and place it in its own chunk.
+    You can supply a custom sizer function to determine the size of an item.
+    Default is len.
+    >>> list(coalesce([1, 2, 11, 4, 4, 1, 2], 10, lambda x: x))
+    [[1, 2], [11], [4, 4, 1], [2]]
+    """
+    batch = []
+    current_size = 0
+    for item in items:
+        this_size = sizer(item)
+        if current_size + this_size > max_size:
+            yield batch
+            batch = []
+            current_size = 0
+        batch.append(item)
+        current_size += this_size
+    if batch:
+        yield batch
+
+
+def coalesce_parquets(
+    paths: Iterable[Path], outpath: Path, max_size: int = 2**20
+) -> None:
+    tables = stream_from_parquets(paths)
+    # Instead of coalescing using number of rows as your metric, you could
+    # use pa.Table.nbytes or something.
+    # table_groups = coalesce(tables, max_size, sizer=lambda t: t.nbytes)
+    table_groups = coalesce(tables, max_size)
+    coalesced_tables = (pa.concat_tables(group) for group in table_groups)
+    stream_to_parquet(outpath, coalesced_tables)
+
+
+def merge_parquet_dir(path: str, outpath: Path) -> None:
+    paths = Path(path).glob("*.parquet")
+    coalesce_parquets(paths, outpath)

process.py

@@ -2,12 +2,9 @@
 # Simple script to convert StackExchange XML to Open Assistant format
 # Original code by https://github.com/b-mc2
 
+import os, gc, glob, sys, re
 from bs4 import BeautifulSoup as bs
 import pandas as pd
-import os
-import glob
-import sys
-import re
 from html2text import html2text
 from datasets import load_dataset
 from lxml import etree
@@ -23,12 +20,11 @@ QUESTION_SCORE_TRESHOLD = 0
 ANSWER_SCORE_TRESHOLD = 0
 HF_DATASET = "donfu/oa-stackexchange"
 PARQUET_FILE = "{0}.parquet"
+MAX_LENGTH = 1000  # max length of question or answer
 
 
 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)
 
@@ -44,28 +40,63 @@ def process_dataset(dataset):
     xml_file = f"{XML_DIR}/{dataset}.xml"
     parquet_file = PARQUET_FILE.format(dataset)
     source = SOURCE.format(dataset)
-    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)
+    if not os.path.exists(xml_file):
+        print(f"XML file {xml_file} not found, please download first. Skipping...")
+    elif not os.path.exists(parquet_file):
+        df = parse_and_convert(xml_file, source)
+        save_parquet(df, dataset)
         # upload_hf(dataset)
     else:
-        print(f"XML file {xml_file} not found, please download first. Skipping...")
+        print(f"File already converted {xml_file}. Skipping...")
+
+
+def parse_and_convert(path: str, source: str):
+    """
+    Parse (very large) XML files with sax parser and load it into a pandas Dataframe
+    """
+    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 = []
+    max_process = 10**6
+    processed = 0
+    oa_df = pd.DataFrame(columns=["INSTRUCTION", "RESPONSE", "SOURCE", "METADATA"])
+
+    context = etree.iterparse(path, events=("end",))
+
+    for _, element in tqdm(context, total=total_rows):
+        if element.tag == "row":
+            if len(element.get("Body")) > MAX_LENGTH:
+                continue
+            rows.append(parse_row(element))
+            processed += 1
+            element.clear()
+            while element.getprevious() is not None:
+                del element.getparent()[0]
+
+            if processed % max_process == 0 or processed == total_rows:
+                df = pd.DataFrame(rows, columns=columns.split())
+                rows = []
+                oa = convert_to_oa(df, source)
+                oa_df = pd.concat([oa_df, oa])
+                del df
+                del oa
+                gc.collect()
 
+    return oa_df
 
-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 parse_row(element):
+    return [
+        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)),
+    ]
 
 
 def convert_to_oa(all, source):
@@ -74,26 +105,16 @@ def convert_to_oa(all, source):
 
     Only include questions with an AcceptedAnswerId
     """
-    convert_tags = (
-        lambda raw: raw.replace("-", " ")
-        .replace("><", ", ")
-        .replace("<", "")
-        .replace(">", "")
-    )
-    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(
         questions,
         all,
-        how="left",
+        how="inner",
         left_on="AcceptedAnswerId",
         right_on="Id",
         suffixes=("_q", "_a"),
     )
+
     del all
 
     merged["INSTRUCTION"] = (
@@ -106,6 +127,18 @@ def convert_to_oa(all, source):
     return merged[["INSTRUCTION", "RESPONSE", "SOURCE", "METADATA"]]
 
 
+def convert_tags(raw):
+    return raw.replace("-", " ").replace("><", ", ").replace("<", "").replace(">", "")
+
+
+def create_metadata(row):
+    return {
+        "tags": convert_tags(row["Tags_q"]),
+        "question_score": row["Score_q"],
+        "answer_score": row["Score_a"],
+    }
+
+
 def save_parquet(df, dataset):
     """
     Save Dataframe to Parquet. See here for specs:
@@ -126,98 +159,6 @@ def upload_hf(dataset):
     print("Uploaded to Hugging Face: " + HF_DATASET)
 
 
-# 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):
-    """
-    Parse (very large) XML files with sax parser and load it into a pandas Dataframe
-    """
-    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]+"