Add initial scripts

.gitignore

@@ -0,0 +1,2 @@
+xml/
+*.pyc

dl-stackexchange.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+#
+# Simple script to download StackExchange archive XML files with posts (threaded version)
+#
+# Note: you probably want to download stackoverflow.com-Posts.7z manually, as it is 18GB
+# and takes a long time to download. You can try using torrent:
+#
+# webtorrent https://archive.org/download/stackexchange/stackexchange_archive.torrent --select 658
+#
+
+import requests
+import concurrent.futures
+import os
+from bs4 import BeautifulSoup as bs
+import pandas as pd
+import re
+
+base_url = "https://ia600107.us.archive.org/view_archive.php?archive=/27/items/stackexchange/{0}&file=Posts.xml"
+DOWNLOAD_DIR = "xml/"
+NUM_PARALLEL = 20
+RE_IGNORE = r"_meta|stackoverflow\.com\-"
+
+
+def get_all_filenames():
+    """
+    Retrieve all urls from stackexchange archive.
+    This needs quite some mangling because of special cases.
+    """
+    response = requests.get("https://archive.org/download/stackexchange")
+    if response.ok:
+        soup = bs(response.content, "html.parser")
+        table = soup.find("table")
+        link_tags = table.find_all("a")
+        urls = {
+            "stackoverflow": "https://archive.org/download/stackexchange/stackoverflow.com-Posts.7z"
+        }
+        for link in link_tags:
+            url = link["href"]
+            name = url.split(".stackexchange")[0].replace(".", "_").replace("-", "_")
+            name = name.replace("_com_7z", "")
+            if url.endswith("7z") and not re.search(RE_IGNORE, url):
+                urls[name] = base_url.format(url)
+        return urls
+
+
+urls = get_all_filenames()
+
+
+def download_url(dataset_name: str, url: str):
+    if not os.path.exists(DOWNLOAD_DIR):
+        os.mkdir(DOWNLOAD_DIR)
+    cache_path = os.path.join(DOWNLOAD_DIR, dataset_name + ".xml")
+    if os.path.exists(cache_path):
+        print("Using cached: ", cache_path)
+        return cache_path
+    else:
+        print("Downloading xml: ", dataset_name)
+        response = requests.get(url)
+        print("Finished downloading: ", dataset_name)
+        with open(cache_path, "wb") as f:
+            f.write(response.content)
+        return cache_path
+
+
+with concurrent.futures.ThreadPoolExecutor(max_workers=NUM_PARALLEL) as executor:
+    futures = [
+        executor.submit(download_url, dataset, url) for dataset, url in urls.items()
+    ]
+
+# Wait for all downloads to complete
+concurrent.futures.wait(futures)
+
+print("All downloads complete")

