Update files from the datasets library (from 1.9.0)

Release notes: https://github.com/huggingface/datasets/releases/tag/1.9.0

README.md

@@ -1,11 +1,38 @@
 ---
+pretty_name: C4
+annotations_creators:
+- no-annotation
+language_creators:
+- found
+languages:
+- en
+licenses:
+- odc-by-1-0
+multilinguality:
+- multilingual
+size_categories:
+  en:
+  - 100M<n<1B
+  en-noblocklist:
+  - 100M<n<1B
+  en-noclean:
+  - 1B<n<10B
+  realnewslike:
+  - 10M<n<100M
+source_datasets:
+- original
+task_categories:
+- sequence-modeling
+task_ids:
+- language-modeling
 paperswithcode_id: c4
 ---
 
 # Dataset Card for C4
 
 ## Table of Contents
-- [Dataset Card for [Dataset Name]](#dataset-card-for-dataset-name)
+
+- [Dataset Card for C4](#dataset-card-for-c4)
   - [Table of Contents](#table-of-contents)
   - [Dataset Description](#dataset-description)
     - [Dataset Summary](#dataset-summary)
@@ -36,38 +63,62 @@ paperswithcode_id: c4
 
 ## Dataset Description
 
-- **Homepage:**
-- **Repository:**
-- **Paper:**
-- **Leaderboard:**
-- **Point of Contact:**
+- **Homepage:** https://huggingface.co/datasets/allenai/c4
+- **Paper:** https://arxiv.org/abs/1910.10683
 
 ### Dataset Summary
 
-A colossal, cleaned version of Common Crawl's web crawl corpus. Based on Common Crawl dataset: "https://commoncrawl.org"
-Due to the overhead of cleaning the dataset, it is recommend you prepare it with a distributed service like Cloud Dataflow. More info at https://www.tensorflow.org/datasets/beam_datasets.
+A colossal, cleaned version of Common Crawl's web crawl corpus. Based on Common Crawl dataset: "https://commoncrawl.org".
+
+This is the version prepared by AllenAI, hosted at this address: https://huggingface.co/datasets/allenai/c4
+
+It comes in four variants:
+
+- `en`: 305GB in JSON format
+- `en.noblocklist`: 380GB in JSON format
+- `en.noclean`: 2.3TB in JSON format
+- `realnewslike`: 15GB in JSON format
+
+The `en.noblocklist` variant is exactly the same as the `en` variant, except we turned off the so-called "badwords filter", which removes all documents that contain words from the lists at https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words.
 
 ### Supported Tasks and Leaderboards
 
-[More Information Needed]
+C4 is mainly intended to pretrain language models and word representations.
 
 ### Languages
 
-[More Information Needed]
+The dataset is in English.
 
 ## Dataset Structure
 
 ### Data Instances
 
-[More Information Needed]
+An example form the `en` config is:
+
+```
+{
+  'url': 'https://klyq.com/beginners-bbq-class-taking-place-in-missoula/',
+  'text': 'Beginners BBQ Class Taking Place in Missoula!\nDo you want to get better at making delicious BBQ? You will have the opportunity, put this on your calendar now. Thursday, September 22nd join World Class BBQ Champion, Tony Balay from Lonestar Smoke Rangers. He will be teaching a beginner level class for everyone who wants to get better with their culinary skills.\nHe will teach you everything you need to know to compete in a KCBS BBQ competition, including techniques, recipes, timelines, meat selection and trimming, plus smoker and fire information.\nThe cost to be in the class is $35 per person, and for spectators it is free. Included in the cost will be either a t-shirt or apron and you will be tasting samples of each meat that is prepared.',
+  'timestamp': '2019-04-25T12:57:54Z'
+}
+```
 
 ### Data Fields
 
-[More Information Needed]
+The data have several fields:
+
+- `url`: url of the source as a string
+- `text`: text content as a string
+- `timestamp`: timestamp as a string
 
 ### Data Splits
 
-[More Information Needed]
+|      name      |  train  |validation|
+|----------------|--------:|---------:|
+| en             |364868892|    364608|
+| en.noblocklist |393391519|    393226|
+| en.noclean     |        ?|         ?|
+| realnewslike   | 13799838|     13863|
 
 ## Dataset Creation
 
@@ -79,7 +130,9 @@ Due to the overhead of cleaning the dataset, it is recommend you prepare it with
 
 #### Initial Data Collection and Normalization
 
-[More Information Needed]
+C4 dataset is a collection of about 750GB of English-language text sourced from the public Common Crawl web scrape. It includes heuristics to extract only natural language (as opposed to boilerplate and other gibberish) in addition to extensive deduplication. You can find the code that has been used to build this dataset in [c4.py](https://github.com/tensorflow/datasets/blob/5952d3d60d60e1727786fa7a9a23d24bb463d4d6/tensorflow_datasets/text/c4.py) by Tensorflow Datasets.
+
+The dataset was explicitly designed to be English only: any page that was not given a probability of at least 99% of being English by [langdetect](https://github.com/Mimino666/langdetect) was discarded.
 
 #### Who are the source language producers?
 
@@ -121,7 +174,7 @@ Due to the overhead of cleaning the dataset, it is recommend you prepare it with
 
 ### Licensing Information
 
-[More Information Needed]
+AllenAI are releasing this dataset under the terms of ODC-BY. By using this, you are also bound by the Common Crawl terms of use in respect of the content contained in the dataset.
 
 ### Citation Information
 
@@ -138,6 +191,4 @@ Due to the overhead of cleaning the dataset, it is recommend you prepare it with
 
 ### Contributions
 
-Thanks to [@github-username](https://github.com/<github-username>) for adding this dataset.
-
-Thanks to @thomwolf, @Narsil, @patrickvonplaten, @lhoestq, @lewtun for adding this dataset.
+Thanks to [@dirkgr](https://github.com/dirkgr) and [@lhoestq](https://github.com/lhoestq) for adding this dataset.

c4.py

@@ -1,41 +1,11 @@
-# coding=utf-8
-# Copyright 2020 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Lint as: python3
 """C4 dataset based on Common Crawl."""
 
 
+import gzip
 import json
-import os
 
 import datasets
 
-from .c4_utils import (
-    dedupe_urls,
-    filter_by_webtextlike,
-    get_clean_page_fn,
-    get_counter_inc_fn,
-    get_hashed_url_filter_fn,
-    is_language,
-    is_realnews_domain,
-    is_valid_length,
-    normalize_url,
-    remove_duplicate_text,
-    split_wet_file,
-)
-
 
 logger = datasets.logging.get_logger(__name__)
 
@@ -43,12 +13,11 @@ logger = datasets.logging.get_logger(__name__)
 _DESCRIPTION = """\
 A colossal, cleaned version of Common Crawl's web crawl corpus.
 
-Based on Common Crawl dataset: "https://commoncrawl.org"
+Based on Common Crawl dataset: "https://commoncrawl.org".
 
-Due to the overhead of cleaning the dataset, it is recommend you prepare it with
-a distributed service like Cloud Dataflow. More info at
-https://www.tensorflow.org/datasets/beam_datasets.
+This is the processed version of Google's C4 dataset by AllenAI.
 """
+
 _CITATION = """
 @article{2019t5,
     author = {Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu},
@@ -59,275 +28,66 @@ _CITATION = """
     eprint = {1910.10683},
 }
 """
-_VERSION = datasets.Version("2.3.0", "Deduplicate lines within a page.")
-
-_DOWNLOAD_HOST = "https://commoncrawl.s3.amazonaws.com"
-_WET_PATH_URL = "https://commoncrawl.s3.amazonaws.com/crawl-data/CC-MAIN-{cc_version}/wet.paths.gz"
-_REALNEWS_DOMAINS_URL = "https://raw.githubusercontent.com/rowanz/grover/38f7184bd87237ae2d3bc330b99f1e2e246f6d51/realnews/domain_to_allowed_subdomains.json"
-_BADWORDS_URL = "https://raw.githubusercontent.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words/25e679f03d96baa721cde20db9944649e8d0a844/{lang}"
-_CHECKSUMS_URL = "https://storage.googleapis.com/tfds-data/manual_checksums/c4.txt"
-_OPENWEBTEXT_URLS_ZIP = "OpenWebText.zip"
-_OPENWEBTEXT_URLS_URL = "https://mega.nz/#F!EZZD0YwJ!9_PlEQzdMVLaNdKv_ICNVQ"
-_OPENWEBTEXT_URLS_FILE_PATTERN = "OpenWebText/Version 1/URLs/*.txt"
-
-_DEFAULT_CC_VERSIONS = ("2019-18",)  # April 2019
-_DEFAULT_WEBTEXTLIKE_CC_VERSIONS = (  # August 2018 - July 2019
-    "2018-34",
-    "2018-39",
-    "2018-43",
-    "2018-47",
-    "2018-51",
-    "2019-04",
-    "2019-09",
-    "2019-13",
-    "2019-18",
-    "2019-22",
-    "2019-26",
-    "2019-30",
-)
 
+_URL = "https://github.com/allenai/allennlp/discussions/5056"
 
-class C4Config(datasets.BuilderConfig):
-    """BuilderConfig for C4 dataset."""
+_VARIANTS = ["en", "realnewslike", "en.noblocklist", "en.noclean"]
 
-    def __init__(self, language, cc_versions=None, clean=True, realnewslike=False, webtextlike=False, **kwargs):
-        """BuilderConfig for C4.
-
-        Args:
-            language: string, the language code, or "all" to disable language
-                filtering.
-            cc_versions: tuple(string), a collection of versions of Common Crawl to
-                use as the raw source text. Set to None to use defaults.
-            clean: bool, whether to clean the dataset for badwords, duplications, etc.
-            realnewslike: bool, whether to limit to news domains as compiled by
-                RealNews.
-            webtextlike: bool, whether to limit to WebText-like URLs.
-            **kwargs: keyword arguments forwarded to super.
-        """
-        name_parts = [language]
-        if cc_versions:
-            name_parts.append("_".join(cc_versions))
-        if not clean:
-            name_parts.append("noclean")
-        if realnewslike:
-            name_parts.append("realnewslike")
-        if webtextlike:
-            name_parts.append("webtextlike")
-        name = ".".join(name_parts)
-        super(C4Config, self).__init__(name=name, version=_VERSION, **kwargs)
-        self.lang = language
-        self.cc_versions = cc_versions or (_DEFAULT_WEBTEXTLIKE_CC_VERSIONS if webtextlike else _DEFAULT_CC_VERSIONS)
-        self.clean = clean
-        self.realnewslike = realnewslike
-        self.webtextlike = webtextlike
+_N_SHARDS_PER_SPLIT = {
+    "en": {"train": 1024, "validation": 8},
+    "realnewslike": {"train": 512, "validation": 1},
+    "en.noblocklist": {"train": 1024, "validation": 8},
+    "en.noclean": {"train": 7168, "validation": 64},
+}
 
+_DATA_URL = "https://huggingface.co/datasets/allenai/c4/resolve/1ddc917116b730e1859edef32896ec5c16be51d0/{name}/c4-{split}.{index:05d}-of-{n_shards:05d}.json.gz"
 
-class C4(datasets.BeamBasedBuilder):
-    """C4 dataset based on Common Crawl."""
 
-    BUILDER_CONFIGS = [
-        C4Config(language="en", description="English C4 dataset."),
-        C4Config(
-            language="en",
-            clean=False,
-            description="Disables all cleaning (deduplication, removal based on bad words, " "etc.)",
-        ),
-        C4Config(
-            language="en",
-            realnewslike=True,
-            description="Filters from the default config to only include content from the "
-            "domains used in the 'RealNews' dataset (Zellers et al., 2019).",
-        ),
-        C4Config(
-            language="en",
-            webtextlike=True,
-            description="Filters from the default config to only include content from the "
-            "URLs in OpenWebText (https://github.com/jcpeterson/openwebtext).",
-        ),
-    ]
+class C4(datasets.GeneratorBasedBuilder):
+    """C4, a colossal, cleaned version of Common Crawl's web crawl corpus."""
 
-    @property
-    def manual_download_instructions(self):
-        return """\
-    For the WebText-like config, you must manually download 'OpenWebText.zip'
-    (from https://mega.nz/#F!EZZD0YwJ!9_PlEQzdMVLaNdKv_ICNVQ) and the Common Crawl
-    WET files from August 2018 to July 2019
-    (https://commoncrawl.org/the-data/get-started/) and place them in the
-    `data_dir`.
-        """
+    BUILDER_CONFIGS = [datasets.BuilderConfig(name) for name in _VARIANTS]
 
     def _info(self):
-        features = {
-            "text": datasets.Value("string"),
-            "url": datasets.Value("string"),
-            "content-type": datasets.Value("string"),
-            "content-length": datasets.Value("string"),
-            "timestamp": datasets.Value("string"),
-        }
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
-            features=datasets.Features(features),
+            features=datasets.Features(
+                {
+                    "text": datasets.Value("string"),
+                    "timestamp": datasets.Value("string"),
+                    "url": datasets.Value("string"),
+                }
+            ),
+            supervised_keys=None,
+            homepage=_URL,
             citation=_CITATION,
-            homepage="https://github.com/google-research/text-to-text-transfer-transformer#datasets",
         )
 
-    def _split_generators(self, dl_manager, pipeline):
-        import apache_beam as beam
-
-        # We will automatically down the default CC version(s), but others need to
-        # be manually downloaded.
-        cc_versions = set(self.config.cc_versions)
-        auto_cc_versions = cc_versions & set(_DEFAULT_CC_VERSIONS)
-        manual_cc_versions = cc_versions - set(_DEFAULT_CC_VERSIONS)
-
-        files_to_download = {}
-        files_to_download["wet_path_urls"] = [
-            _WET_PATH_URL.format(cc_version=cc_version) for cc_version in auto_cc_versions
-        ]
-        if self.config.clean:
-            files_to_download["badwords"] = _BADWORDS_URL.format(lang=self.config.lang)
-        if self.config.realnewslike:
-            files_to_download["realnews_domains"] = _REALNEWS_DOMAINS_URL
-        file_paths = dl_manager.download_and_extract(files_to_download)
-
-        if self.config.webtextlike:
-            owt_path = os.path.join(dl_manager.manual_dir, _OPENWEBTEXT_URLS_ZIP)
-            if not os.path.exists(owt_path):
-                raise FileNotFoundError(
-                    "{} does not exist. Make sure you insert a manual dir via `datasets.load_dataset('c4', data_dir=...)` that includes a file name {}. Manual download instructions: {})".format(
-                        owt_path, _OPENWEBTEXT_URLS_ZIP, self.manual_download_instructions
-                    )
-                )
-            file_paths["openwebtext_urls_zip"] = dl_manager.extract(owt_path)
-
-        wet_urls = []
-        for wet_path_url in file_paths["wet_path_urls"]:
-            with open(wet_path_url, "r", encoding="utf-8") as f:
-                wet_urls.extend(["%s/%s" % (_DOWNLOAD_HOST, line.strip()) for line in f])
-        file_paths["wet_urls"] = wet_urls
-        file_paths["wet_files"] = []
-
-        for cc_version in manual_cc_versions:
-            cc_dir = os.path.join(dl_manager.manual_dir, cc_version)
-            wet_files = beam.io.filesystems.FileSystems.match(os.path.join(cc_dir, "*.warc.wet.gz"))
-            if not os.path.exists(cc_dir):
-                raise FileNotFoundError(
-                    "{} does not exist. Make sure you insert a manual dir via `datasets.load_dataset('c4', data_dir=...)` that includes the files {}. Manual download instructions: {})".format(
-                        cc_dir, "*.warc.wet.gz", self.manual_download_instructions
-                    )
-                )
-            logger.info("Adding %d WET files for manually downloaded version %s.", len(wet_files), cc_version)
-            file_paths["wet_files"].extend(wet_files)
-
-        page_content_pcollection = self._get_page_content(pipeline, file_paths, dl_manager)
+    def _split_generators(self, dl_manager):
+        data_urls = {}
+        for split in ["train", "validation"]:
+            n_shards = _N_SHARDS_PER_SPLIT[self.config.name][split]
+            data_urls[split] = [
+                _DATA_URL.format(name=self.config.name, split=split, index=index, n_shards=n_shards)
+                for index in range(n_shards)
+            ]
+        train_downloaded_files = dl_manager.download(data_urls["train"])
+        validation_downloaded_files = dl_manager.download(data_urls["validation"])
         return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepaths": train_downloaded_files}),
             datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs=dict(
-                    split="train",
-                    page_content=page_content_pcollection,
-                    hashed_url_predicate=lambda x: x % 1000 != 0,  # 99.9%
-                ),
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs=dict(
-                    split="validation",
-                    page_content=page_content_pcollection,
-                    hashed_url_predicate=lambda x: x % 1000 == 0,  # 0.01%
-                ),
+                name=datasets.Split.VALIDATION, gen_kwargs={"filepaths": validation_downloaded_files}
             ),
         ]
 
-    def _get_page_content(self, pipeline, file_paths, dl_manager):
-        """Build PCollection of un-split page content."""
-        import apache_beam as beam
-
-        wet_file_paths = pipeline | "create_wet_files" >> beam.Create(file_paths["wet_files"])
-        if "wet_urls" in file_paths:
-
-            def download_url(url, downloader, pipeline):
-                path = downloader.download(url)
-                if not pipeline.is_local():
-                    path = downloader.ship_files_with_pipeline(path, pipeline)
-                return path
-
-            dl_wet_file_paths = (
-                pipeline
-                | "create_wet_urls" >> beam.Create(file_paths["wet_urls"])
-                | beam.Map(download_url, downloader=dl_manager, pipeline=pipeline)
-            )
-            wet_file_paths = (wet_file_paths, dl_wet_file_paths) | beam.Flatten()
-
-        # Parse WET files and filter by length.
-        # Output: url, text
-        page_content = wet_file_paths | beam.FlatMap(split_wet_file) | beam.Filter(is_valid_length)
-
-        # Optionally filter for RealNews domains.
-        # Output: url, text
-        if self.config.realnewslike:
-            with open(file_paths["realnews_domains"], "r", encoding="utf-8") as f:
-                realnews_domains = json.load(f)
-            page_content = page_content | beam.Filter(is_realnews_domain, realnews_domains)
-
-        # Normalize and deduplicate by URL.
-        # Output: url, text
-        page_content = (
-            page_content
-            | "normalize_url" >> beam.Map(normalize_url)
-            | "group_url" >> beam.GroupByKey()
-            | beam.Map(dedupe_urls)
-        )
-
-        # Optionally filter for WebText-like URLs.
-        # Output: url, text
-        if self.config.webtextlike:
-            webtextlike_urls = (
-                pipeline
-                | "read_webtextlike_urls"
-                >> beam.io.ReadFromText(
-                    os.path.join(file_paths["openwebtext_urls_zip"], _OPENWEBTEXT_URLS_FILE_PATTERN)
-                )
-                | "add_dummy_page" >> beam.Map(lambda x: (x, ""))
-                | "normal_webtext_url" >> beam.Map(normalize_url)
-            )
-            page_content = (
-                {"text": page_content, "webtextlike_urls": webtextlike_urls}
-                | "group_webtextlike_urls" >> beam.CoGroupByKey()
-                | beam.FlatMap(filter_by_webtextlike)
-            )
-
-        # Optionally clean pages of badwords, boilerpolate text, and duplicate
-        # spans of sentences.
-        # Output: url, text
-        if self.config.clean:
-            with open(file_paths["badwords"], "r", encoding="utf-8") as f:
-                badwords = [line.strip() for line in f]
-            page_content = page_content | "clean_pages" >> beam.FlatMap(get_clean_page_fn(badwords))
-            page_content = remove_duplicate_text(page_content)
-
-        # Optionally filter out non-`language` pages. We do this after cleaning
-        # since it may change the predominate language.
-        if self.config.lang != "all":
-            page_content |= beam.Filter(is_language, language=self.config.lang)
-
-        return page_content
-
-    def _build_pcollection(self, unused_pipeline, split, page_content, hashed_url_predicate):
-        import apache_beam as beam
-
-        def _emit_examples(el):
-            get_counter_inc_fn(split)("examples")
-            _, features = el
-            return (
-                features["url"],
-                {
-                    "url": features["url"],
-                    "text": features["text"],
-                    "content-type": features["content-type"],
-                    "content-length": features["content-length"],
-                    "timestamp": features["timestamp"],
-                },
-            )
-
-        return page_content | beam.Filter(get_hashed_url_filter_fn(hashed_url_predicate)) | beam.Map(_emit_examples)
+    def _generate_examples(self, filepaths):
+        """This function returns the examples in the raw (text) form by iterating on all the files."""
+        id_ = 0
+        for filepath in filepaths:
+            logger.info("generating examples from = %s", filepath)
+            with gzip.open(open(filepath, "rb"), "rt", encoding="utf-8") as f:
+                for line in f:
+                    if line:
+                        example = json.loads(line)
+                        yield id_, example
+                        id_ += 1

c4_utils.py

@@ -1,488 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Lint as: python3
-"""Utilities for generating the C4 dataset."""
-
-
-import functools
-import gzip
-import hashlib
-import io
-import re
-import threading
-
-
-# WET file constants
-_PAGE_DELIMITER = "WARC/1.0"
-_URL_KEY = "WARC-Target-URI:"
-_URL_DATE = "WARC-Date:"
-_CONTENT_TYPE = "Content-Type:"
-_CONTENT_LEN = "Content-Length:"
-_METADATA_PREFIXES = ("WARC", "CONTENT-", "Content-")
-
-# Filters
-_MIN_WORDS_PER_LINE = 5
-_MIN_NUM_SENTENCES = 3
-_MAX_WORD_LENGTH = 1000
-_END_MARKS = (".", "?", "!", '"')
-_ELLIPSIS = "..."
-_POLICY_SUBSTRINGS = [
-    "terms of use",
-    "privacy policy",
-    "cookie policy",
-    "uses cookies",
-    "use of cookies",
-    "use cookies",
-]
-
-# Memoized sentence tokenizer.
-_SENTENCE_TOKENIZER = None
-
-
-def get_counter_inc_fn(namespace):
-    import apache_beam as beam
-
-    def counter_inc_fn(counter, amt=1):
-        beam.metrics.Metrics.counter(namespace, counter).inc(amt)
-
-    return counter_inc_fn
-
-
-def get_hashed_url_filter_fn(predicate_fn):
-    import tensorflow.compat.v2 as tf
-
-    def filter_fn(el):
-        url, _ = el
-        val = int(hashlib.md5(tf.compat.as_text(url).encode("utf-8")).hexdigest(), 16)
-        return predicate_fn(val)
-
-    return filter_fn
-
-
-def _load_sentence_tokenizer():
-    """Returns a sentence tokenization function."""
-    # Lock to avoid a race-condition in the creation of the download directory.
-    with threading.Lock():
-        import nltk
-
-        nltk.download("punkt")
-        return nltk.data.load("nltk:tokenizers/punkt/english.pickle")
-
-
-def _get_sentences(text):
-    import tensorflow.compat.v2 as tf
-
-    global _SENTENCE_TOKENIZER
-    if not _SENTENCE_TOKENIZER:
-        _SENTENCE_TOKENIZER = _load_sentence_tokenizer()
-    return list(_SENTENCE_TOKENIZER.tokenize(tf.compat.as_text(text)))
-
-
-def _get_sentences_by_line(text, lower=False):
-    sentences = []
-    for line in text.splitlines():
-        sentences.append([s.lower() if lower else s for s in _get_sentences(line)])
-    return sentences
-
-
-def is_language(page, language, min_probability=0.99):
-    """Returns True iff text is in `language` with at least `min_probability`."""
-    unused_url, features = page
-    text = features["text"]
-
-    counter_inc_fn = get_counter_inc_fn("detected-lang")
-
-    # Make langdetect predictions deterministic.
-    import langdetect
-
-    langdetect.DetectorFactory.seed = 0
-    try:
-        predictions = langdetect.detect_langs(text)
-    except langdetect.lang_detect_exception.LangDetectException:
-        counter_inc_fn("langdetect-exception")
-        return False
-    if not predictions:
-        counter_inc_fn("page-filtered-nolangpredictions")
-        return False
-    best_prediction = predictions[0]
-    if best_prediction.prob < min_probability:
-        counter_inc_fn("page-filtered-lowlangdetectconf")
-        return False
-    if best_prediction.lang != language:
-        counter_inc_fn("page-filtered-ignoredlang")
-        counter_inc_fn("page-filtered-ignoredlang-%s" % (best_prediction.lang))
-        return False
-    counter_inc_fn("page-emited-%s" % best_prediction.lang)
-    return True
-
-
-def get_clean_page_fn(badwords=None):
-    """Returns `clean_page` with pre-compiled badword and citation regexes."""
-    # Used to filter citation from Wikipedia pages (among others).
-    citation_regex = re.compile(r"\[\d*\]|\[edit\]|\[citation needed\]")
-    if badwords:
-        badwords_regex = re.compile("[^a-z]({})[^a-z]".format("|".join(badwords or [])))
-    else:
-        badwords_regex = None
-    return functools.partial(clean_page, citation_regex=citation_regex, badwords_regex=badwords_regex)
-
-
-def clean_page(
-    url_and_features,
-    citation_regex,
-    badwords_regex=None,
-    counter_inc_fn=None,
-    min_words_per_line=_MIN_WORDS_PER_LINE,
-    min_num_sentences=_MIN_NUM_SENTENCES,
-    max_word_length=_MAX_WORD_LENGTH,
-):
-    """Cleans a CommonCrawl page, yielding nothing if it should be skipped.
-
-    Cleaning removes lines with no end marks or with too few words. After line
-    filtering, pages are filtered out if they have too few sentences based on a
-    simple count of end marks.
-
-    Args:
-        url_and_features: tuple(string, dict), the url and features of the page.
-        citation_regex: Regex to use for finding Wikipedia-like citations to filter.
-        badwords_regex: Regex to use for finding badwords. Default None, which means
-            don't apply badwords filtering.
-        counter_inc_fn: function, a function taking the name of a counter to be
-            incremented and the (optional) amount. Defaults to a beam Metric counter.
-        min_words_per_line: int, the minimum number of words a line needs to not be
-            removed.
-        min_num_sentences: int, the minimum number of sentences a page needs to not
-            be skipped.
-        max_word_length: int, the maximum number of characters allowed in a word.
-            Lines containing a word with too many characters are removed.
-    Yields:
-        The url and cleaned text for the page.
-    """
-    url, features = url_and_features
-    text = features["text"]
-
-    if not counter_inc_fn:
-        counter_inc_fn = get_counter_inc_fn("clean-page")
-
-    lines = text.splitlines()
-    valid_lines = []
-    num_sentences = 0
-
-    def line_has_too_long_word(line):
-        for word in line.split():
-            if len(word) > max_word_length:
-                return True
-        return False
-
-    for line in lines:
-        line = line.strip()
-        if line_has_too_long_word(line):
-            counter_inc_fn("lines-with-too-long-word")
-            continue
-        line = citation_regex.sub("", line)
-        if not line.endswith(_END_MARKS) or line.endswith(_ELLIPSIS):
-            counter_inc_fn("lines-no-endmark")
-            continue
-        if len(line.split()) < min_words_per_line:
-            counter_inc_fn("lines-too-short")
-            continue
-        line_lower = line.lower()
-        # Remove documents which contain lorem ipsum
-        if "lorem ipsum" in line_lower:
-            counter_inc_fn("filtered-page-loremipsum")
-            return
-        # Remove "javascript must be enabled" notices
-        if "javascript" in line_lower:
-            counter_inc_fn("lines-javascript")
-            continue
-        # Remove docs which probably contain javascript code
-        if "{" in line:
-            counter_inc_fn("filtered-page-squigglybracket")
-            return
-        # Remove policy lines
-        if any(p in line_lower for p in _POLICY_SUBSTRINGS):
-            counter_inc_fn("lines-policy")
-            continue
-        # If any badword appears on its own in the line, skip this doc
-        if badwords_regex:
-            badwords_found = badwords_regex.search(line_lower)
-            if badwords_found is not None:
-                counter_inc_fn("filtered-page-badword")
-                return
-        num_sentences += len(_get_sentences(line))
-        valid_lines.append(line)
-        counter_inc_fn("lines-valid")
-
-    if num_sentences < min_num_sentences:
-        counter_inc_fn("filtered-page-toofewsentences")
-        return
-    counter_inc_fn("emitted-clean-pages")
-    features["text"] = "\n".join(valid_lines).strip()
-    yield url, features
-
-
-def _hash_line(line):
-    import tensorflow.compat.v2 as tf
-
-    m = hashlib.md5()
-    m.update(tf.compat.as_text(line).encode("utf-8").strip().lower())
-    return m.hexdigest()
-
-
-def _emit_url_to_lines(page):
-    """Emits url to all (lower-cased, hashed) lines."""
-    url, features = page
-    text = features["text"]
-    for line in text.split("\n"):
-        yield _hash_line(line), url
-
-
-def _emit_line_to_urls(el, counter_inc_fn):
-    """Emits (hashed) line to all but one url."""
-    import tensorflow.compat.v2 as tf
-
-    line, urls = el
-    # Materialize urls as a list.
-    urls = list(urls)
-    # Hash urls and sort to have a consistent, but unbiased, selection when the
-    # same urls exist for multiple lines.
-    skip_url = min(urls, key=lambda x: hashlib.md5(tf.compat.as_text(x).encode("utf-8")).hexdigest())
-    for url in urls:
-        if url != skip_url:
-            yield url, line
-    counter_inc_fn("emitted-line-duplicate", amt=len(urls) - 1)
-
-
-def _remove_lines_from_text(el, counter_inc_fn, min_num_sentences=_MIN_NUM_SENTENCES):
-    """Removes matching lines from the page.
-
-    Process the result of a join containing a single value for 'features' and zero
-    or more values for 'lines'. Each value in 'lines' is a lower-cased, hashed
-    line.
-
-    If a line has fewer sentences than `max_window_size`, the full line is
-    compared for a match.
-
-    Args:
-        el: `(string, {'features': features_dict, 'lines': [string]})`,
-            element containing the result of a join on key with both the page text
-            and lower-cased, hashed lines to remove.
-        counter_inc_fn: function, a function taking the name of a counter to be
-            incremented and the (optional) amount.
-        min_num_sentences: int, the minimum number of sentences a page needs to not
-            be skipped.
-
-    Yields:
-        url: The URL of the page.
-        features: The page features with lines removed from text.
-    """
-    url, join_values = el
-    features = join_values["features"]
-
-    assert len(features) == 1, "Invalid page count (%d) for %s" % (len(features), url)
-    features = features[0]
-    text = features["text"]
-    lines_to_remove = set(join_values["lines"])
-    new_lines = []
-    hashed_lines = set()
-    for line in text.split("\n"):
-        hashed_line = _hash_line(line)
-        if hashed_line in lines_to_remove:
-            counter_inc_fn("filtered-lines-duplicate")
-        elif hashed_line not in hashed_lines:
-            new_lines.append(line)
-            hashed_lines.add(hashed_line)
-    new_text = "\n".join(new_lines)
-    if len(_get_sentences(new_text)) < min_num_sentences:
-        counter_inc_fn("filtered-doc-toofewsentences")
-        return
-    new_features = features.copy()
-    new_features["text"] = new_text
-    yield (url, new_features)
-
-
-def remove_duplicate_text(pages):
-    """Utility to remove duplicate lines across text documents."""
-    # Output: url, lines
-    import apache_beam as beam
-
-    counter_inc_fn = get_counter_inc_fn("dedupe-lines")
-    lines_to_remove = (
-        pages
-        | beam.FlatMap(_emit_url_to_lines)
-        | "group_sentences" >> beam.GroupByKey()
-        | beam.FlatMap(_emit_line_to_urls, counter_inc_fn=counter_inc_fn)
-    )
-
-    # Output: url, text
-    final_docs = (
-        {"features": pages, "lines": lines_to_remove}
-        | "group_features_and_lines_by_url" >> beam.CoGroupByKey()
-        | beam.FlatMap(_remove_lines_from_text, counter_inc_fn=counter_inc_fn)
-    )
-
-    return final_docs
-
-
-def split_wet_file(wet_file_path, counter_inc_fn=None):
-    """Split a WET file into separate pages."""
-    from absl import logging
-
-    logging.info("Splitting file: %s", wet_file_path)
-    if not counter_inc_fn:
-        counter_inc_fn = get_counter_inc_fn("split-wet-file")
-    counter_inc_fn("wet-file")
-
-    import apache_beam as beam
-
-    with beam.io.filesystems.FileSystems.open(wet_file_path) as f, gzip.GzipFile(fileobj=f) as g:
-        url = None
-        content = None
-        content_len = None
-        content_type = None
-        timestamp = None
-
-        def _maybe_get_page():
-            """Generate a (url, {features}) page."""
-            if not url and url is not None:
-                counter_inc_fn("page-filtered-nourl")
-            if not content and content is not None:
-                counter_inc_fn("page-filtered-nocontent")
-            if not content_type and content_type is not None:
-                counter_inc_fn("page-nocontenttype")
-            if not content_len and content_len is not None:
-                counter_inc_fn("page-nocontentlen")
-            if not timestamp and timestamp is not None:
-                counter_inc_fn("page-notimestamp")
-            if content and url:
-                counter_inc_fn("page-emitted")
-                return (
-                    url,
-                    {
-                        "text": "\n".join(content),
-                        "content-type": content_type,
-                        "content-length": content_len,
-                        "timestamp": timestamp,
-                        "url": url,
-                    },
-                )
-            return None
-
-        for line in io.TextIOWrapper(g, encoding="utf-8"):
-            line = line.strip()
-            if not line:
-                continue
-            if line == _PAGE_DELIMITER:
-                page = _maybe_get_page()
-                if page:
-                    yield page
-                url = ""
-                content = []
-                content_len = ""
-                content_type = ""
-                timestamp = ""
-
-            if line.startswith(_URL_KEY):
-                url = line[len(_URL_KEY) :].strip()
-
-            if line.startswith(_URL_DATE):
-                timestamp = line[len(_URL_DATE) :].strip()
-
-            if line.startswith(_CONTENT_TYPE):
-                content_type = line[len(_CONTENT_TYPE) :].strip()
-
-            if line.startswith(_CONTENT_LEN):
-                content_len = line[len(_CONTENT_LEN) :].strip()
-
-            if line.startswith(_METADATA_PREFIXES):
-                continue
-
-            content.append(line)
-
-        page = _maybe_get_page()
-        if page:
-            yield page
-
-
-def dedupe_urls(el):
-    """Returns the first value for a given URL."""
-    counter_inc_fn = get_counter_inc_fn("dedupe-urls")
-    url, vals = el
-    cnt = 0
-    v = None
-    for v in vals:
-        cnt += 1
-    counter_inc_fn("filtered-url-duplicate", cnt - 1)
-    counter_inc_fn("unique-url")
-    return url, v
-
-
-def is_valid_length(el, max_length=1.9e5):
-    """Returns False iff page's text is too long."""
-    counter_inc_fn = get_counter_inc_fn("is-valid-length")
-    _, page = el
-    if len(page["text"]) > max_length:
-        counter_inc_fn("filtered-page-contenttoolong")
-        return False
-    counter_inc_fn("valid-length")
-    return True
-
-
-def is_realnews_domain(el, realnews_domains):
-    """Returns False iff page's (sub)domain is not allowed."""
-    import tldextract
-
-    counter_inc_fn = get_counter_inc_fn("is-realnews-domain")
-    url, _ = el
-    ext = tldextract.extract(url)
-    main_domain = ext.domain + "." + ext.suffix
-    if main_domain not in realnews_domains:
-        counter_inc_fn("filtered-url-invaliddomain")
-        return False
-    allowed_subdomains = realnews_domains[main_domain]
-    if isinstance(allowed_subdomains, list) and ext.subdomain not in allowed_subdomains:
-        counter_inc_fn("filtered-url-invalidsubdomain")
-        return False
-    counter_inc_fn("realnews-domain")
-    return True
-
-
-def filter_by_webtextlike(el):
-    """Yields only pages with a matching WebText-like URL."""
-    counter_inc_fn = get_counter_inc_fn("filter-by-webtextlike")
-    url, join_values = el
-    text = join_values["text"]
-    webtextlike = join_values["webtextlike_urls"]
-    if not webtextlike:
-        counter_inc_fn("filtered-url-notwebtextlike")
-        return
-    if not text:
-        counter_inc_fn("missing-webtextlike")
-        return
-    assert len(text) == 1
-    counter_inc_fn("found-webtextlike")
-    yield url, text[0]
-
-
-def normalize_url(el):
-    import tensorflow.compat.v2 as tf
-
-    url, val = el
-    url = tf.compat.as_text(url)
-    url = re.sub(r"https?:\/\/(www\.)?", "", url)
-    url = re.sub(r"\?(utm_|ref|feed).*", "", url)
-    url = url.rstrip("/")
-    return url, val

dummy/en.noblocklist/0.0.0/dummy_data.zip

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

dummy/en.noclean/0.0.0/dummy_data.zip

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

dummy/en/0.0.0/dummy_data.zip

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

dummy/realnewslike/0.0.0/dummy_data.zip

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