added some fiels

fetch_arxiv.py

@@ -0,0 +1,272 @@
+import os
+import sys 
+from pathlib import Path
+import datetime
+
+import tarfile
+import xml.etree.ElementTree as ET 
+from tqdm import tqdm
+import re 
+from itertools import chain, islice
+import requests
+import time
+
+import shutil
+
+import arxiv 
+
+import langdetect
+from langdetect import detect
+
+from utils import Loader as Loader
+from utils import make_archive
+
+def batch_loader(seq, size):
+    """
+    Iterator that takes in a list `seq` and returns
+    chunks of size `size` 
+    """
+    return [seq[pos:pos + size] for pos in range(0, len(seq), size)]
+
+
+def _delete_files_except_pattern(path, pattern, transform = lambda x: None, verbose=False):
+    """
+    recursively
+    """
+    for f in os.listdir(path):
+        f_path = os.path.join(path, f)
+        if verbose: 
+            print(f_path)
+        if os.path.isfile(f_path): 
+            if not re.search(pattern, f):
+                os.chmod(f_path, 0o755)
+                os.remove(f_path)
+            else: 
+                transform(f_path)
+        elif os.path.isdir(f_path):
+            try: 
+                print(f_path)
+            except UnicodeEncodeError: 
+                new_path = f_path.encode("utf-8", 'replace').decode()
+                os.system(f"mv \"{f_path}\" \"{new_path}\"")
+                f_path = new_path
+
+            _delete_files_except_pattern(f_path, pattern, transform=transform, verbose=verbose)
+
+def _download_with_progress_bar(url):
+    response = requests.get(url, stream=True)
+    total_size_in_bytes = int(response.headers.get("content-length", 0))
+    block_size = 1024  # 1 Kibibyte
+    progress_bar = tqdm(total=total_size_in_bytes, unit="iB", unit_scale=True)
+    to_return = bytearray()
+    for data in response.iter_content(block_size):
+        progress_bar.update(len(data))
+        to_return += data
+    progress_bar.close()
+    if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes:
+        raise AssertionError("ERROR, something went wrong")
+
+    return to_return
+
+def get_math_ids(resumption_token="init"): 
+    with Loader(f"fetching metadata shard {resumption_token}..."):
+        if resumption_token=="init": 
+            resp = requests.get("https://export.arxiv.org/oai2?verb=ListIdentifiers&set=math&metadataPrefix=oai_dc")
+        else: 
+            time.sleep(5)
+            resp = requests.get(f"https://export.arxiv.org/oai2?verb=ListIdentifiers&resumptionToken={resumption_token}")
+     
+    root = ET.fromstring(resp.content.decode("utf-8"))
+    articles = root[2]
+
+    math_ids = {}
+    for article in articles: 
+        if article.tag == "{http://www.openarchives.org/OAI/2.0/}resumptionToken": 
+            if article.text: 
+                return math_ids | get_math_ids(resumption_token=article.text)
+            else: 
+                return math_ids
+
+        db_id = article[0].text
+        eyed = db_id[db_id.rindex(":")+1:]
+        math_ids[eyed] = True 
+
+def clean_tex_file(path): 
+    with open(path, encoding="utf-8") as f: 
+        try: 
+            src = f.read()
+        except (UnicodeDecodeError, UnicodeError): 
+            print(f"Decoding error at {path} with utf-8. Trying latin-1")
+            try: 
+                with open(path, encoding="latin-1") as fle: 
+                    src = fle.read()
+                    #print("latin-1 successful\n")
+            except (UnicodeDecodeError, UnicodeError): 
+                #print(f"Decoding error at {path} with latin-1. Trying utf-16")
+                try: 
+                    with open(path, encoding="utf-16") as fl: 
+                        src = fl.read()
+                        #print("utf-16 successful\n")
+                except (UnicodeDecodeError, UnicodeError): 
+                    #print(f"Decoding error at {path} with utf-16. Trying utf-32")
+                    try: 
+                        with open(path, encoding="utf-32") as f: 
+                            src = f.read()
+                    except (UnicodeDecodeError, UnicodeError): 
+                        print(f"Decoding error at {path} with all of utf-8, 16, 32 and latin-1. Deleting this file")
+                        print("This issue should only occur with a handful of quite old files. Continuing...\n")
+                        return 
+
+    end = re.search(r"\\end\{document\}", src)
+    if end: 
+        src = src[:end.span()[1]]
+
+    bib = re.search(r"\\Refs|\\begin\{thebibliography\}", src)
+    if bib:
+        src = src[:bib.span()[0]]
+    
+    os.chmod(path, 0o755)
+    with open(path, "w", encoding="utf-8") as f: 
+        f.write(src)
+
+def clean_tex_file_some_more(path): 
+    with open(path) as f:
+        text = f.read()
+
+    text = re.sub(r"(?<!\\)%.*", "", text)
+
+    match_obj = re.search(r"\\begin\{document\}", text)
+    if match_obj: 
+        text = text[match_obj.span()[0]:]
+
+    match_obj = re.search(r"\\begin\{references\}", text)
+    if match_obj: 
+        text = text[:match_obj.span()[0]]
+
+    text = text.strip()
+
+    os.remove(path)
+    if len(text)>280: 
+        try: 
+            print(path) 
+        except UnicodeEncodeError: 
+            path = path.encode('utf-8', 'replace').decode()
+
+        try: 
+            lang = detect(text)
+        except langdetect.lang_detect_exception.LangDetectException: 
+            # no linguistic features to analyze, delete
+            return 
+        
+        if lang=="en": 
+            with open(path, "w") as f: 
+                f.write(text)
+        else: 
+            print("HIT NONENGLISH ARTICLE")
+
+def process_tarball_old_scheme(tarball_name, save_dir): 
+    tarball_path = os.path.join(save_dir, tarball_name)
+    os.system("tar -xf " + tarball_path + " -C " + save_dir)
+
+    last_ = tarball_name.rfind("_")
+    second_last_ = tarball_name.rfind("_", 0, last_)
+    subdir = tarball_name[second_last_+1:last_]
+    
+    subpath = os.path.join(save_dir, subdir)
+    zipped_names = os.listdir(subpath)
+
+    for zipped_name in zipped_names: 
+        if zipped_name[-len(".gz"):]==".gz": 
+            zipped_path = os.path.join(subpath, zipped_name)
+            if re.match(r"math", zipped_name): 
+                eyed = zipped_name[:-len(".gz")]
+                if tarfile.is_tarfile(zipped_path): 
+                    article_dir = os.path.join(subpath, eyed)
+                    Path(article_dir).mkdir()
+                    os.system("tar -xzf " + zipped_path + " -C " + article_dir)
+                    os.remove(zipped_path)
+                else: 
+                    os.system("gzip -d " + zipped_path)
+                    unzipped_path = os.path.join(subpath, eyed)
+                    os.rename(unzipped_path, unzipped_path + ".tex")
+            else: 
+                os.remove(zipped_path)
+
+    _delete_files_except_pattern(subpath, r".*\.tex", transform=clean_tex_file)
+    os.remove(tarball_path)
+
+def process_tarball(tarball_name, save_dir, math_ids): 
+    tarball_path = os.path.join(save_dir, tarball_name)
+    untar_cmd = "tar -xf " + tarball_path + " -C " + save_dir
+    os.system(untar_cmd)
+    
+    last_ = tarball_name.rfind("_")
+    second_last_ = tarball_name.rfind("_", 0, last_)
+    subdir = tarball_name[second_last_+1:last_]
+    
+    subpath = os.path.join(save_dir, subdir)
+    listdir = os.listdir(subpath)
+
+    ids = [x[:-3] for x in listdir if x[-3:]==".gz"]
+ 
+    for eyed in ids: 
+        if eyed in math_ids: 
+            zipped_path = os.path.join(subpath, eyed + ".gz")
+
+            if tarfile.is_tarfile(zipped_path): 
+                article_dir = os.path.join(subpath, eyed)
+                Path(article_dir).mkdir()
+                os.system("tar -xzf " + zipped_path + " -C " + article_dir)
+                os.remove(zipped_path)
+            else: 
+                os.system("gzip -d " + zipped_path)
+                unzipped_path = os.path.join(subpath, eyed)
+                os.rename(unzipped_path, unzipped_path + ".tex")
+    
+    _delete_files_except_pattern(subpath, r".*\.tex", transform=clean_tex_file)
+    os.remove(tarball_path)
+
+def main(): 
+    """
+    Warning: this code is *extremely* brittle
+    """
+    math_ids = get_math_ids()
+
+    save_dir = "arxiv_1"
+    Path(save_dir).mkdir(exist_ok=True) 
+    manifest_path = os.path.join(save_dir, "manifest.xml")
+    
+    os.system(f"s3cmd get s3://arxiv/src/arXiv_src_manifest.xml --requester-pays {manifest_path}") 
+
+    tree = ET.parse(manifest_path)
+    root = tree.getroot()
+    
+    shards_and_dates = []
+    for child in root: 
+        if child.tag == "file":
+            shard = child[1].text # the index of filename
+            yymm = child[9].text # the index of yymm
+            shards_and_dates.append((shard, yymm))
+ 
+    format_cutoff = datetime.datetime(2007, 3, 1) # arXiv switches from old to new format
+    for shard, yymm in tqdm(shards_and_dates): 
+        print("SHARD: ", shard)
+        os.system(f"s3cmd get s3://arxiv/" + shard + \
+                " --requester-pays " + save_dir) 
+        tarball_name=shard[shard.rindex("/")+1:]
+        
+        # nb this code will stop working in 2051 ;) 
+        year = int("19" + yymm[:2]) if int(yymm[:2])>50 else int("20"+yymm[:2])
+        if datetime.datetime(year, int(yymm[2:]), 1)<=format_cutoff: 
+            process_tarball_old_scheme(tarball_name, save_dir)
+        else: 
+            process_tarball(tarball_name, save_dir, math_ids) 
+
+    os.remove(manifest_path)
+
+if __name__=="__main__": 
+    #main()
+    #_delete_files_except_pattern("arxiv_1", r".*\.tex$", transform=clean_tex_file_some_more)
+    for f in tqdm(os.listdir("arxiv")):
+        f_path = os.path.join("arxiv", f)
+        make_archive(f_path)