process.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+# Simple script to convert StackExchange XML to Open Assistant format
+# Original code by https://github.com/b-mc2
+
+from bs4 import BeautifulSoup as bs
+import pandas as pd
+import os
+import glob
+import sys
+from html2text import html2text
+from datasets import load_dataset
+
+CACHE_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,
+}
+
+
+def main():
+    datasets = sys.argv[1:] if len(sys.argv) > 1 else list_cached_datasets()
+    for dataset in datasets:
+        process_dataset(dataset)
+
+
+def list_cached_datasets():
+    xml_files = glob.glob(f"{CACHE_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"
+    source = SOURCE.format(dataset)
+    if os.path.exists(xml_file):
+        df = xml_to_df(xml_file, source)
+        # df = filter_only_questions_with_accepted_answers(df)
+        # df = filter_scores_above(df, QUESTION_SCORE_TRESHOLD, ANSWER_SCORE_TRESHOLD)
+        # df = clean_tags(df)
+        # df = convert_html_to_markdown(df)
+        # df = group_qa(df)
+        oa = convert_to_oa(df)
+        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):
+    """
+    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("-", " ")
+        .replace("><", ", ")
+        .replace("<", "")
+        .replace(">", "")
+        if isinstance(row["Tags_q"], str)
+        else "",
+        "score": row["Score_q"],
+        "views": row["ViewCount_q"],
+    }
+    questions = all[all["AcceptedAnswerId"] != 0]
+    merged = pd.merge(
+        questions,
+        all,
+        how="left",
+        left_on="AcceptedAnswerId",
+        right_on="Id",
+        suffixes=("_q", "_a"),
+    )
+    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["METADATA"] = merged.apply(create_metadata, axis=1)
+
+    return merged[["INSTRUCTION", "RESPONSE", "SOURCE", "METADATA"]]
+
+
+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"
+    df.to_parquet(parquet_file, row_group_size=100, engine="pyarrow", index=False)
+    print("Converted data into parquet format: " + parquet_file)
+
+
+def upload_hf(dataset):
+    """
+    Upload to Hugging Face
+    """
+    parquet_file = f"{dataset}.parquet"
+    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):
+    """
+    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
+    """
+    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
+
+
+def filter_only_questions_with_accepted_answers(df):
+    """
+    Filter only to Questions with Accepted Answers
+
+    Filter dataframe by questions that have accepted answers, should also include
+    all rows of answers for those questions, even if not accepted.
+
+    Parameters:
+    df (DataFrame): containing a "AcceptedAnswerId", "Id", and "ParentId" columns
+
+    Returns:
+    df (DataFrame): current dataframe with filtered results
+    """
+    accepted_ids = df[df["AcceptedAnswerId"] != 0]["Id"].tolist()
+    return df[(df["AcceptedAnswerId"] != 0) | (df["ParentId"].isin(accepted_ids))]
+
+
+def filter_scores_above(
+    df, question_score_threshold: int = 20, answer_score_threshold: int = 20
+):
+    """
+    Filter Dataframe by minimum scores
+
+    Filter Question and Answer columns by score thresholds to trim lower scoring results
+
+    Parameters:
+    df (DataFrame): containing a "Score" column
+
+    Returns:
+    df (DataFrame): current dataframe with filtered results
+    """
+    return df[
+        ((df["Score"] >= question_score_threshold) & (df.PostTypeId == 1))
+        | ((df["Score"] >= answer_score_threshold) & (df.PostTypeId == 2))
+    ]
+
+
+to_markdown = (
+    lambda row: html2text(row, bodywidth=0).strip() if isinstance(row, str) else ""
+)
+
+
+def convert_html_to_markdown(df, column: str = "Body"):
+    """
+    Convert HTML tags to markdown
+
+    Feeds HTML text body into markdown. Remove final newline from <p> tags
+
+    Parameters:
+    df (DataFrame): containing a "Body" column with HTML
+
+    Returns:
+    df (DataFrame): current dataframe with parsed column
+    """
+    df.dropna(subset=[column], inplace=True)
+    df[f"{column}Clean"] = df[column].apply(to_markdown)
+    return df
+
+
+def clean_tags(df):
+    """
+    Convert Tags into Comma separated
+
+    Converts Tag slugs into commas separated tags
+
+    Parameters:
+    df (DataFrame): containing a "Tags" column with slugs
+
+    Returns:
+    df (DataFrame): current dataframe with parsed column
+    """
+    df["TagsClean"] = (
+        df["Tags"]
+        .str.replace("-", " ")
+        .str.replace("><", ", ")
+        .str.replace("<", "")
+        .str.replace(">", "")
+    )
+    return df
+
+
+def group_qa(df):
+    """
+    Group Questions and Answers
+    """
+    questions = df[df.PostTypeId == 1]
+    answers = df[df.PostTypeId == 2]
+
+    df = pd.merge(
+        questions,
+        answers[
+            [
+                "Id",
+                "CreationDate",
+                "Score",
+                "ViewCount",
+                "CommentCount",
+                "ContentLicense",
+                "TagsClean",
+                "BodyClean",
+                "ParentId",
+            ]
+        ],
+        left_on="Id",
+        right_on="ParentId",
+        suffixes=("_q", "_a"),
+        how="left",
+    )
+
+    df["AcceptedAnswerFlag"] = df.apply(
+        lambda row: row["Id_a"] == row["AcceptedAnswerId"], axis=1
+    )
+
+    df = df.rename(
+        columns={
+            "BodyClean_q": "Question",
+            "Score_q": "QuestionScore",
+            "TagsClean_q": "QuestionTags",
+            "BodyClean_a": "Answer",
+            "Score_a": "AnswerScore",
+            "ContentLicense_q": "QuestionContentLicense",
+            "ContentLicense_a": "AnswerContentLicense",
+            "CreationDate_q": "CreationDate",
+        }
+    )
+
+    df = (
+        df.sort_values(
+            by=["AcceptedAnswerFlag", "AnswerScore"], ascending=[False, False]
+        )
+        .groupby("Question")
+        .head(MAX_ANSWERS)
+        .reset_index(drop=True)
+    )
+    df = (
+        df.groupby(
+            [
+                "Title",
+                "Question",
+                "QuestionScore",
+                "QuestionTags",
+                "QuestionContentLicense",
+                "DataSource",
+                "CreationDate",
+            ]
+        )
+        .apply(
+            lambda x: x[["Answer", "AnswerScore", "AcceptedAnswerFlag"]].to_dict(
+                "records"
+            )
+        )
+        .reset_index()
+        .rename(columns={0: "Answers"})
+    )
+    return df
+
+
+if __name__ == "__main__":
+    main()