Initial Commit

.gitattributes

@@ -0,0 +1,58 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+
+
+*.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,164 @@
+---
+annotations_creators:
+  - no-annotation
+language_creators:
+  - crowdsourced
+license:
+  - cc-by-sa-4.0
+task_categories:
+  - text-generation
+  - fill-mask
+task_ids:
+  - language-modeling
+  - masked-language-modeling
+source_datasets:
+  - original
+language:
+  - en
+
+configs:
+- config_name: default
+  data_files:
+  - split: final
+    path: "data/Fandom-v0.5.jsonl"
+  - split: raw-pre-roblox
+    path: "v2.5-chunks/*.jsonl"
+  - split: raw-post-roblox
+    path: "v2.5-chunks-roblox-filter/*.jsonl"
+
+pretty_name: Fanatic Fandom
+---
+
+# Dataset Card for Fanatic Fandom
+
+![](FandomWaifu.png "SD-Generated image styled in the same essence with fandom's logo")
+
+*Waifu to catch your attention.*
+
+## Dataset Details
+
+### Dataset Description
+
+*Fanatic Fandom* is a cleaned dataset of a raw scrape of fandom wikis. We crawled all the publicly available wikis and crawled each page.  
+Filtering to a total amount of tokens of **~7.43B** (llama-2-7b-chat-tokenizer) / **~6.27B** (RWKV Tokenizer) from primarily English language.
+
+- **Curated by:** KaraKaraWitch
+- **Funded by [optional]:** Recursal.ai (I work there lol)
+- **Shared by [optional]:** KaraKaraWitch
+- **Language(s) (NLP):** Primarily English
+- **License:** cc-by-sa-4.0
+
+### Dataset Sources [optional]
+
+- **Source Data:** [https://fandom.com/](https://fandom.com/) (Bot Crawled.)
+
+### Processing and Filtering
+
+We detail the following steps involved in scraping, indexing and cleaning fandom wikis to the html content files. Here's a breakdown of the process:
+
+1. **Wiki Identification:**
+    - `WikisIndexer.py` script retrieves a list of wikis from `https://community.fandom.com/Special:NewWikis`.
+
+2. **Page Indexing:**
+    - `IndexFandomPages.py` script utilizes the MediaWiki API (`api.php`) to gather a list of pages per each wiki.
+
+3. **Page Fetching:**
+    - `WikiPageFetcher.py` script utilizes the MediaWiki API (`api.php`) to render the render the wiki page and save it to a large JSONL file.
+    - Additionally, any wikis with less than 5 pages are not scrapped due to assumed low-quality.
+
+4. **Data Chunking:**
+    - A single large JSONL file containing all fetched pages is split into smaller, more manageable chunks.
+    - This is in preparation from the 4th step.
+
+5. **Roblox Wiki Removal:**
+    - The `RobloxWikiFilter.py` script identifies and removes Roblox wikis due to the high volume of low-quality content they often generate. This filtering step simplifies the subsequent stub article removal process.
+    - From quick napkin math: around 15.2% (Comparing Step 3 and Step 4 results) of fandom wikis are Roblox data.
+
+6. **Content Transformation:**
+    - HTML content is converted to Markdown format. The conversion process removes unnecessary elements like figures, stub article notices, and other irrelevant data.
+
+**Note:** Due to the passage of time (approximately 3 months as of May 6, 2024), the specific details of the crawling process may be a little hazy. The primary challenge encountered was the significant time required to complete the crawling operation.
+
+### Data Splits
+
+There are 3 splits for this dataset:
+
+- final
+  - Contains the final 25GB jsonl file.
+  - You probably want this for training.
+- raw-pre-roblox
+  - Raw files, **before** Roblox filtering.
+  - Use this if you want to start from scratch and don't want to crawl fandom again.
+- raw-post-roblox
+  - Raw files, **after** Roblox filtering.
+  - Roblox wikis removed.
+  - Use this if you want to start from scratch and don't want to crawl fandom again.
+
+### Data Keys
+
+For this dataset, we have included most of the various steps for the dataset. They are listed as such below:
+
+- `fandom_wikis_210224.csv`
+  - A CSV file containing a list of wikis found when scrapping from `Special:NewWikis` on 21/02/2024
+  - The key is as follows: `Sub Domain,Name of Wiki,Path name,0`
+  - The stray zero can be ignored as it does not serve any purpose.
+- `fandom_wikis_pages_210224_v2.jsonl`
+  - Contains a jsonl list of wiki pages per each wiki.
+  - Each jsonl has the following keys:
+  - domain: str [The subdomain.]
+  - path: str [Path to `api.php`. Which can be different for different languages]
+  - pages: list[str] [A list of strings containing page names]
+- `v2.5-chunks` [folder]
+  - Contains all the pages fetched from the list in `fandom_wikis_pages_210224_v2.jsonl`
+  - The original file it was from is `fandom_wikis_pages_contents_210224_v2.jsonl`, which is 283.44GB in size and can't be uploaded to HF.
+  - Each jsonl has the following keys:
+  - domain: str [The subdomain.]
+  - path: str [Path to `api.php`. Which can be different for different languages]
+  - pages: str [Page name]
+  - content: raw response from api.php
+- `v2.5-chunks-roblox-filter` [folder]
+  - Contains files after roblox has been filtered.
+  - Each jsonl has the following keys:
+    - domain: str [The subdomain.]
+    - path: str [Path to `api.php`. Which can be different for different languages]
+    - pages: str [Page name]
+    - content: raw response from api.php
+- `fandom-v0.5.jsonl` [file]
+  - Jsonl file containing the fully processed text.
+  - Each jsonl has the following keys:
+    - text: str [The text content.]
+    - meta: dict[str,str] [dictionary of metadata]
+      - title: str [The page/name]
+      - domain: str [The subdomain.]
+      - cats: str [Categories. Extracted and unused.]
+      - removed: list[str] [A list of removed stubs / html content]
+
+- `roblox.domains.txt` [Extras]
+  - A txt list of Roblox domains.
+
+### Dataset Curators
+
+KaraKaraWitch. (I typically hangout in PygmalionAI discord, sometimes EleutherAI. If something is wrong, `@karakarawitch` on discord.)
+
+I'd be happy if you could spread the word and recommend this dataset for your use cases `:)`
+
+### Licensing Information
+
+Most of all fandom user-created content are licensed under CC-BY-SA unless otherwise noted. By that assumption, we did not include any figures or images as they typically are not licensed under the CC-BY-SA license.
+
+### Citation Information
+
+```
+@ONLINE{fantaticfandom,
+  title         = {FanaticFandom},
+  author        = {KaraKaraWitch, recursal.ai},
+  year          = {2023},
+  howpublished  = {\url{TBD}},
+}
+```
+
+### Special Thanks
+
+- [undeleted](https://huggingface.co/undeleted) from RyokoAI for providing initial scripts to base stuff on.  
+  I eventually decided to write my own scraper while taking inspiration from their code.
+- [Google / Gemini]... I'm horrible at writing professional stuff lol.

Scripts/HTML2Markdown.py

@@ -0,0 +1,451 @@
+import multiprocessing
+import pathlib
+import re
+import string
+import traceback
+from multiprocessing import Queue
+
+import markdownify
+import orjson
+import tqdm
+from bs4 import BeautifulSoup, Comment, NavigableString, Tag
+from markdownify import chomp
+
+if __name__ == "__main__":
+    multiprocessing.set_start_method("forkserver")
+
+
+queue = Queue(maxsize=64)
+
+
+class WikiConverter(markdownify.MarkdownConverter):
+    def convert_a(self, el, text, convert_as_inline):
+        prefix, suffix, text = chomp(text)
+        if not text:
+            return ""
+        return "%s%s%s" % (prefix, text, suffix)
+
+    integer_rgx = re.compile("^[0-9]*$")
+
+    @staticmethod
+    def is_intable(string: str):
+        if not string or not string.isdigit():
+            return False
+        if WikiConverter.integer_rgx.match(string):
+            return True
+
+    def convert_img(self, el, text, convert_as_inline):
+        convert_as_inline = True
+        if (
+            convert_as_inline
+            and el.parent.name not in self.options["keep_inline_images_in"]
+        ):
+            return ""
+        return ""
+
+    def convert_li(self, el, text, convert_as_inline):
+        parent = el.parent
+        if parent is not None and parent.name == "ol":
+            start = parent.get("start")
+            if start and WikiConverter.is_intable(start.strip()):
+                start = int(start.strip())
+            else:
+                start = 1
+            bullet = "%s." % (start + parent.index(el))
+        else:
+            depth = -1
+            while el:
+                if el.name == "ul":
+                    depth += 1
+                el = el.parent
+            bullets = self.options["bullets"]
+            bullet = bullets[depth % len(bullets)]
+        return "%s %s\n" % (bullet, (text or "").strip())
+
+
+wk = WikiConverter()
+
+
+def table_filtration(input_soup: BeautifulSoup, title):
+    for table in input_soup.select("table"):
+        tds = len(table.find_all("td"))
+        texsize = len(table.get_text().replace(" ", ""))
+        if tds >= texsize and texsize < 50:
+            table.decompose()
+        if tds > 20:
+            # print("Decompose Excessive td")
+            table.decompose()
+            # print(table.get_text().replace(" ", ""))
+            # print("Removing table from", title, ". TD exceeds Content")
+    return input_soup
+
+
+def soup_data(data: BeautifulSoup, title: str):
+    soup = data
+
+    # Navigation elements
+    [toc.decompose() for toc in soup.find_all("div", attrs={"class": "toc"})]
+    [toc.decompose() for toc in soup.select("[class*='nav']")]
+    # [toc.decompose() for toc in soup.select(".navbox")]
+    # Edit Section
+    [element.decompose() for element in soup.select(".mw-editsection")]
+    # Remove styles
+    [element.decompose() for element in soup.select("style")]
+
+    [element.decompose() for element in soup.select("sup.reference")]
+    # star-citizen.wiki.
+    [element.decompose() for element in soup.select(".thumbcaption")]
+    # Images and pictures are not under licenses typically.
+    [toc.decompose() for toc in soup.select("audio")]
+    [toc.decompose() for toc in soup.select("picture")]
+    [toc.decompose() for toc in soup.select("img")]
+    [toc.decompose() for toc in soup.select("[class*='video']")]
+    # Blazblue.wiki
+    [toc.decompose() for toc in soup.select("[class*='tooltip']")]
+    [toc.decompose() for toc in soup.select("video")]
+
+    [
+        toc.decompose()
+        for toc in soup.select(".no-featured-video .featured-video-player-container")
+    ]
+    # print(soup)
+    cleaned_soup = table_filtration(soup, title)
+    composed_data = (
+        re.sub(r"\n\s*\n", "\n\n", wk.convert_soup(cleaned_soup))
+        .replace("\n |\n|", " |\n")
+        .strip()
+    )
+    return composed_data
+
+
+raw_puncts = string.punctuation + "｛｝（）［］【】、，゠＝…‥。「」『』〝〟"
+
+puncts = str.maketrans("", "", raw_puncts)
+
+cpl = re.compile(r"\n\s*\n")
+
+dbg_q = multiprocessing.Queue()
+
+
+def debug_queue():
+    try:
+        with open("debug.txt", "w", encoding="utf-8") as f:
+            while True:
+                z = dbg_q.get()
+                if z is None or z == "None":
+                    break
+                f.write(z + "\n")
+                f.flush()
+    except Exception as e:
+        print(e)
+
+
+# Filters based on classes
+msgbox = set(["mbox", "notice", "hidden", "plainlinks"])
+msgbox2 = set(["mbox", "notice", "stub-box", "plainlinks"])
+msgbox3 = set(["notice", "metadata", "plainlinks"])
+# Aggressive class filter.
+msgbox_agressive = set(
+    [
+        "mbox-w",
+        "mbox",
+        "msgbox",
+        "notice-container",
+        "notice",
+        "message-box",
+        "boilerplate",
+        "ambox",
+        "ombox",
+    ]
+)
+
+wikistub = set(["wikistub"])
+
+
+def get_text_cleaned(elem):
+    return (
+        cpl.sub("\n\n", elem.get_text(" "))
+        .replace("\n", " ")
+        .replace("  ", " ")
+        .replace("  ", " ")
+        .lower()
+    )
+
+
+def get_plain_text_clean(data: str):
+    return (
+        cpl.sub("\n\n", data.translate(puncts))
+        .replace("\n", " ")
+        .replace("  ", " ")
+        .replace("  ", " ")
+        .lower()
+    )
+
+
+t_stubs = 0
+f_stubs = 0
+
+t_lock = multiprocessing.Lock()
+
+
+def t_inc(idx: int):
+    global t_stubs
+    with t_lock:
+        t_stubs += idx
+
+
+f_lock = multiprocessing.Lock()
+
+
+def f_inc(idx: int):
+    global f_stubs
+    with f_lock:
+        f_stubs += idx
+
+
+def stub_removal(soup: str, debug=None):
+    b_soup = BeautifulSoup(soup, "lxml")
+    a = get_text_cleaned(b_soup)
+    if "this article is a stub" in a:
+        parser = b_soup.select_one(".mw-parser-output")
+        if parser is None:
+            return b_soup, []
+        pruned = []
+        for child in parser.children:
+            if child is None:
+                continue
+            if isinstance(child, Comment):
+                continue
+            if isinstance(child, NavigableString):
+                # print("Nav string?")
+                # print(child)
+                # print("===========")
+                continue
+            if not isinstance(child, Tag):
+                # print(type(child))
+                continue
+            classes = set(i.lower() for i in child.get("class", []))
+            styles = child.get("style", "")
+            has_border = False
+            if styles:
+                styles = {
+                    i.split(":")[0]: ":".join(i.split(":")[1:])
+                    for i in child.get("style", "").split(";")
+                }
+
+                has_border = any(
+                    [
+                        styles.get("border"),
+                        styles.get("border-width") and styles.get("border-style"),
+                        styles.get("border-top"),
+                        styles.get("border-bottom"),
+                        styles.get("border-left"),
+                        styles.get("border-right"),
+                        styles.get("background"),
+                    ]
+                )
+                # print(styles)
+
+            child_text = get_text_cleaned(child)
+            has_stub_word = "stub" in child_text and "this article" in child_text
+            c_name = "" if not child.name else child.name
+
+            if not has_stub_word:
+                continue
+            if (
+                len(classes.intersection(msgbox)) == len(msgbox)
+                or len(classes.intersection(msgbox2)) == len(msgbox2)
+                or len(classes.intersection(msgbox3)) == len(msgbox3)
+            ):  # Seems to be safe.
+                child.decompose()
+                pruned.append("mbox")
+            elif len(classes.intersection(msgbox_agressive)) > 0:  # Aggressive
+                child.decompose()
+                # dbg_q.put(f'[I aggressive "mbox3_aggressive" prune]: {debug}')
+                pruned.append("mbox3_aggressive")
+            elif len(classes.intersection(wikistub)) == 1:  # Seems to be safe.
+                child.decompose()
+                pruned.append("wikistub[gods-games-we-play]")
+            elif "table" in c_name:  # Bit risky, but i guess it works?
+                pruned.append("table[stub-word]")
+                child.decompose()
+            elif "dl" in c_name:  # Seems to be safe.
+                if len(child.find_all("dd", recursive=False)) == 1:
+                    pruned.append("dl > dd")
+                    child.decompose()
+            elif "div" in c_name:
+                inner_elements = [
+                    i for i in child.find_all(recursive=False) if isinstance(i, Tag)
+                ]
+                if len(inner_elements) == 0:
+                    # print(child.find_all(recursive=False))
+                    # dbg_q.put(f"[No Inner Element()?]: {len(inner_elements)}")
+                    continue
+                stub_inner = get_text_cleaned(inner_elements[0])
+                has_stub_word = "stub" in stub_inner and "this article"
+
+                if len(inner_elements) == 0 or len(inner_elements) > 2:
+                    # dbg_q.put(
+                    #     f"[W No Prune len()? has_stub_word]: {debug} {has_stub_word} {len(inner_elements)}"
+                    # )
+                    continue
+                if (
+                    inner_elements[0].name
+                    and inner_elements[0].name == "table"
+                    and has_stub_word
+                ):
+                    pruned.append("table[stub-word]")
+                    child.decompose()
+                elif has_border and inner_elements[0].name.lower() in [
+                    "div",
+                    "p",
+                    "span",
+                ]:
+                    # dbg_q.put(f'[I Risky "has_border" prune]: {debug}')
+                    pruned.append("risky[border]")
+                else:
+                    # dbg_q.put(
+                    #     f"[W No Prune div? has_stub_word]: {debug} {has_stub_word} {inner_elements[0].name}"
+                    # )
+                    pruned.append("?")
+            elif "p" in c_name:  # Really risky. will try logging it first.
+                child.decompose()
+                # dbg_q.put(f'[I Risky "p" prune]: {debug}')
+                f_inc(1)
+                pruned.append("risky[p]")
+            elif "center" in c_name:  # Really risky. will try logging it first.
+                # dbg_q.put(f'[I Risky "center" prune]: {debug}')
+                child.decompose()
+                f_inc(1)
+                pruned.append("risky[center]")
+        if pruned:
+            t_inc(len(pruned))
+            # print("Pruned", pruned, debug)
+            return b_soup, pruned
+        else:
+            # dbg_q.put(f"[W No Prune?]: {debug}")
+            # print(f"[W No Prune?]: {debug}")
+            return b_soup, []
+
+    return b_soup, []
+
+
+def writer(fp: str, writer_queue: multiprocessing.Queue):
+    pbar = tqdm.tqdm()
+    try:
+        with open(fp, "wb") as fl:
+            while True:
+                q = writer_queue.get(block=True)
+                if q is None or isinstance(q, str) and q == "None":
+                    print("Q Empty, exit.")
+                    break
+                elif isinstance(q, bytes):
+                    fl.write(q)
+                    fl.write(b"\n")
+                pbar.update(1)
+    except Exception as e:
+        print("Writer Crashed?")
+        traceback.print_exception(e)
+
+
+def mt_fn(bytes_data: bytes, write_queue: multiprocessing.Queue):
+    data = orjson.loads(bytes_data)
+    dbg = f"domain: {data['domain']} title: {data['page']}"
+    if "parse" not in data["content"]:
+        print(
+            "Missing parse content",
+            "domain",
+            data["domain"],
+            "title",
+            data["page"],
+        )
+        return
+    lower_title = data["page"].lower()
+    if (
+        lower_title.startswith("forum:")
+        or lower_title.startswith("discussion:")
+        or lower_title.startswith("thread:")
+        or lower_title.startswith("comments:")
+        or lower_title.startswith("comment:")
+    ):
+        return
+    if lower_title.endswith("gallery"):
+        return
+    soup = data["content"]["parse"]["text"]["*"]
+    cats = ",".join([z["*"] for z in data["content"]["parse"]["categories"]]).lower()
+    unstubbed_soup, removed = stub_removal(soup, debug=dbg)
+    text = soup_data(unstubbed_soup, data["page"])
+    unpunct = get_plain_text_clean(text)
+    if len(unpunct) > 64:
+        # print(text[:64])
+        write_queue.put(
+            orjson.dumps(
+                {
+                    "text": text,
+                    "meta": {
+                        "title": data["page"],
+                        "domain": data["domain"],
+                        "cats": cats,
+                        "removed": removed,
+                    },
+                }
+            )
+        )
+
+
+def err_handler(e):
+    if "KeyboardInterrupt" not in str(e):
+        traceback.print_exception(e)
+
+
+def main():
+    with multiprocessing.Pool(processes=64) as pool:
+        managed = multiprocessing.Manager()
+        writer_out = managed.Queue()
+        write_proc = multiprocessing.Process(
+            target=writer, args=("test.jsonl", writer_out), daemon=False
+        )
+        # debug_tasks.start()
+        write_proc.start()
+
+        tasks = []
+        for file in pathlib.Path("v2.5-chunks-roblox-filter").iterdir():
+            with open(file, "rb") as f:
+                iter_wrapper = f  # tqdm.tqdm(f)
+                for line in iter_wrapper:
+                    tasks.append(
+                        pool.apply_async(
+                            mt_fn, args=(line, writer_out), error_callback=err_handler
+                        )
+                    )
+
+                    if len(tasks) >= 100000:
+                        print("Waiting for Chunked task to complete.")
+                        for task in tasks:
+                            if task.ready():
+                                continue
+                            task.wait()
+                        tasks = []
+            print("[I] ========== Task gen done", file)
+        print("Waiting for Chunked task to complete.")
+        for task in tasks:
+            if task.ready():
+                continue
+            task.wait()
+        print("Cleanup")
+        # print("Stubs", t_stubs, "FStubs", f_stubs)
+        dbg_q.put("None")
+        # debug_tasks.join()
+        writer_out.put("None")
+        # while not writer_out.empty():
+        #     print(f"Waiting for empty writer {writer_out.qsize()} items left")
+        #     time.sleep(5)
+
+        write_proc.join()
+
+        pool.close()
+        pool.join()
+
+
+if __name__ == "__main__":
+    main()

Scripts/IndexFandomPages.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+# License: MIT
+# Copyright (C) 2024, Shinon.
+# Code inspiration from Ronsor Labs. Licensed as below.
+# License: AGPL 3.0
+# Copyright (C) 2023, 2024 Ronsor Labs.
+import asyncio
+import concurrent.futures as conc
+import csv
+import pathlib
+import random
+import urllib.parse
+
+import aiofile
+import httpx
+import orjson
+import tqdm
+from bs4 import BeautifulSoup
+
+from proxy_magic_session import get_async_session
+
+CONCURRENT_WORKERS = 128
+
+executor = conc.ProcessPoolExecutor(max_workers=64)
+
+queue = asyncio.Queue(maxsize=1048576)
+
+WIKI_LIST = pathlib.Path("fandom_wikis_210224.csv")
+OUPUT_JSONL = pathlib.Path("fandom_wikis_pages_210224_v2.jsonl")
+
+
+def parse_special_index(html_text: str):
+    doc = BeautifulSoup(html_text, "lxml")
+
+    page_list_li = doc.select("ul.mw-allpages-chunk li a")
+    page_list = set()
+    for page_item in page_list_li:
+        page_title = page_item.get("title", "")
+        if not page_title or page_title is None:
+            print("[W] no page title?")
+            continue
+        if page_title.lower().rstrip().endswith("(redirect)"):
+            continue
+        else:
+            page_list.add(page_item["title"])
+    page_list = list(page_list)
+
+    next_url = doc.select(".mw-allpages-nav a")
+    if next_url is None or len(next_url) == 0:
+        next_url = None
+    else:
+        candidates = next_url
+        next_url = None
+        for x in candidates:
+            if "next page" in x.text.lower():
+                if "index.php" not in x["href"].lower():
+                    next_url = x["href"].split("=", 1)
+                    next_url[1] = urllib.parse.quote_plus(
+                        next_url[1].replace("+", "__SAFE_PLUS__")
+                    ).replace("__SAFE_PLUS__", "+")
+                    next_url = "=".join(next_url)
+                else:
+                    next_url = x["href"]
+
+    return page_list, next_url
+
+
+async def domain_procesor(domain: str, path: str):
+    session: httpx.AsyncClient = get_async_session()
+    loop = asyncio.get_running_loop()
+    session.cookies.clear()
+    session.headers["user-agent"] = (
+        "Mozilla/6.2 (compatible; Microsoft Chrome 137.0; Apple Gecko 47.0 in AOL Firefox 37.6) Google Toolbar/1.3"
+    )
+    print(f"[I] Processing: https://{domain}{path}Special:AllPages")
+    tries = 10
+    # pbar = tqdm.tqdm(desc=f"{domain}")
+    data = None
+    while True:
+        try:
+            data = await session.get(
+                f"https://{domain}{path}Special:AllPages", follow_redirects=True
+            )
+            if data.status_code != 200:
+                if data.status_code == 410:
+                    break
+
+                # print(f"https://{domain}{path}Special:AllPages", data.status_code)
+                continue
+            break
+        except httpx.TransportError as e:
+            await session.aclose()
+            session: httpx.AsyncClient = get_async_session()
+            print(f"[W] Retry TransportError https://{domain}{path} {e}")
+            await asyncio.sleep(1)
+            tries -= 1
+        except httpx.HTTPError as e:
+            print(f"[W] Uncaught Exception Retry... https://{domain}{path} | {e}")
+            await session.aclose()
+            session: httpx.AsyncClient = get_async_session()
+            # print(f"[W] Retry TransportError https://{domain}{path} {e}")
+            await asyncio.sleep(1)
+            tries -= 1
+        except Exception as e:
+            print(f"[W] Uncaught Exception https://{domain}{path} | {e}")
+            break
+        if tries <= 0:
+            print(f"[W] Tries Exceeded https://{domain}{path}")
+            break
+
+    if tries <= 0 or data is None:
+        return
+    if data.status_code == 410:
+        return
+
+    # Handle redirected domains
+    domain = data.url.host
+
+    page_list, next_url = await loop.run_in_executor(
+        executor, parse_special_index, data.text
+    )
+    # pbar.update(len(page_list))
+    while next_url:
+        tries = 10
+        data = None
+        while True:
+            try:
+                data = await session.get(
+                    f"https://{domain}{next_url}", follow_redirects=True
+                )
+                if data.status_code != 200:
+                    if data.status_code == 410:
+                        break
+                    print(f"https://{domain}{next_url}", data.status_code)
+                    continue
+                break
+            except httpx.TransportError as e:
+                await session.aclose()
+                session: httpx.AsyncClient = get_async_session()
+                print(f"[W2] Retry TransportError https://{domain}{next_url} {e}")
+                await asyncio.sleep(1)
+                tries -= 1
+            except httpx.HTTPError as e:
+                print(
+                    f"[W2] Uncaught Exception Retry... https://{domain}{next_url} | {e}"
+                )
+                await session.aclose()
+                session: httpx.AsyncClient = get_async_session()
+                # print(f"[W] Retry TransportError https://{domain}{path} {e}")
+                await asyncio.sleep(1)
+                tries -= 1
+            except Exception as e:
+                print(f"[W2] Uncaught Exception https://{domain}{next_url} | {e}")
+                break
+            if tries <= 0:
+                print(f"[W2] Tries Exceeded https://{domain}{next_url}")
+                break
+        if tries <= 0 or data is None:
+            return
+        if data.status_code == 410:
+            return
+        new_page_list, next_url = await loop.run_in_executor(
+            executor, parse_special_index, data.text
+        )
+        # pbar.update(len(new_page_list))
+        page_list.extend(new_page_list)
+    # pbar.close()
+    print(f"[I] Done: {domain} | {len(page_list)}")
+    await session.aclose()
+    return page_list
+
+
+export_queue = asyncio.Queue(CONCURRENT_WORKERS + 1)
+
+
+async def compiler_worker():
+    loop = asyncio.get_running_loop()
+    async with aiofile.async_open(OUPUT_JSONL, "ab") as f:
+        while True:
+            page_data = await export_queue.get()
+            if page_data is None:
+                break
+            domain, pages, path = page_data
+            print(f"[I] Dump: {domain}")
+            fi = {"domain": domain, "path": path, "pages": pages}
+            bytes_data = await loop.run_in_executor(executor, orjson.dumps, fi)
+            await f.write(bytes_data)
+            await f.write(b"\n")
+            print(f"[I] OKDump: {domain}")
+
+
+async def worker():
+    await asyncio.sleep(random.uniform(1, CONCURRENT_WORKERS / 60))
+    while True:
+        domain_root = await queue.get()
+        if domain_root is None:
+            break
+        domain, _, path, __ = domain_root
+        if path == "":
+            path = "/wiki/"
+        if "vpn-restricted" in domain:
+            continue
+        pages = await domain_procesor(domain, path)
+        if pages is None:
+            continue
+        await export_queue.put((domain, pages, path))
+
+
+async def main():
+    loop = asyncio.get_running_loop()
+    workers = [loop.create_task(worker()) for _ in range(CONCURRENT_WORKERS)]
+    writer = loop.create_task(compiler_worker())
+
+    seen_domains = set()
+    if OUPUT_JSONL.exists():
+        print("[I] Fetching seen domains...")
+        with open(OUPUT_JSONL, "rb") as f:
+            for line in tqdm.tqdm(f, desc="Domains Parsed"):
+                seen_domains.add(orjson.loads(line)["domain"])
+
+    with open(WIKI_LIST) as f:
+        reader = csv.reader(f)
+        for line in reader:
+            if len(line) == 0:
+                continue
+            domain, friendly_name, path, has_scraped = line
+            if domain[0] == "#":
+                continue
+            if domain in seen_domains:
+                continue
+            await queue.put((domain, friendly_name, path, has_scraped))
+    for _ in range(CONCURRENT_WORKERS + 1):
+        await queue.put(None)
+
+    await asyncio.gather(*workers)
+    await export_queue.put(None)
+    await asyncio.gather(writer)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

Scripts/RobloxWikiFilter.py

@@ -0,0 +1,111 @@
+# Purging roblox domain games base of word matching
+# - Shinon
+import multiprocessing
+import re
+from bs4 import BeautifulSoup
+import orjson
+import pathlib
+import typer
+from sqlitedict import SqliteDict
+
+cpl = re.compile(r"(roblox | roblox)", flags=re.IGNORECASE)
+
+app = typer.Typer()
+
+def filter_worker(
+    chunked_jsonl: pathlib.Path, out_file: pathlib.Path, index_file: pathlib.Path
+):
+    domains = set([i.strip() for i in index_file.read_text().split("\n") if i.strip()])
+    with open(chunked_jsonl, "rb") as f, open(out_file, "wb") as out_fp:
+        for line in f:
+            data = orjson.loads(line)
+            if data["domain"] in domains:
+                continue
+            out_fp.write(line)
+
+
+def roblox_worker(file: pathlib.Path, index_file: pathlib.Path, txt_file: pathlib.Path):
+    with SqliteDict(index_file) as fout:
+        with open(file, "rb") as f:
+            sync_time = 0
+            for line in f:
+                data = orjson.loads(line)
+                # dbg = f"domain: {data['domain']} title: {data['page']}"
+                if "parse" not in data["content"]:
+                    print(
+                        "Missing parse content",
+                        "domain",
+                        data["domain"],
+                        "title",
+                        data["page"],
+                    )
+                    continue
+                soup = data["content"]["parse"]["text"]["*"]
+                composed_soup = (
+                    re.sub(r"\n\s*\n", "\n\n", BeautifulSoup(soup, "lxml").get_text())
+                    .replace("\n", "")
+                    .strip()
+                )
+                robloxed = len(cpl.findall(composed_soup))
+                if data["domain"] not in fout:
+                    fout[data["domain"]] = 0
+                fout[data["domain"]] += robloxed
+                sync_time += 1
+                if sync_time % 10000 == 0 and sync_time != 0:
+                    fout.commit()
+            fout.commit()
+        with open(txt_file, "wb") as f:
+            for domain, roblox_count in fout.iteritems():
+                if roblox_count >= 2:
+                    print(domain)
+                    f.write(domain.encode() + b"\n")
+
+
+def err_cb(e):
+    print(e)
+
+@app.command()
+def index(folder:pathlib.Path,index_folder:pathlib.Path):
+    with multiprocessing.Pool(processes=64) as pool:
+        fn = []
+        for file in pathlib.Path(folder).iterdir():
+            fn.append(
+                pool.apply_async(
+                    roblox_worker,
+                    args=(
+                        pathlib.Path("v2.5-chunks") / f"{file.name}",
+                        index_folder / f"{file.stem}.sqlite",
+                        index_folder / f"{file.name}.domains.txt",
+                    ),
+                    error_callback=err_cb,
+                )
+            )
+        for task in fn:
+            task.wait()
+        pool.close()
+        pool.join()
+
+@app.command()
+def main(folder:pathlib.Path,output_folder:pathlib.Path,domains_txt:pathlib.Path):
+    with multiprocessing.Pool(processes=64) as pool:
+        fn = []
+        for file in folder.iterdir():
+            fn.append(
+                pool.apply_async(
+                    filter_worker,
+                    args=(
+                        file,
+                        output_folder / f"{file.name}.jsonl",
+                        domains_txt
+                    ),
+                    error_callback=err_cb,
+                )
+            )
+        for task in fn:
+            task.wait()
+        pool.close()
+        pool.join()
+
+app()
+
+# main()

Scripts/WikiPageFetcher.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# License: MIT
+# Copyright (C) 2024, Shinon.
+# Code inspiration from Ronsor Labs. Licensed as below.
+# License: AGPL 3.0
+# Copyright (C) 2023, 2024 Ronsor Labs.
+
+# Fetches pages and page content from a page list
+
+import asyncio
+import concurrent.futures as conc
+import pathlib
+import urllib.parse
+
+import aiofile
+import httpx
+import orjson
+
+from proxy_magic_session import get_async_session
+
+CONCURRENT_WORKERS = 128
+
+executor = conc.ProcessPoolExecutor(max_workers=64)
+
+pages_queue = asyncio.Queue(maxsize=1048576)
+output_queue = asyncio.Queue(maxsize=int(CONCURRENT_WORKERS*1.5))
+
+INPUT_JSONL = pathlib.Path("fandom_wikis_pages_210224_v2.jsonl")
+OUPUT_JSONL = pathlib.Path("fandom_wikis_pages_contents_210224_v2.jsonl")
+
+
+async def retry_url(url: str):
+    loop = asyncio.get_running_loop()
+    session: httpx.AsyncClient = get_async_session()
+    session.cookies.clear()
+    session.headers[
+        "user-agent"
+    ] = "Mozilla/6.2 (compatible; Microsoft Chrome 137.0; Apple Gecko 47.0 in AOL Firefox 37.6) Google Toolbar/1.3"
+    tries = 10
+    data = None
+    while True:
+        try:
+            data = await session.post(url, follow_redirects=True)
+            if data.status_code >= 300 and data.status_code < 500 and data.status_code != 403:
+                if data.status_code == 410:
+                    break
+                print(f"[W] RetryRequest | {url} {data.status_code}")
+                continue
+            try:
+                await loop.run_in_executor(executor, orjson.loads, data.content)
+            except Exception:
+                continue
+            break
+        except httpx.TransportError as e:
+            await session.aclose()
+            session: httpx.AsyncClient = get_async_session()
+            print(f"[W] Retry TransportError {url} {e}")
+            await asyncio.sleep(1)
+            tries -= 1
+        except httpx.HTTPError as e:
+            print(f"[W] Uncaught Exception Retry... {url} | {e}")
+            await session.aclose()
+            session: httpx.AsyncClient = get_async_session()
+            await asyncio.sleep(1)
+            tries -= 1
+        except Exception as e:
+            print(f"[W] Uncaught Exception {url} | {e}")
+            break
+        if tries <= 0:
+            print(f"[W] Tries Exceeded {url}")
+            break
+    await session.aclose()
+    if tries <= 0:
+        return
+    return data
+
+
+async def HTMLWorker():
+    loop = asyncio.get_running_loop()
+    while True:
+        data = await pages_queue.get()
+        if data is None:
+            break
+        domain, path, page = data
+        query_params = {
+            "action": "parse",
+            "format": "json",
+            "page": page,
+            "prop": "text|langlinks|categories|links|templates|images|externallinks|sections|revid|displaytitle|iwlinks|properties|parsewarnings|wikitext",
+        }
+        print(f"[I] HTMLW | {domain} {page} query.")
+        response = await retry_url(
+            f"https://{domain}{path}api.php?{urllib.parse.urlencode(query_params)}"
+        )
+        if response and response.status_code == 200:
+            print(f"[I] HTMLW | {domain} {page} dumped.")
+            await output_queue.put(
+                {
+                    "domain": domain,
+                    "path": path,
+                    "page": page,
+                    "content": await loop.run_in_executor(
+                        executor, orjson.loads, response.content
+                    ),
+                }
+            )
+
+
+async def jsonl_writer():
+    loop = asyncio.get_running_loop()
+    async with aiofile.async_open(OUPUT_JSONL, "wb") as f:
+        while True:
+            dict_data: dict = await output_queue.get()
+            if dict_data is None:
+                break
+            print(f"[I] Dump: {dict_data['domain']}{dict_data['path']}{dict_data['page']}")
+            bytes_data = await loop.run_in_executor(executor,orjson.dumps, dict_data)
+            await f.write(bytes_data)
+            await f.write(b"\n")
+
+
+async def main():
+    loop = asyncio.get_running_loop()
+    workers = [loop.create_task(HTMLWorker()) for _ in range(CONCURRENT_WORKERS)]
+    writer = loop.create_task(jsonl_writer())
+    with open(INPUT_JSONL, "rb") as f:
+        line = f.readline()
+        for line in f:
+            if line:
+                domain_data = orjson.loads(line)
+                page_count = len(domain_data["pages"])
+                if page_count <= 5:
+                    print(f"[I] Skip {domain_data['domain']} due to low page count.")
+                    continue
+                for page in domain_data["pages"]:
+                    await pages_queue.put(
+                        (domain_data["domain"], domain_data["path"][:-5], page)
+                    )
+        for _ in range(CONCURRENT_WORKERS):
+            await pages_queue.put(None)
+    while True:
+        done_workers = 0
+        for worker in workers:
+            if worker.done():
+                done_workers += 1
+        if done_workers != CONCURRENT_WORKERS:
+            print(f"\r{done_workers} / {CONCURRENT_WORKERS} are completed.")
+            await asyncio.sleep(60)
+        else:
+            break
+    # await asyncio.gather(*workers)
+    await output_queue.put(None)
+    print("Sent shutdown to Jsonl writer.")
+    await asyncio.gather(writer)
+
+if __name__ == "__main__":
+    asyncio.run(main())

Scripts/WikisIndexer.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# License: MIT
+# Copyright (C) 2024, Shinon.
+
+# Retrieves a full list of wikis to be scraped
+
+import asyncio
+import csv
+import urllib.parse
+
+from bs4 import BeautifulSoup
+
+from proxy_magic_session import get_async_session
+
+
+async def main():
+    with open("fandom_wikis_210224.csv", "w", newline="") as f:
+        writer = csv.writer(f)
+        session = get_async_session()
+        root = "https://community.fandom.com"
+        r = await session.get(f"{root}/wiki/Special:NewWikis?limit=500")
+        if r.status_code == 200:
+            nrow = 0
+            soup = BeautifulSoup(r.text, "lxml")
+            for doms in soup.select(".mw-spcontent li > a"):
+                href: str = doms.get("href", "")
+                if href:
+                    parsed = urllib.parse.urlparse(href)
+
+                    domain = parsed.netloc
+                    if parsed.path.strip("/"):
+                        sp = f"{parsed.path}wiki/"
+                    else:
+                        sp = "/wiki/"
+                    print("Add wiki:", domain, "|", doms.get_text().strip())
+                    writer.writerow([domain, doms.get_text().strip(), sp, 0])
+                    nrow += 1
+            next_page = soup.find("a", attrs={"rel": "next", "class": "mw-nextlink"})
+            if next_page:
+                next_page_url = f'{root}{next_page.get("href")}'
+            else:
+                next_page_url = None
+            while next_page_url:
+                nrow = 0
+                r = await session.get(next_page_url)
+                soup = BeautifulSoup(r.text, "lxml")
+                for doms in soup.select(".mw-spcontent li > a"):
+                    href: str = doms.get("href", "")
+                    if href:
+                        parsed = urllib.parse.urlparse(href)
+
+                        domain = parsed.netloc
+                        if parsed.path.strip("/"):
+                            sp = f"{parsed.path}wiki/"
+                        else:
+                            sp = "/wiki/"
+                        print("Add wiki:", domain, "|", doms.get_text().strip())
+                        writer.writerow([domain, doms.get_text().strip(), sp, 0])
+                        nrow += 1
+                next_page = soup.find(
+                    "a", attrs={"rel": "next", "class": "mw-nextlink"}
+                )
+                if next_page:
+                    next_page_url = f'{root}{next_page.get("href")}'
+                else:
+                    next_page_url = None
+                print(next_page_url)
+
+
+asyncio.run(main())

data/Fandom-v0.5.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0c66575d06311ea94497ff4f62651c7b99e918ec27bbb166d49f38590591837
+size 25083924695

v2.5-chunks-roblox-filter/fandom-aa.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f59bb9d312f6f7c649a6db84205b8ca104bdd1fd06868f7d2c1535caa6e0c36
+size 3076260389

v2.5-chunks-roblox-filter/fandom-ab.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9e3c4c10cb4e3df72d248e7c6362f76a401894d03c41a980f55ccde2e050ebf
+size 2988982948

v2.5-chunks-roblox-filter/fandom-ac.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d38deff269ca23cc85011b860b845505ada0ce20af7feaf197ed4772a7edee1c
+size 3253909135

v2.5-chunks-roblox-filter/fandom-ad.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5283fd799c4f160444983fc6f38ca570cac3107392530ca75e784b88aa5e8036
+size 3202289490

v2.5-chunks-roblox-filter/fandom-ae.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d839a51220ec84d10febb7b33f2b8776a54a5add2cecce53d1a5159da9d0dffa
+size 3175983811

v2.5-chunks-roblox-filter/fandom-af.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ab2cbc57c60a696e0430351df70f82d61121b1ccb2f09cd3ad2720dc85c7648
+size 3361323936

v2.5-chunks-roblox-filter/fandom-ag.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5c5ec05324dee4c3695e65956ad24f931c12fe24f1ab26d77c84151d101f73d
+size 3216472903

v2.5-chunks-roblox-filter/fandom-ah.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae213c10090278755cfead7debdfcc1b6f2c056b6fe90597cb75626679ea6468
+size 3532652692

v2.5-chunks-roblox-filter/fandom-ai.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd8922e5c041f990fe91ee32193dfb6ab7c092684dc102201be151e51e32d33c
+size 3665469694

v2.5-chunks-roblox-filter/fandom-aj.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d6e3e70c99d71be460fe3eab294e1bbcd988c0269bfd88d538ace89a75f9e9e
+size 3573593240

v2.5-chunks-roblox-filter/fandom-ak.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75de4684a965dd4e6dbdf4892ed1414320e4e5fa12cf4cf3686c1c15c3930368
+size 4066781175

v2.5-chunks-roblox-filter/fandom-al.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6690a5b3b620e92b48fd1269666a71e0b9606f3305c65a20e0768e3076d750e9
+size 3119261297

v2.5-chunks-roblox-filter/fandom-am.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c52ed6fb0e18cdbc01d32ca6891dba67dd4c912dd8f58265e4e1dde156bffea2
+size 3646904767

v2.5-chunks-roblox-filter/fandom-an.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8413fd13326b024486f594db083001c65bbecb65ca5661543ca320cf10446548
+size 4214395319

v2.5-chunks-roblox-filter/fandom-ao.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe8ae43585028bf611d697011b43ca1e7c2812d1144f51d93cbdd91eca06acc9
+size 3875038386

v2.5-chunks-roblox-filter/fandom-ap.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1db23c0ec3c9c2b251013e7ba331f0cdead73658b2c28a69e2e346001700cdf0
+size 4000054995

v2.5-chunks-roblox-filter/fandom-aq.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:432556b415988f770f9957e14f0097c8642aeb53485419dc1c8fb5c65e43b223
+size 3911995237

v2.5-chunks-roblox-filter/fandom-ar.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ef73dbeaf46796298e386b4dd5c0a08a4af09345b55bc552ba6dc130dba7789
+size 4495367225

v2.5-chunks-roblox-filter/fandom-as.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad67103c167002ff3a862a0038ff3be7f1133d80c68077ed467192ea5a483fdc
+size 3381623126

v2.5-chunks-roblox-filter/fandom-at.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f6b2abd7685f71a4f33c930e6e86300d4bcaedb4183e896b5b118db7980f0ea
+size 4068383946

v2.5-chunks-roblox-filter/fandom-au.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dab5a1747bddc6feb3c40b8969681788866e8843220c541a7819367d36acf31f
+size 3591797240

v2.5-chunks-roblox-filter/fandom-av.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a044338f26fcba9f380a2a19855882aac3be152b859aafdc5046c8c3559a04e
+size 3471398559

v2.5-chunks-roblox-filter/fandom-aw.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ca28c522d354023470e393339a050d77c92422bb427baef9a1371d795b1988b
+size 3738377264

v2.5-chunks-roblox-filter/fandom-ax.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4eeb7d77d6d91e5490448e5ff9bfa5e48eb71cbbfa140f8f29b71f41b860d667
+size 3892347988

v2.5-chunks-roblox-filter/fandom-ay.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3047dd355353ce1d8c0963c7059ad966cb946a84f5c4eeffb5b9f14438d894e5
+size 5369778357

v2.5-chunks-roblox-filter/fandom-az.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff65e7bb5b8622feaf3c7de73522097167ad1ae0a238c786d4d42b810f3b9eba
+size 5928051969

v2.5-chunks-roblox-filter/fandom-ba.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8626ab8ffa39b0ce96c5891093d78a9a25268edcab323d795258c65072cdcde0
+size 5197485894

v2.5-chunks-roblox-filter/fandom-bb.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f9b4b594cfbbcb66e4f9d0190369f396dd0f0856dff715e2bf5c40620220313
+size 3179725310

v2.5-chunks-roblox-filter/fandom-bc.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3bf5b3c63392cbd6903cd499892b15411ebba3ddfabbdc0309d3aa6dfc85a27
+size 3585388360

v2.5-chunks-roblox-filter/fandom-bd.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2563cdc8bce7893bfcd230d04a7d30b63e1aaeefac353dbd3fb349dcc7176a3
+size 3459115448

v2.5-chunks-roblox-filter/fandom-be.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f731690825e17d951ef9b06bf1e7ce4aa13ecbecb3c186a2598fb30d2b2ce56b
+size 3321816281

v2.5-chunks-roblox-filter/fandom-bf.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90219016838c5829e7f6590e13d059cd1205488d72d780c5e577792b3a971a5e
+size 2695687623

v2.5-chunks-roblox-filter/fandom-bg.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edc888422d39f3b0375a9ad1911330185c8ca26fd5d10e316d437376e08bd7fd
+size 3499549822

v2.5-chunks-roblox-filter/fandom-bh.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03ca99944602eae8234559903eb7a503d77bb0d7b0804aea0b199d6ed5b89e88
+size 3640070882

v2.5-chunks-roblox-filter/fandom-bi.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4539ba3eb4914fece398d4fbed2eb7e6c2556ff7135fed48d7ecbc7db007bff
+size 4729760443

v2.5-chunks-roblox-filter/fandom-bj.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30efa8318134f32f8dccf9a3bc1f27280d42f82ca84b64757a265dfc55b7946e
+size 3904301398

v2.5-chunks-roblox-filter/fandom-bk.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71cffbfd115c9a184b3114de259a3cfcc2374c5d3735490688901a2aaced6748
+size 3460240622

v2.5-chunks-roblox-filter/fandom-bl.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e79228cb7a83307e274d186d587d2235ac8c187e50cbae53167fafe737bb0d5
+size 3498847536

v2.5-chunks-roblox-filter/fandom-bm.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf8cada7d8b8a0b98f7de53a1c7c37b7ea0b9c4ce009856af5628eefb8a160cf
+size 3488156067

v2.5-chunks-roblox-filter/fandom-bn.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f78061817f14d4e8ecbf2cfa63bde739f0caadfff8299bb70a62c333db1a6b8
+size 3059357476

v2.5-chunks-roblox-filter/fandom-bo.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdfa5f2c3b82455af2933b820acb50b603781e661fb7f7a81e19dd92f9e8c179
+size 2420305940