fetch_wiki.py

@@ -6,8 +6,14 @@ import re
 import pypandoc
 import json
 from pathlib import Path
+
 from fetch_books_and_formal import _download_with_progress_bar
-from fetch_mathoverflow import batch_loader
+from utils import make_archive
+
+import random
+
+random.seed(20)
+
 
 def page_titles_of_category(cat_page):
         """
@@ -43,8 +49,11 @@ PROOFWIKI_URL = (
     "https://zenodo.org/record/4902289/files/naturalproofs_proofwiki.json?download=1"
 )
 def proofwiki(testing=False):
+    VAL_RATE = 0.025
     save_dir = "wiki/proofwiki"
+    val_dir = "wiki/proofwiki_val"
     Path(save_dir).mkdir(parents=True, exist_ok=True)
+    Path(val_dir).mkdir(parents=True, exist_ok=True)
 
     if testing:
         with open("naturalproofs/proofwiki.json") as f:
@@ -55,48 +64,53 @@ def proofwiki(testing=False):
         struct = json.loads(resp.decode("utf-8"))
         print("DONE DOWNLOADING PROOFWIKI")
     
-    batches = batch_loader(struct["dataset"]["theorems"], 500) 
-    for i, batch in enumerate(batches):
-        thms_list = []
-        for thm in batch:
-            if thm["contents"]:
-                thm_string = "\\section{" + thm["label"] + "}\n"
-                thm_string += (
-                    "Tags: " + ", ".join(thm["categories"]).replace("/", ": ") + "\n\n"
-                )
+    for i, thm in enumerate(struct["dataset"]["theorems"]):
+        if thm["contents"]:
+            thm_string = "\\section{" + thm["label"] + "}\n"
+            thm_string += (
+                "Tags: " + ", ".join(thm["categories"]).replace("/", ": ") + "\n\n"
+            )
 
+            thm_string += (
+                "\\begin{theorem}\n"
+                + "\n".join(thm["contents"])
+                + "\n\\end{theorem}\n\n"
+            )
+
+            for proof in thm["proofs"]:
                 thm_string += (
-                    "\\begin{theorem}\n"
-                    + "\n".join(thm["contents"])
-                    + "\n\\end{theorem}\n\n"
+                    "\\begin{proof}\n"
+                    + "\n".join(proof["contents"])
+                    + "\n\\end{proof}\n\n"
                 )
 
-                for proof in thm["proofs"]:
-                    thm_string += (
-                        "\\begin{proof}\n"
-                        + "\n".join(proof["contents"])
-                        + "\n\\end{proof}\n\n"
-                    )
-
-                thms_list.append(thm_string.strip())
-
-        with open(os.path.join(save_dir, f"shard_{i}.txt"), "w") as f:
-            f.write("<|endoftext|>\n".join(thms_list))
+            if random.random()>VAL_RATE: 
+                with open(os.path.join(save_dir, f"""thm_{thm["id"]}.txt"""), "w") as f:
+                    f.write(thm_string)
+            else: 
+                with open(os.path.join(val_dir, f"""thm_{thm["id"]}.txt"""), "w") as f: 
+                    f.write(thm_string)
 
     defn_strings = []
     for defn in struct["dataset"]["definitions"]:
         if defn["contents"]:
-            defn_strings.append((
+            defn_string = (
                 "\\begin{definition}["
                 + defn["label"]
                 + "]\n"
                 + "\n".join(defn["contents"])
                 + "\n\\end{definition}").strip()
-            )
-
-    with open(os.path.join(save_dir, "defs.txt"), "w") as f:
-        f.write("<|endoftext|>\n".join(defn_strings))
+            
+            if random.random()>VAL_RATE:
+                with open(os.path.join(save_dir, f"""def_{defn["id"]}.txt"""), "w") as f:
+                    f.write(defn_string)
+            else: 
+                with open(os.path.join(val_dir, f"""def_{defn["id"]}.txt"""), "w") as f: 
+                    f.write(defn_string)
+              
 
 if __name__=="__main__": 
     #wikipedia()
     proofwiki()
+    make_archive("wiki/proofwiki")
+    make_archive("wiki/proofwiki_val")

proof-pile.py

@@ -75,6 +75,7 @@ class ProofPile(datasets.GeneratorBasedBuilder):
     # data = datasets.load_dataset('my_dataset', 'first_domain')
     # data = datasets.load_dataset('my_dataset', 'second_domain')
     BUILDER_CONFIGS = [
+    datasets.BuilderConfig(name="arxiv", version=VERSION, description="All of English arxiv.math up to 03/22"),
     datasets.BuilderConfig(name="books", version=VERSION, description="Open source math textbooks"),
     datasets.BuilderConfig(name="formal", version=VERSION, description="Formal math libraries"), 
     datasets.BuilderConfig(name="stack-exchange", version=VERSION, description="math overflow and math stack exchange"), 
@@ -119,9 +120,19 @@ class ProofPile(datasets.GeneratorBasedBuilder):
         with open("splits.json") as f: 
             splits = json.load(f)
 
-        self.archived_configs = ["stack-exchange", "math-dataset", "wiki"]
+        self.archived_configs = ["arxiv", "stack-exchange", "math-dataset", "wiki"]
 
         if self.config.name in self.archived_configs: 
+            if self.config.name=="arxiv": 
+                train_paths = []
+                val_paths = []
+                for f in os.listdir("arxiv"): 
+                    f_path = os.path.join("./arxiv", f)
+                    # validation set is june of years divisible by 4
+                    if int(f[1])%4==0 and int(f[3])==6: 
+                        val_paths.append(f_path)
+                    else: 
+                        train_paths.append(f_path)
             if self.config.name=="stack-exchange": 
                 train_paths = [os.path.join("./stack-exchange", x) for x in ["math_overflow.tar.gz",
                     "math_stack_exchange.tar.gz"]]

test.py

@@ -2,6 +2,9 @@ from datasets import load_dataset
 from itertools import islice
 import sys
 
+dataset = load_dataset("./proof-pile.py", "arxiv")
+print('ARXIV')
+print(dataset)
 """
 dataset = load_dataset("./proof-pile.py", "books")
 print("BOOKS")
