Update files from the datasets library (from 1.0.0)

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

.gitattributes

@@ -0,0 +1,27 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 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
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack 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
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* 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
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

c4.py

@@ -0,0 +1,331 @@
+# 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."""
+
+from __future__ import absolute_import, division, print_function
+
+import json
+import logging
+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,
+)
+
+
+_DESCRIPTION = """\
+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.
+"""
+_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},
+    title = {Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer},
+    journal = {arXiv e-prints},
+    year = {2019},
+    archivePrefix = {arXiv},
+    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",
+)
+
+
+class C4Config(datasets.BuilderConfig):
+    """BuilderConfig for C4 dataset."""
+
+    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
+
+
+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).",
+        ),
+    ]
+
+    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`.
+        """
+
+    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),
+            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, l.strip()) for l 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
+                    )
+                )
+            logging.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)
+        return [
+            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%
+                ),
+            ),
+        ]
+
+    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 = [l.strip() for l 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)

c4_utils.py

@@ -0,0 +1,489 @@
+# 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."""
+
+from __future__ import absolute_import, division, print_function
+
+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