@@ -20,11 +23,9 @@ for x in dataset["train"]:
     print(x)
     break
 print(dataset)
-"""
 dataset = load_dataset("./proof-pile.py", "wiki")
 print("WIKI")
 print(dataset)
-"""
 dataset = load_dataset("./proof-pile.py", "math-dataset", download_mode='force_redownload')
 print("MATH DATASET")
 print(dataset)

utils.py

@@ -1,7 +1,53 @@
 import os
 import tarfile 
+from itertools import cycle
+from shutil import get_terminal_size
+from threading import Thread
+from time import sleep
 
 def make_archive(path): 
     with tarfile.open(path + ".tar.gz", "w:gz") as tar: 
         tar.add(path, arcname=os.path.sep)
     os.system(f"rm -r {path}")
+
+class Loader:
+    def __init__(self, desc="Loading...", end="Done!", timeout=0.1):
+        """
+        A loader-like context manager
+
+        Args:
+            desc (str, optional): The loader's description. Defaults to "Loading...".
+            end (str, optional): Final print. Defaults to "Done!".
+            timeout (float, optional): Sleep time between prints. Defaults to 0.1.
+        """
+        self.desc = desc
+        self.end = end
+        self.timeout = timeout
+
+        self._thread = Thread(target=self._animate, daemon=True)
+        self.steps = ["⢿", "⣻", "⣽", "⣾", "⣷", "⣯", "⣟", "⡿"]
+        self.done = False
+
+    def start(self):
+        self._thread.start()
+        return self
+
+    def _animate(self):
+        for c in cycle(self.steps):
+            if self.done:
+                break
+            print(f"\r{self.desc} {c}", flush=True, end="")
+            sleep(self.timeout)
+
+    def __enter__(self):
+        self.start()
+
+    def stop(self):
+        self.done = True
+        cols = get_terminal_size((80, 20)).columns
+        print("\r" + " " * cols, end="", flush=True)
+        print(f"\r{self.end}", flush=True)
+
+    def __exit__(self, exc_type, exc_value, tb):
+        # handle exceptions with those variables ^
+        self.stop()