Add files using upload-large-folder tool

cc-multilingual-main/cc_net/build/lib/cc_net/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#

cc-multilingual-main/cc_net/build/lib/cc_net/__main__.py

@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+
+import func_argparse
+
+import cc_net.mine
+
+
+def main():
+    func_argparse.parse_and_call(cc_net.mine.get_main_parser())
+
+
+if __name__ == "__main__":
+    main()

cc-multilingual-main/cc_net/build/lib/cc_net/dedup.py

@@ -0,0 +1,478 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Tools to remove duplicate paragraphs across one or several shards.
+"""
+
+import argparse
+import gc
+import hashlib
+import logging
+import multiprocessing
+import os
+import tempfile
+import time
+from pathlib import Path
+from typing import Iterable, List, Optional, Set, Union
+
+import numpy as np
+
+from cc_net import jsonql
+from cc_net.flat_hash_set import HASH_TYPE, AbstractDedupHashSet, FlatHashSet
+from cc_net.jsonql import mem_footprint_gb
+from cc_net.text_normalizer import normalize_for_dedup
+
+BYTE_ORDER = "little"
+HASH_SIZE = HASH_TYPE(0).nbytes
+DISABLE_MULTI_PROCESSING = False
+
+FilesOrDir = Union[List[Path], Path]
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description="Read a set of json files and allow to query them",
+        parents=[jsonql.io_parser()],
+    )
+
+    parser.add_argument("--field", type=str, default="raw_content")
+    parser.add_argument("--output_hashes", type=str)
+    parser.add_argument("--no_finalize", action="store_false", dest="finalize")
+    # parser.add_argument("--mem_gb", type=int)
+    parser.add_argument("--hashes", type=str)
+
+    return vars(parser.parse_args())
+
+
+def _b2i(b: bytes) -> int:
+    return np.frombuffer(b[:HASH_SIZE], dtype=HASH_TYPE, count=1, offset=0).item(0)
+
+
+def str_hash(s: str) -> int:
+    h = hashlib.sha1(bytes(s, encoding="utf-8"))
+    return _b2i(h.digest())
+
+
+log = logging.getLogger(__name__).info
+
+
+def run_par(processes):
+    # This is different from multiprocessing.map since it allows for kwargs.
+    processes = list(processes)
+    if len(processes) == 1 or DISABLE_MULTI_PROCESSING:
+        for f, args, kwargs in processes:
+            f(*args, **kwargs)
+        return
+
+    log(f"Starting {len(processes)} subprocess")
+    processes = [
+        multiprocessing.Process(target=f, args=a, kwargs=kw) for (f, a, kw) in processes
+    ]
+    for p in processes:
+        p.start()
+    for p in processes:
+        p.join()
+    failed = 0
+    for p in processes:
+        if p.exitcode != 0:
+            log(f"Process failed with code {p.exitcode}: {p}")
+            failed += 1
+    assert failed == 0, f"{failed} processes failed..."
+
+
+def split_file(file, n_splits):
+    for i in range(n_splits):
+        yield jsonql.SplitFile(file, i, n_splits)
+
+
+def merge(hashes_1, hashes_2, output):
+    if isinstance(hashes_1, str):
+        h1 = FlatHashSet()
+        h1.load(hashes_1)
+    else:
+        h1 = hashes_1
+
+    if isinstance(hashes_2, str):
+        h2 = FlatHashSet()
+        h2.load(hashes_2)
+    else:
+        h2 = hashes_2
+
+    h2_np = np.fromiter(h2.keys(), dtype=FlatHashSet.dtype, count=len(h2))
+    dup = h1.__contains__(h2_np)
+
+    # Dups between h1 and h2 will be set to 1, keys unique to h2 are copied to
+    # h1 with their value.
+    h1[h2_np] = dup
+    if output:
+        h1.dump(output)
+    return h1
+
+
+def merge_shard(hash_files, output):
+    h = FlatHashSet()
+    h.load(hash_files[0])
+    for hash_file in hash_files[1:]:
+        h = merge(h, hash_file, output=None)
+        print(f"Merged {hash_file}. We now have {len(h)} hashes.")
+
+    h.dump(output)
+    print(f"Saved {len(h)} hashes to {output}.")
+
+
+def _dump_sentence_hashes(source: Path, output: Path, field: str):
+    treated = 0
+    started = time.time()
+    with open(output, "wb") as o:
+        for doc in jsonql.read_jsons(source):
+            content = doc.get(field)
+            if not content:
+                continue
+            h = compute_hashes(content)
+            if h is None:
+                continue
+            h.tofile(o)
+            treated += 1
+            if treated % 100_000 == 0:
+                delay = time.time() - started
+                log(
+                    f"Computed {treated} documents hashes in {delay / 3600:.2f}h ({treated / delay} doc / s)"
+                )
+
+
+def _remove_duplicate_hashes(duplicates, source, output):
+    batch_size = 100_000
+    n_lines, n_lines_kept = 0, 0
+    with open(source, "rb") as f, open(output, "wb") as o:
+        log(f"Opening {source} with mode rb")
+        log(f"Opening {output} with mode wb")
+        while True:
+            hashes = np.fromfile(f, dtype=HASH_TYPE, count=batch_size)
+            if hashes.size == 0:
+                break
+
+            keep = duplicates[hashes] < 1
+            kept = keep.sum()
+            hashes *= keep
+            hashes.tofile(o)
+
+            n_lines += hashes.size
+            n_lines_kept += kept
+
+    removed = n_lines - n_lines_kept
+    selectivity = n_lines_kept / n_lines if n_lines else 0
+    log(f"Removed {removed} duplicate hashes with selectivity: {selectivity:3.1%}")
+
+
+def remove_duplicates_sharded(
+    files: List[Path],
+    outputs: List[Path],
+    hashes_dir: FilesOrDir,
+    field: str,
+    group_hashes: int = 1,
+    tmp_dir: Path = None,
+    min_len: int = 0,
+):
+    """Remove duplicates in several passes, when all hashes don't fit in RAM.
+
+    Note: The current implementation is not doing a 'perfect' deduplication.
+    If a hash appear exactly once in each shard of hashes it won't be detected
+    as a duplicate. This can be fixed if hashes are fully dedup beforehand.
+    """
+    assert len(files) == len(outputs)
+
+    if isinstance(hashes_dir, list):
+        hashes_files = hashes_dir
+    else:
+        hashes_files = sorted(
+            h for h in Path(hashes_dir).iterdir() if h.suffix == ".bin"
+        )
+
+    assert len(hashes_files) > 0, f"no hashes files found in: {hashes_dir}"
+
+    if len(hashes_files) <= group_hashes:
+        log(f"All hashes can be done in one pass, using DuplicatesRemover on {files}")
+        rm_dups = DuplicatesRemover(field, hashes_files)
+        rm_dups._prepare()
+        run_par(
+            (jsonql.run_pipes, (rm_dups,), dict(file=f, output=o))
+            for f, o in zip(files, outputs)
+        )
+        return
+
+    log(f"Starting deduplicate_sharded on {files}.")
+    tmp_directory = tempfile.TemporaryDirectory(dir=str(tmp_dir) if tmp_dir else None)
+
+    def tmp_files(i):
+        return [
+            Path(tmp_directory.name) / (f.name.split(".")[0] + f".{i}.bin")
+            for f in files
+        ]
+
+    last = tmp_files(0)
+    run_par((_dump_sentence_hashes, (f, tmp, field), {}) for f, tmp in zip(files, last))
+
+    if isinstance(hashes_dir, list):
+        hashes_files = hashes_dir
+    else:
+        hashes_files = sorted(
+            h for h in Path(hashes_dir).iterdir() if h.suffix == ".bin"
+        )
+    for i, group in enumerate(jsonql.grouper(hashes_files, group_hashes)):
+        hashes = FlatHashSet()
+        for h in group:
+            hashes.load(h)
+            log(f"Loaded {h}, up to {len(hashes)} hashes ({mem_footprint_gb()}GB)")
+
+        intermediates = tmp_files(i + 1)
+        # Remove hashes in parallel. Since modern OS have "copy-on-write" and
+        # `hashes` is read-only, we will only have one version of it in RAM.
+        run_par(
+            (_remove_duplicate_hashes, (hashes, f, tmp), {})
+            for f, tmp in zip(last, intermediates)
+        )
+        # Force hashes to be freed, before we start allocating a new one.
+        del hashes
+        gc.collect()
+
+        for tmp in last:
+            os.remove(tmp)
+        last = intermediates
+
+    def finalize(source, dedup_hashes, min_len):
+        n_chars, n_chars_kept = 0, 0
+        with open(dedup_hashes, "rb") as hashes:
+            for doc in jsonql.read_jsons(source):
+                content = doc.get(field)
+                if not content or len(content) < min_len:
+                    continue
+                sentences = content.split("\n")
+                doc_hashes = np.fromfile(hashes, dtype=HASH_TYPE, count=len(sentences))
+                chars, kept_chars = finalize_doc(doc, field, doc_hashes)
+                n_chars += chars
+                n_chars_kept += kept_chars
+                yield doc
+        selectivity = n_chars_kept / n_chars if n_chars else 0
+        log(f"Kept {n_chars_kept} chars out of {n_chars} ({selectivity:.1%}).")
+
+    dedup_hashes = last
+    run_par(
+        [
+            (
+                jsonql.run_pipe,
+                (finalize,),
+                dict(kwargs=dict(dedup_hashes=h, min_len=min_len), file=f, output=o),
+            )
+            for h, f, o in zip(dedup_hashes, files, outputs)
+        ]
+    )
+
+    tmp_directory.cleanup()
+
+
+def compute_hashes(content) -> Optional[np.ndarray]:
+    if not content:
+        return None
+    lines = content.split("\n")
+    # save hashes as bytes but reinterpret them as uint64.
+    hashes = np.fromiter(
+        (
+            hashlib.sha1(bytes(normalize_for_dedup(l), encoding="utf-8")).digest()[
+                :HASH_SIZE
+            ]
+            for l in lines
+        ),
+        dtype=np.dtype((bytes, HASH_SIZE)),
+        count=len(lines),
+    )
+    return np.ndarray(dtype=HASH_TYPE, buffer=hashes.data, shape=hashes.shape)
+
+
+def finalize_doc(doc, field, hashes=None):
+    content = doc.get(field)
+    lines = content.split("\n")
+    n_chars = len(content)
+    if "original_nlines" not in doc:
+        doc["original_nlines"] = doc.get("nlines", len(lines))
+    if "original_length" not in doc:
+        doc["original_length"] = doc.get("length", n_chars)
+    if hashes is None:
+        hashes = doc.pop(field + "_hash")
+
+    # Remove duplicates inside doc
+    seen: Set[int] = set()
+    original_line_ids = doc.get("line_ids", range(len(hashes)))
+    line_ids = []
+    new_lines = []
+    for l, line, h in zip(original_line_ids, lines, hashes):
+        if h not in seen and h != 0:
+            line_ids.append(l)
+            new_lines.append(line)
+        seen.add(h)
+
+    doc[field] = "\n".join(new_lines)
+    doc["nlines"] = len(line_ids)
+    n_chars_kept = len(doc[field])
+    doc["length"] = n_chars_kept
+    doc["line_ids"] = line_ids
+    return n_chars, n_chars_kept
+
+
+class HashesCollector(jsonql.Transformer):
+    """
+    Collect all hashes found of lines found in the `field` of the source documents.
+    """
+
+    parallelisable = False
+
+    def __init__(
+        self, field: str, output: Path = None, hashes: AbstractDedupHashSet = None
+    ):
+        super().__init__()
+        self.n_lines = 0
+        self.field = field
+        self.output = output
+        self.hashes = FlatHashSet() if hashes is None else hashes
+        self.num_hashes_end = 0
+        self.num_hashes_start = len(self.hashes)
+
+    def summary(self) -> List[str]:
+        summ = super().summary()
+        h = self.num_hashes_end if self.hashes is None else len(self.hashes)
+        h = (h - self.num_hashes_start) // 1000
+        max_mem = mem_footprint_gb()
+        n = self.n_lines // 1000
+        summ.append(
+            f"Found {h:_}k unique hashes over {n:_}k lines. Using {max_mem:.1f}GB of RAM."
+        )
+        return summ
+
+    def do(self, doc: dict) -> None:
+        doc_hashes = compute_hashes(doc.get(self.field))
+        if doc_hashes is None:
+            return
+        self.hashes.add(doc_hashes)
+        self.n_lines += doc_hashes.size
+
+    def close(self):
+        if self.output and self.hashes:
+            self.hashes.dump(self.output)
+            self.log(f"Saved {len(self.hashes)} hashes to {self.output}")
+            # Save the number of hashes.
+            self.num_hashes_end = len(self.hashes)
+            # Free up mem even if the transformer is kept somewhere else.
+            self.hashes = None  # type: ignore
+
+
+class DuplicatesRemover(jsonql.Transformer):
+    """DuplicatesRemover"""
+
+    # The hashes can't be pickled so they will have to be read back from disk.
+    warn_when_pickling = True
+
+    def __init__(self, field: str, hashes_files: List[Path], collect: bool = False):
+        """
+        Remove duplicates
+        """
+        super().__init__()
+        self.field = field
+        self.collect = collect
+
+        self.hashes_files = hashes_files
+        self.duplicates: Optional[AbstractDedupHashSet] = None
+
+        self.n_lines, self.n_lines_kept = 0, 0
+        self.n_chars, self.n_chars_kept = 0, 0
+
+    def _prepare(self):
+        if self.duplicates is not None:
+            return
+        self.duplicates = FlatHashSet()
+
+        start = time.time()
+        for h in self.hashes_files:
+            shard_start = time.time()
+            self.duplicates.load(str(h))
+            delay = time.time() - shard_start
+            self.log(
+                f"Loaded hashes from {h} ({mem_footprint_gb():.3f}GB total, took {delay / 60:.1}m)"
+            )
+
+        delay = time.time() - start
+        self.log(
+            f"Loaded {len(self.duplicates):_d} hashes from {len(self.hashes_files)} files. ({mem_footprint_gb():.1f}GB total, took {delay / 60:.1}m)"
+        )
+
+    def do(self, doc: dict) -> Optional[dict]:
+        content = doc.get(self.field)
+        if not content:
+            return None
+        doc_hashes = compute_hashes(content)
+
+        assert self.duplicates is not None
+        seen = (
+            self.duplicates.add(doc_hashes)
+            if self.collect
+            else self.duplicates[doc_hashes]
+        )
+        keep = seen < True
+        kept = keep.sum()
+        if kept == 0:
+            return None
+        doc_hashes = doc_hashes * keep
+        self.n_lines += keep.size
+        self.n_lines_kept += kept
+        chars, kept_chars = finalize_doc(doc, self.field, hashes=doc_hashes)
+        self.n_chars += chars
+        self.n_chars_kept += kept_chars
+        return doc
+
+    def summary(self) -> List[str]:
+        summ = super().summary()
+        end_time = time.time()
+        n_lines_kept, n_lines, n_docs = self.n_lines_kept, self.n_lines, self.processed
+        speed = n_docs / (end_time - self.start_time)
+        summ.append(
+            f"Processed {self.n_lines} lines in {n_docs} docs. [{speed:.1f} doc/s]"
+        )
+        selectivity = self.n_lines_kept / self.n_lines if n_lines else 0
+        summ.append(f"Kept {n_lines_kept} lines out of {n_lines} ({selectivity:.1%}).")
+
+        n_chars_kept, n_chars = self.n_chars_kept, self.n_chars
+        selectivity = n_chars_kept / n_chars if n_chars else 0
+        summ.append(f"Kept {n_chars_kept} chars out of {n_chars} ({selectivity:.1%}).")
+        return summ
+
+
+def deduplicate(
+    file: jsonql.ReadableFileLike, field: str = "raw_content"
+) -> Iterable[dict]:
+    """Remove duplicates of the given file (but keep the first occurence)."""
+    dup_remover = DuplicatesRemover(field, [], collect=True)
+    return dup_remover.map(jsonql.read_jsons(file))
+
+
+def deduplicate_two_pass(
+    file: jsonql.FileDescriptor, field: str = "raw_content"
+) -> Iterable[dict]:
+    """Remove duplicates of the given file (even removing the first occurence).
+
+    This is what is done in the paper, and in mine.py
+    """
+    try:
+        if isinstance(file, Path):
+            hash_file: Path = file.with_suffix(".bin")
+        else:
+            hash_file = jsonql._tmp(Path("hashes.bin"))
+        jsonql.run_pipes(
+            jsonql.JsonReader(), HashesCollector(field, output=hash_file), file=file
+        )
+        dup_remover = DuplicatesRemover(field, [hash_file])
+        return dup_remover.map(jsonql.read_jsons(file))
+    finally:
+        if hash_file.exists():
+            hash_file.unlink()

cc-multilingual-main/cc_net/build/lib/cc_net/execution.py

@@ -0,0 +1,248 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import functools
+import itertools
+import logging
+import os
+import sys
+import time
+import warnings
+from pathlib import Path
+from typing import Callable, Dict, Iterable, List, Optional, Sequence, Sized
+
+import submitit
+from typing_extensions import Protocol
+# import pdb
+from concurrent.futures import ThreadPoolExecutor
+
+
+class Executor(Protocol):
+    def __call__(self, function: Callable[..., str], *args: Iterable) -> None:
+        ...
+
+
+class SubmititRetryOnTimeout(submitit.helpers.Checkpointable):
+    def __init__(self, fn: Callable):
+        self.fn = fn
+        self.__name__ = fn.__name__
+
+    def __call__(self, *args, **kwargs):
+        return self.fn(*args, **kwargs)
+
+
+def get_executor(
+    name: str,
+    log_dir: Path,
+    execution: str,
+    timeout_hour: float = 1.0,
+    mem_gb: int = 1,
+    cpus: int = 1,
+    task_parallelism: int = -1,
+    options: dict = {},
+) -> Executor:
+
+    execution_mode = execution.split(",")[0]
+    options.update(
+        {kv.split("=", 1)[0]: kv.split("=", 1)[1] for kv in execution.split(",")[1:]}
+    )
+
+    if execution_mode == "mp":
+        warnings.warn("Execution mode 'mp' is deprecated, use 'local'.")
+        execution_mode = "local"
+
+    cluster = None if execution_mode == "auto" else execution_mode
+    # use submitit to detect which executor is available
+    ex = submitit.AutoExecutor(log_dir, cluster=cluster)
+    ex.parameters['timeout_min'] = int(timeout_hour * 60)
+
+    if ex.cluster == "local":
+        # LocalExecutor doesn't respect task_parallelism
+        return functools.partial(custom_map_array, ex, task_parallelism)
+    if ex.cluster == "debug":
+        return debug_executor
+    # pdb.set_trace()
+    # We are on slurm
+    if task_parallelism == -1:
+        task_parallelism = 500
+
+    ex.update_parameters(
+        name=name,
+        timeout_min=int(timeout_hour * 60),
+        mem_gb=mem_gb,
+        cpus_per_task=cpus,
+        slurm_array_parallelism=task_parallelism,
+        **options,
+    )
+    return functools.partial(map_array_and_wait, ex)
+
+
+def map_array_and_wait(
+    ex: submitit.AutoExecutor, function: Callable[..., str], *args: Iterable
+):
+    f_name = function.__name__
+
+    assert len(args) > 0, f"No arguments passed to {f_name}"
+    approx_length = _approx_length(*args)
+
+    print(f"Submitting {f_name} in a job array ({approx_length} jobs)")
+    jobs = ex.map_array(function, *args)
+    if not jobs:
+        return
+    failed_jobs = []
+    done = 0
+    total = len(jobs)
+    job_array_id = jobs[0].job_id.split("_")[0]
+    # pdb.set_trace()
+    print(f"Started {f_name} in job array {job_array_id} ({len(jobs)} jobs).")
+    for job in submitit.helpers.as_completed(jobs):
+        done += 1
+        e = job.exception()
+        if not e:
+            print(f"Finished job {job.job_id} ({done} / {total}).", job.result())
+            continue
+
+        print(f"Failed job {job.job_id} ({done} / {total}):", e)
+        failed_jobs.append(job)
+
+    if failed_jobs:
+        n_failures = 10
+        message = f"{len(failed_jobs)} / {done} jobs failed while running {f_name}"
+        print(message)
+        for job in failed_jobs[:n_failures]:
+            print(f"Failed {job.job_id} -> {job.paths.stderr}")
+        if len(failed_jobs) > n_failures:
+            print(f"... ({len(failed_jobs) - n_failures} failed job skipped)")
+        raise Exception(message)
+
+
+def debug_executor(function: Callable[..., Optional[str]], *args: Iterable) -> None:
+    logging.getLogger().setLevel(logging.DEBUG)
+    approx_length = _approx_length(*args)
+    for i, x in enumerate(zip(*args)):
+        try:
+            message = function(*x)
+        except Exception:
+            exit(1)
+            try:
+                import ipdb as pdb  # type: ignore
+            except ImportError:
+                import pdb  # type: ignore
+            import traceback
+
+            traceback.print_exc()
+            print("")
+            pdb.post_mortem()
+            sys.exit(1)
+        if message is not None:
+            print(message, f"({i + 1} / {approx_length})")
+
+# def debug_executor(function: Callable[..., Optional[str]], *args: Iterable) -> None:
+#     logging.getLogger().setLevel(logging.DEBUG)
+#     approx_length = _approx_length(*args)
+#     with ThreadPoolExecutor(max_workers=4) as executor:
+#         futures = []
+#         for i, x in enumerate(zip(*args)):
+#             future = executor.submit(_execute_function, function, x, i + 1, approx_length)
+#             futures.append(future)
+#         for future in futures:
+#             future.result()
+
+# def _execute_function(function: Callable[..., Optional[str]], args: tuple, index: int, total: int):
+#     try:
+#         message = function(*args)
+#         if message is not None:
+#             print(message, f"({index} / {total})")
+#     except Exception:
+#         # traceback.print_exc()
+#         sys.exit(1)
+
+def _approx_length(*args: Iterable):
+    for a in args:
+        if isinstance(a, Sized):
+            return len(a)
+    return -1
+
+
+def custom_map_array(
+    ex: submitit.AutoExecutor,
+    parallelism: int,
+    function: Callable[..., Optional[str]],
+    *args: Iterable,
+) -> None:
+    f_name = function.__name__
+    assert len(args) > 0, f"No arguments passed to {f_name}"
+
+    jobs_args = list(zip(*args))
+    total = len(jobs_args)
+    if parallelism < 0:
+        parallelism = os.cpu_count() or 0
+    assert parallelism >= 0, f"Can't run any jobs with task_parallelism={parallelism}"
+    print(f"Submitting {total} jobs for {f_name}, with task_parallelism={parallelism}")
+    enqueued = 0
+    done = 0
+    running_jobs: List[submitit.Job] = []
+    failed_jobs: List[submitit.Job] = []
+
+    while done < len(jobs_args):
+        # Try to queue more job if we have some bandwidth.
+        if enqueued < total and len(running_jobs) < parallelism:
+            running_jobs.append(ex.submit(function, *jobs_args[enqueued]))
+            enqueued += 1
+            continue
+
+        # Else wait for some job to finish
+        if not running_jobs:
+            warnings.warn(
+                f"No more running jobs, yet we submitted only {enqueued} / {total} and finished {done} / {total}"
+            )
+            break
+
+        job = get_next_job(running_jobs)
+        running_jobs.remove(job)
+        done += 1
+        e = job.exception()
+        if not e:
+            print(f"Finished job {job.job_id} ({done} / {total}).", job.result())
+            continue
+
+        print(f"Failed job {job.job_id} ({done} / {total}):", e)
+        failed_jobs.append(job)
+
+    if failed_jobs:
+        n_failures = 10
+        message = f"{len(failed_jobs)} / {done} jobs failed while running {f_name}"
+        print(message)
+        for job in failed_jobs[:n_failures]:
+            print(f"Failed {job.job_id} -> {job.paths.stderr}")
+        if len(failed_jobs) > n_failures:
+            print(f"... ({len(failed_jobs) - n_failures} failed job skipped)")
+        raise Exception(message)
+
+
+def get_next_job(
+    jobs: Sequence[submitit.Job], poll_frequency: float = 10
+) -> submitit.Job:
+    """
+    Waits for any of the job to finish and returns it.
+
+    jobs: list of jobs
+    poll_frequency: frequency in second at which we check job status
+    """
+    start = time.time()
+    waiting = False
+    while True:
+        for job in jobs:
+            if job.done():
+                return job
+        if not waiting:
+            job_ids = [j.job_id for j in jobs[:4]]
+            suffix = "..." if len(jobs) > 4 else ""
+            print(
+                f"Waiting on {len(jobs)} running jobs. Job ids: {','.join(job_ids)}{suffix}"
+            )
+            waiting = True
+        time.sleep(poll_frequency)

cc-multilingual-main/cc_net/build/lib/cc_net/flat_hash_set.py

@@ -0,0 +1,247 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import sys
+import time
+import warnings
+from typing import Iterable, Iterator, Sequence, Sized, Tuple, Type
+
+import numpy as np
+
+HASH_TYPE: Type[np.uint64] = np.uint64
+
+GETPY_WARNING = False
+
+
+class AbstractDedupHashSet(Sized, Iterable[np.uint64]):
+    """A dict-like that returns `True` for keys that have been added more than once.
+
+    The API is batched and expect np.array as input. This batching grants better
+    perf when using the C++ implementation.
+    """
+
+    dtype: Type[np.uint64] = HASH_TYPE
+
+    def __repr__(self):
+        implementation = type(self).__name__
+        return f"[{implementation}, len: {len(self)}"
+
+    def __len__(self) -> int:
+        ...
+
+    def __contains__(self, values: Sequence[np.uint64]) -> np.ndarray:
+        ...
+
+    def __getitem__(self, values) -> np.ndarray:
+        ...
+
+    def __setitem__(self, keys, values) -> None:
+        ...
+
+    def items(self) -> Iterable[Tuple[np.uint64, np.uint8]]:
+        ...
+
+    def keys(self) -> Iterable[np.uint64]:
+        ...
+
+    def __iter__(self) -> Iterator[np.uint64]:
+        return iter(self.keys())
+
+    def add(self, h, contains=None):
+        """Add the given keys. First time a key is added the value is set to 0,
+        then it's set to one."""
+        if not isinstance(h, np.ndarray):
+            h = np.array(h, dtype=HASH_TYPE)
+        if contains is None:
+            contains = self.__contains__(h)
+
+        self.__setitem__(h, contains)
+        return contains
+
+    def merge(self, keys, values):
+        contains = self.__contains__(keys)
+        self.__setitem__(keys, contains | values)
+
+    def dump(self, filename):
+        return self.dump_np(filename)
+
+    def load(self, filename):
+        return self.load_np(filename)
+
+    def dump_np(self, filename):
+        kv_type = np.dtype([("k", HASH_TYPE), ("v", np.uint8)])
+        items = np.fromiter(self.items(), dtype=kv_type, count=len(self))
+        with open(filename, "wb") as f:
+            np.save(f, items)
+
+    def load_np(self, filename):
+        items = np.load(str(filename))
+        keys = items["k"].copy()
+        values = items["v"].copy()
+        self.merge(keys, values)
+
+    def dump_np2(self, filename):
+        keys = np.fromiter(
+            (k for (k, v) in self.items()), dtype=HASH_TYPE, count=len(self)
+        )
+        with open(filename, "wb") as f:
+            np.save(f, keys)
+
+        values = np.fromiter(
+            (v for (k, v) in self.items()), dtype=np.uint8, count=len(self)
+        )
+        with open(str(filename) + ".val", "wb") as f:
+            np.save(f, values)
+
+    def load_np2(self, filename):
+        keys = np.load(filename)
+        values = np.load(str(filename) + ".val")
+        self.merge(keys, values)
+
+
+class NaiveHashSet(dict, AbstractDedupHashSet):
+    """Pure python implementation of AbstractDedupHashSet.
+
+    This implementation is quite fast, since Python dict are heavily optimized.
+    """
+
+    def __init__(self, iterable=None):
+        super().__init__()
+        global GETPY_WARNING
+        if GETPY_WARNING:
+            warnings.warn(
+                "Module 'getpy' not found. Deduplication will take more RAM."
+                " Try `pip install cc_net[getpy]"
+            )
+        GETPY_WARNING = False
+
+    def __contains__(self, values):
+        """Returns `True` if the object has been added at list once."""
+        contains_point = super().__contains__
+        return np.fromiter(
+            map(contains_point, values), count=len(values), dtype=np.uint8
+        )
+
+    def __getitem__(self, values):
+        """Returns `True` if the object has been added at list twice."""
+        get_point = super().get
+        return np.fromiter(
+            map(lambda x: get_point(x, False), values),
+            count=len(values),
+            dtype=np.uint8,
+        )
+
+    def __setitem__(self, keys, values):
+        assert len(keys) == len(values)
+        for k, v in zip(keys, values):
+            dict.__setitem__(self, k, v)
+
+
+try:
+    import getpy as gp  # type: ignore
+
+    class _FlatHashSet(gp.Dict, AbstractDedupHashSet):
+        """C++ backed implementation of AbstractDedupHashSet.
+
+        This implementation is slightly slower than the Python one but uses
+        3x less RAM.
+        See https://github.com/atom-moyer/getpy.
+        """
+
+        def __init__(self):
+            super().__init__(HASH_TYPE, np.uint8, default_value=False)
+
+        def __contains__(self, h):
+            """Returns `True` if the object has been added at list once."""
+            if not isinstance(h, np.ndarray):
+                h = np.array(h, dtype=HASH_TYPE)
+            c = gp.Dict.__contains__(self, h)
+            c.dtype = np.uint8
+            return c
+
+        def dump(self, filename):
+            return self.dump_gp(filename)
+
+        def load(self, filename):
+            return self.load_gp(filename)
+
+        def dump_gp(self, filename):
+            return gp.Dict.dump(self, str(filename))
+
+        def load_gp(self, filename):
+            """Override gp.Dict.load, to correctly merge values instead of overwriting."""
+            other = gp.Dict(HASH_TYPE, np.uint8, default_value=False)
+            other.load(str(filename))
+            n = len(other)
+            keys = np.fromiter(
+                (k for (k, v) in other.items()), dtype=HASH_TYPE, count=n
+            )
+            values = np.fromiter(
+                (v for (k, v) in other.items()), dtype=np.uint8, count=n
+            )
+            self.merge(keys, values)
+
+    FlatHashSet: Type[AbstractDedupHashSet] = _FlatHashSet
+except ImportError:
+    GETPY_WARNING = True
+    FlatHashSet = NaiveHashSet
+
+
+def timeit(message, function, *args):
+    start = time.time()
+    function(*args)
+    end = time.time()
+    print(message, f"took {end - start:.0f}s")
+
+
+def compare_load(*filenames):
+    assert filenames, "No file given"
+
+    def load_list():
+        hashes = []
+        for f in filenames:
+            h = FlatHashSet()
+            h.load(f)
+            print(f"Loaded {h} from {f}.")
+            hashes.append(h)
+        return hashes
+
+    def load_all(load, ext):
+        hashes = FlatHashSet()
+        for f in filenames:
+            load(hashes, f + ext)
+
+    def dump_all(hashes, dump, ext):
+        for h, f in zip(hashes, filenames):
+            dump(h, f + ext)
+
+    hashes = load_list()
+    dump_gp = getattr(FlatHashSet, "dump_gp")
+    if dump_gp is not None:
+        timeit("Dumping using gp.dump", dump_all, hashes, dump_gp, ".gp.test")
+    timeit("Dumping using dump_np", dump_all, hashes, FlatHashSet.dump_np, ".npy.test")
+    timeit(
+        "Dumping using dump_np2", dump_all, hashes, FlatHashSet.dump_np2, ".npy2.test"
+    )
+
+    load_gp = getattr(FlatHashSet, "load_gp")
+    if load_gp is not None:
+        timeit("Loading using gp.load", load_all, load_gp, ".gp.test")
+    timeit("Loading using load_np", load_all, FlatHashSet.load_np, ".npy.test")
+    timeit("Loading using load_np2", load_all, FlatHashSet.load_np2, ".npy2.test")
+
+    # Loading 10 shards:
+    # [dedup] Dumping using gp.dump took 52s
+    # [dedup] Dumping using dump_np took 270s
+    # [dedup] Dumping using dump_np2 took 483s
+    #
+    # [dedup] Loading using gp.load took 654s
+    # [dedup] Loading using load_np took 82s
+    # [dedup] Loading using load_np2 took 76s
+
+
+if __name__ == "__main__":
+    compare_load(*sys.argv[1:])

cc-multilingual-main/cc_net/build/lib/cc_net/get_wiki_cirrus.py

@@ -0,0 +1,127 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Creates mono-lingual corpus from Wikipedia.
+"""
+
+import functools
+import re
+import subprocess
+import urllib.request
+from pathlib import Path
+from typing import Dict
+
+import func_argparse
+from bs4 import BeautifulSoup  # type: ignore
+
+from cc_net import jsonql, text_normalizer
+
+CIRRUS_URL = "https://dumps.wikimedia.org/other/cirrussearch"
+CIRRUS_DUMP_RE = re.compile(r"^(.*)wiki-\d+-cirrussearch-content\.json\.gz")
+
+
+def tmp(file: Path) -> Path:
+    return file.parent / ("tmp." + file.name)
+
+
+def opening(file: Path, output: Path = None, n_docs: int = 1_000_000):
+    """Will dump the tokenized opening text of the given Wikipedia.
+
+    Args:
+        - file: File containing the Wikipedia dump.
+        - output: Output file.
+        - n_docs: How many docs to parse
+        - tokenize: whether to tokenize the text
+        - lang: Language code used to chose the tokenizer
+    """
+    assert file.exists()
+    return jsonql.run_pipes(
+        functools.partial(extract_opening_text, n_docs=n_docs),
+        file=file,
+        output=tmp(output) if output else None,
+    )
+    if output:
+        tmp(output).replace(output)
+
+
+def extract_opening_text(source, n_docs: int = 10_000):
+    i = 0
+    for doc in jsonql.read_jsons(source):
+        if not doc:
+            continue
+
+        text = doc.get("opening_text")
+        if not text:
+            continue
+
+        yield text_normalizer.normalize(text)
+        i += 1
+        if i >= n_docs:
+            break
+
+
+def dl(lang: str, output_dir: Path, date: str = None):
+    """Download the cirrus extract for the given lang.
+
+    See https://dumps.wikimedia.org/other/cirrussearch for the full list of files.
+
+    Args:
+        - lang: The Wikipedia code for the language.
+        - output_dir: Output directory. File will be `{lang}.json.gz`
+        - date: Date of a specific Cirrus dump.
+    """
+
+    urls = get_cirrus_urls(date)
+    assert (
+        lang in urls
+    ), f"--lang {lang} not found. Available languages are: {urls.keys()}"
+
+    assert output_dir, "--output_dir folder needed."
+    output_dir.mkdir(exist_ok=True)
+    output = output_dir / (lang + ".json.gz")
+    print(f"Downloading {lang} wiki from {urls[lang]} to {output}")
+    wget(urls[lang], output)
+
+
+def get_cirrus_urls(date: str = None) -> Dict[str, str]:
+    if date is None:
+        cirrus_page = BeautifulSoup(
+            urllib.request.urlopen(CIRRUS_URL), features="html.parser"
+        )
+        dumps = [a.get("href").strip("/") for a in cirrus_page.findAll("a")]
+        dumps.remove("..")
+        dumps.remove("current")
+        # We take the oldest dump since the most recent might be incomplete.
+        # The page only link to the N latest dumps so the dump won't be too old.
+        date = min(dumps)
+
+    cirrus_url = "/".join((CIRRUS_URL, date))
+    print("Will use the Wikipedia dump from:", date, cirrus_url)
+    cirrus_page = BeautifulSoup(
+        urllib.request.urlopen(cirrus_url), features="html.parser"
+    )
+    urls = {}
+    for link in cirrus_page.findAll("a"):
+        match = CIRRUS_DUMP_RE.match(link.get("href"))
+        if not match:
+            continue
+
+        urls[match.group(1)] = "/".join([cirrus_url, link.get("href")])
+    assert urls, f"No valid download urls found at {cirrus_url}"
+    return urls
+
+
+def wget(url: str, output: Path):
+    subprocess.run(["wget", url, "-O", tmp(output), "-q"], check=True)
+    tmp(output).replace(output)
+    assert (
+        output.stat().st_size > 10_000
+    ), f"File {output} downloaded from {url} looks too small"
+
+
+if __name__ == "__main__":
+    func_argparse.main(dl, opening)

cc-multilingual-main/cc_net/build/lib/cc_net/jsonql.py

@@ -0,0 +1,1340 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Manipulate files containing one json per line.
+"""
+import argparse
+import collections
+import contextlib
+import functools
+import glob
+import gzip
+import importlib
+import inspect
+import io
+import itertools
+import json
+import logging
+import multiprocessing
+import os
+import re
+import sys
+import tempfile
+import time
+import typing as tp
+import warnings
+import zlib
+from pathlib import Path
+from typing import (
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    TextIO,
+    Tuple,
+    Union,
+)
+
+import numpy as np
+import psutil  # type: ignore
+import requests
+from typing_extensions import Protocol
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(process)d:%(name)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M",
+)
+
+NEWLINE = " N3WL1N3 "
+
+FilterFn = Callable[[dict], bool]
+FileDescriptor = Union[Path, List[Path], str]
+WritableFileLike = Union[FileDescriptor, TextIO, "SimpleIO", None]
+ReadableFileLike = Union[Iterable[str], FileDescriptor, None]
+
+
+def io_parser():
+    """Parser shared by all commands to get input/output files."""
+    parser = argparse.ArgumentParser(add_help=False)
+    file_help = """File to read from. Can be specified several times for several files.
+    Be careful that bash will expand glob patterns **before** sending the args
+    to python. To use globs put it inside single quotes:
+        jsonql where --file 'data/perplexity/*.json' '{length} > 100' | head -1
+        jsonql --file 'data/perplexity/*.json' where '{length} > 100' | head -1
+        [Invalid] jsonql where '{length} > 100' --file data/perplexity/*.json | head -1
+        [Invalid] jsonql where --file data/perplexity/*.json '{length} > 100' | head -1
+    """
+    parser.add_argument("-f", "--file", type=Path, action="append", help=file_help)
+    parser.add_argument("-o", "--output", type=Path, default="-")
+    parser.add_argument("--processes", type=int, default=1)
+    return parser
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="Read a set of json files and allow to query them"
+    )
+    subparsers = parser.add_subparsers()
+
+    def add_subparser(function, arguments):
+        doc = function.__doc__.split("\n")[0]
+        p = subparsers.add_parser(function.__name__, help=doc, parents=[io_parser()])
+        p.set_defaults(command=function)
+        for k, v in arguments.items():
+            p.add_argument(k, **v)
+
+    add_subparser(
+        select,
+        {
+            "columns": dict(nargs="+", help="Extract the value of the given fields"),
+            "--skip_empty": dict(
+                action="store_true", help="Skip lines without the requested fields"
+            ),
+            "--separator": dict(
+                default="\t", help="Separator to use between the different columns"
+            ),
+            "--newline": dict(
+                default=NEWLINE,
+                help="Replace newlines found in the text by the given string",
+            ),
+        },
+    )
+
+    add_subparser(
+        where,
+        {
+            "clauses": dict(nargs="+", help=""),
+            "--requires": dict(
+                action="append", help="Python module required by the clauses code."
+            ),
+        },
+    )
+
+    add_subparser(
+        merge,
+        {
+            "columns": dict(nargs="+", help=""),
+            "--separator": dict(
+                default="\t", help="Separator to use between the different columns"
+            ),
+            "--newline": dict(
+                default=NEWLINE, help="Replace the given string by actual newlines"
+            ),
+        },
+    )
+
+    add_subparser(
+        describe,
+        {
+            "columns": dict(nargs="*", help=""),
+            "--bins": dict(
+                default="auto", help="Number of bins for computing the histograms"
+            ),
+            "--cumulative": dict(
+                action="store_true", help="Compute cumulative histograms"
+            ),
+            "--weights": dict(type=str, help="Column used to weight histograms"),
+        },
+    )
+
+    add_subparser(split, {"--pattern": dict(type=str)})
+    add_subparser(shard, {})
+    return parser
+
+
+def _split_array(array, sep):
+    last = 0
+    for i, x in enumerate(array):
+        if x != sep:
+            continue
+        yield array[last:i]
+        last = i + 1
+    if last != len(array):
+        yield array[last:]
+
+
+def main(raw_args):
+    parser = get_parser()
+    pipeline = []
+    file = "-"
+    output = "-"
+    processes = 1
+
+    for args_group in _split_array(raw_args, "--"):
+        args = vars(parser.parse_args(args_group))
+        command = args.pop("command")
+        file = args.pop("file") or file
+        output = args.pop("output") or output
+        processes = args.pop("processes") or processes
+        pipeline.append(as_pipe(command, args))
+
+    if not pipeline:
+        parser.print_help()
+        return
+
+    run_pipes(*pipeline, file=Path(file), output=Path(output), processes=processes)
+
+
+class Transformer:
+    """
+    Wrapper around functions transforming documents.
+
+    This allows `run_pipes` to automatically parallelize the pipeline.
+    Provides:
+    * Automatic logging. Logging can be changed with the `summary` method.
+        Loggin frequency with _log_freq (in second) or $JSONQL_LOG_FREQ env variable.
+    * Automatic parallelization without pickling. The transformers are shared
+    across processes, and the object is usually not pickled.
+    * Basic pickling / unpickling in case it's still needed.
+    By default will only pickle the arguments passed to the constructor.
+    * Delayed initialization. Internal state which is not pickable should be set
+    inside the `_prepare` function.
+    """
+
+    parallelisable: bool = True
+    expect_json: bool = False
+    warn_when_pickling: bool = False
+    ready: bool = False
+
+    def __init_subclass__(cls, expect_json: bool = None):
+        """Detects if the subclass expects json as input."""
+        spec = inspect.getfullargspec(cls.do)
+        if expect_json is None:
+            expect_json = spec.annotations.get(spec.args[1], None) == dict
+
+        cls.expect_json = expect_json
+
+    def __new__(cls, *args, **kwargs):
+        """Creates the transformer and save the arguments passed to the constructor."""
+        t = super().__new__(cls)
+        Transformer.__init__(t, args, kwargs)
+        return t
+
+    def __init__(self, state_args: tuple = None, state_kwargs: dict = None):
+        """
+        Init the transformer counters.
+
+        If state_args/state_kwargs are set they will override whatever was
+        originally passed to the subclass constructor.
+        """
+        if state_args is not None:
+            self.__args = state_args
+        if state_kwargs is not None:
+            self.__kwargs = state_kwargs
+
+        self.start_time = time.time()
+        self.__last_log = self.start_time
+        self.processed = 0
+        # Log every 5 min unless specified other wise.
+        self._log_freq = int(os.environ.get("JSONQL_LOG_FREQ", 5 * 60))
+        self.__cls = type(self)
+        self._logger = logging.getLogger(self.__cls.__name__)
+
+    def __call__(self, x):
+        assert self.ready, f"{self} is not ready."
+        if x is None:
+            return
+        y = self.do(x)
+        self.processed += 1
+        if time.time() - self.__last_log > self._log_freq:
+            self.log_summary()
+        return y
+
+    def do(self, x):
+        raise NotImplementedError(f"'do' not implemented in {type(self)}")
+
+    def summary(self) -> List[str]:
+        return [self.speed_summary()]
+
+    def speed_summary(self) -> str:
+        delay = time.time() - self.start_time
+        h = delay / 3600
+        s = self.processed / delay
+        return f"Processed {self.processed:_} documents in {h:.2}h ({s:5.1f} doc/s)."
+
+    def log(self, message):
+        self._logger.info(message)
+
+    def log_summary(self) -> None:
+        if not self.ready:
+            self.log("Not ready.")
+            return
+        summ = self.summary() or []
+        for line in summ:
+            self.log(line)
+        self.__last_log = time.time()
+
+    def map(self, source: Iterable) -> Iterator:
+        if self.ready:
+            for x in source:
+                yield self(x)
+            # since we have been prepared by caller,
+            # caller is also responsible for calling `close`.
+            return
+        else:
+            with self:
+                for x in source:
+                    yield self(x)
+
+    def __getstate__(self) -> Tuple[tuple, dict, bool]:
+        return (self.__args, self.__kwargs, self.expect_json)
+
+    def __setstate__(self, state: Tuple[tuple, dict, bool]):
+        if self.warn_when_pickling:
+            warnings.warn(f"Unpickling transformer: {type(self)}. This can be slow.")
+        (args, kwargs, expect_json) = state
+        # When unpickling `__new__` isn't called so we have to doit ourselves.
+        Transformer.__init__(self, state_args=args, state_kwargs=kwargs)
+        type(self).__init__(self, *args, **kwargs)
+        assert self.expect_json == expect_json
+        # __setstate__ is called by multiprocessing right before calling
+        # the object so we need to initialize everything.
+        self.__enter__()
+
+    def _prepare(self) -> None:
+        pass
+
+    def __enter__(self) -> "Transformer":
+        # In multiprocessing __enter__ is always called twice, so we are idempotent.
+        # Because we call __enter__ when deserializing this transformer and
+        # also when the parent transformer is deserialized.
+        self.start_time = time.time()
+        if self.ready:
+            return self
+        self._prepare()
+        self.ready = True
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+        self.log_summary()
+
+    def close(self) -> None:
+        pass
+
+
+def as_pipe(transformer, kwargs):
+    if isinstance(transformer, type):
+        return transformer(**kwargs)
+    return lambda source: transformer(source, **kwargs)
+
+
+def compose(fns: List[Transformer]) -> Transformer:
+    if len(fns) == 1:
+        return fns[0]
+    return MultiTransformer(fns)
+
+
+class MultiTransformer(Transformer):
+    def __init__(self, transformers: List[Transformer]):
+        super().__init__()
+        self.transformers = transformers
+
+    def __repr__(self) -> str:
+        pipeline = " | ".join(type(t).__name__ for t in self.transformers)
+        return f"<{pipeline}>"
+
+    def do(self, x):
+        for t in self.transformers:
+            x = t(x)
+        return x
+
+    def _prepare(self):
+        for t in self.transformers:
+            t.__enter__()
+        return self
+
+    def __exit__(self, *args):
+        for t in self.transformers:
+            t.__exit__(*args)
+
+    def summary(self):
+        return itertools.chain(*(t.summary() for t in self.transformers))
+
+
+class Mapper(Transformer):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def do(self, x):
+        return self.fn(x)
+
+
+def run_pipe(
+    command,
+    kwargs: dict = None,
+    file: ReadableFileLike = None,
+    output: WritableFileLike = None,
+):
+    kwargs = kwargs or {}
+    if isinstance(kwargs, argparse.ArgumentParser):
+        kwargs = vars(kwargs.parse_args())
+    file = file or Path(kwargs.pop("file", "-"))
+    output = output or Path(kwargs.pop("output", "-"))
+
+    return run_pipes(as_pipe(command, kwargs), file=file, output=output)
+
+
+def run_pipes(
+    *fns: Union[Transformer, Callable[[Iterable], Iterable]],
+    inputs: Iterable[dict] = None,
+    file: ReadableFileLike = None,
+    output: WritableFileLike = None,
+    processes: int = 1,
+    chunksize: int = 10_000,
+):
+    """
+    Run full document processing pipeline.
+
+    - fns: list of functions to run over the documents. Can be:
+        * `Iterable -> Iterable` function
+        * jsonql.Transformer instance
+        Using transformers allow the pipeline to process documents in parallel.
+    - inputs: iterable to read the documents from
+    - file: if inputs is not given, will read documents from this file.
+    - output: writable file like.
+    - processes: number of processes to use. -1 means all CPU available.
+    - chunksize: chunksize for multiprocessing.Pool.imap_unordered
+    """
+    expect_json = len(fns) and isinstance(fns[0], Transformer) and fns[0].expect_json
+    if expect_json and inputs is None:
+        fns = (JsonReader(),) + fns
+    transformers = []
+    for t in fns:
+        if not isinstance(t, Transformer):
+            break
+        if not t.parallelisable:
+            break
+        transformers.append(t)
+    pipes = fns[len(transformers) :]
+
+    log = logging.getLogger(__name__).info
+    if inputs is None:
+        data: Iterable = open_read(file)
+    else:
+        data = inputs
+
+    if processes == -1:
+        processes = os.cpu_count() or 0
+
+    with contextlib.suppress(BrokenPipeError), contextlib.ExitStack() as stack:
+        if transformers:
+            log(f"preparing {transformers}")
+            transform = stack.enter_context(compose(transformers))
+            if processes <= 1:
+                data = transform.map(data)
+            else:
+                p = multiprocessing.current_process()
+                log(f"Will start {processes} processes from {p.name}, Pid: {p.pid}")
+                pool = stack.enter_context(
+                    multiprocessing.Pool(
+                        processes=processes,
+                        initializer=_set_global_transformer,
+                        initargs=(transform,),
+                    )
+                )
+                data = pool.imap_unordered(
+                    _global_transformer, data, chunksize=chunksize
+                )
+
+        for fn in pipes:
+            if isinstance(fn, Transformer):
+                data = fn.map(data)
+            else:
+                data = fn(data)
+
+        write_jsons(data, output)
+
+
+# Allows to share transformer acroos subprocess.
+# Used by `run_pipes`
+_GLOBAL_TRANSFORMER: Optional[Transformer] = None
+
+
+def _set_global_transformer(transformer: Transformer):
+    global _GLOBAL_TRANSFORMER
+    p = multiprocessing.current_process()
+    logging.info(
+        f"Started subprocess {p.name}:{p.pid} from {os.getppid()} for {transformer}"
+    )
+    assert transformer.ready, f"{transformer} isn't ready"
+    _GLOBAL_TRANSFORMER = transformer
+
+
+def _global_transformer(document: str) -> Optional[dict]:
+    assert _GLOBAL_TRANSFORMER is not None
+    return _GLOBAL_TRANSFORMER(document)
+
+
+def lines(file: ReadableFileLike) -> Iterator[str]:
+    return (line.strip("\n") for line in open_read(file))
+
+
+def read_jsons(file: ReadableFileLike, strict=False) -> Iterator[dict]:
+    reader = JsonReader(strict=strict)
+    lines = open_read(file)
+    for line in lines:
+        if line is None:
+            continue
+        yield reader(line)
+
+    reader.log_summary()
+
+
+def write_jsons(source: Iterable[dict], file: WritableFileLike) -> None:
+    eol = os.linesep
+    with open_write(file) as o:
+        for res in source:
+            if res is None:
+                continue
+            if isinstance(res, dict):
+                json.dump(res, o, ensure_ascii=False)
+                o.write(eol)
+                continue
+            if isinstance(res, str):
+                res = res.rstrip("\n")
+            print(res, file=o)
+
+
+class JsonReader(Transformer):
+    def __init__(self, strict: bool = False):
+        super().__init__()
+        self.ready = True
+        self.strict = strict
+        self.num_errors = 0
+
+    def do(self, line: str) -> Optional[dict]:
+        if line is None:
+            return None
+        if isinstance(line, dict):
+            return line
+        line = line.rstrip("\n")
+        if not line:
+            return None
+        try:
+            return json.loads(line)
+        except json.decoder.JSONDecodeError as e:
+            self.log_error(e)
+            if self.strict:
+                raise
+            return None
+
+    def log_error(self, e: json.decoder.JSONDecodeError):
+        self.num_errors += 1
+        if self.num_errors > 10:
+            return
+
+        MAX_LEN = 80
+        snippet, snippet_len = e.doc, len(e.doc)
+        col = e.pos
+        if snippet_len > MAX_LEN:
+            if col < MAX_LEN:
+                start = 0
+            elif snippet_len - col < MAX_LEN:
+                start = snippet_len - MAX_LEN
+            else:
+                start = col - MAX_LEN // 2
+            snippet = e.doc[start : start + MAX_LEN]
+            col = col - start
+        logging.warning(
+            "\n".join(
+                [
+                    f"Invalid json (length={len(e.doc)}) {e}",
+                    snippet,
+                    " " * (col - 1) + "^",
+                ]
+            )
+        )
+
+    def summary(self):
+        summ = super().summary()
+        if self.num_errors > 0:
+            summ.append(f"Skipped {self.num_errors} invalid json.")
+        return summ
+
+
+def compile_column(column, newline):
+    if callable(column):
+        return column
+
+    if column == "*":
+        return json.dumps
+
+    if re.match(r"[_a-z][_a-z0-9]*", column):
+
+        def extract_col(doc):
+            v = doc.get(column, "")
+            if isinstance(v, str) and newline != "\n":
+                v = v.rstrip("\n").replace("\n", newline)
+            return v
+
+        return extract_col
+
+    return compile_expr(column)
+
+
+def select(lines, columns, skip_empty=False, separator="\t", newline="\n"):
+    """Yields the content of the requested columns."""
+    column_parsers = [compile_column(c, newline) for c in columns]
+    for doc in read_jsons(lines):
+        values = []
+        empty = True
+        for parse_col in column_parsers:
+            v = parse_col(doc)
+            values.append(str(v) or "")
+            empty = empty and v is None
+
+        if skip_empty and empty:
+            continue
+
+        yield separator.join(values)
+
+
+def compile_expr(clause: Union[str, FilterFn], requires: List[str] = None):
+    if not isinstance(clause, str):
+        return clause
+
+    args_re = r"(?i:\{([_a-z][_a-z0-9]*)\})"
+    args_list = list(re.findall(args_re, clause))
+    if not args_list:
+        # This is only a warning because you may want to have eg random sampling
+        # that doesn't depend on the document.
+        logging.warn(
+            f"Warning: No variable found in expression: <{clause}>\n"
+            "Variables should be written inside braces, eg: {language}=='en'"
+        )
+    python_like = re.sub(args_re, r"doc.get('\1', None)", clause)
+    requires = requires or []
+    modules = {r: importlib.import_module(r) for r in requires}
+    return eval(f"lambda doc: {python_like}", modules)
+
+
+class where(Transformer):
+    """Filters the data using python code.
+
+    Ex: `jsonql where 'len({text}) > 100'`
+    """
+
+    def __init__(
+        self, clauses: Sequence[Union[str, FilterFn]], requires: List[str] = []
+    ):
+        super().__init__()
+        self.raw_clauses = clauses
+        self.requires = requires
+        self.n_selected = 0
+        self.clauses: List[FilterFn] = []
+
+    def _prepare(self):
+        self.clauses = [compile_expr(c, self.requires) for c in self.raw_clauses]
+
+    def do(self, doc: dict) -> Optional[dict]:
+        assert self.clauses
+        if not doc or not all((c(doc) for c in self.clauses)):
+            return None
+        self.n_selected += 1
+        return doc
+
+    def summary(self):
+        n_selected, n_docs = self.n_selected, self.processed
+        selectivity = n_selected / n_docs if n_docs else 0
+        return [f"Selected {n_selected} documents out of {n_docs} ({selectivity:5.1%})"]
+
+
+def merge(lines, columns, separator="\t", newline=NEWLINE):
+    """Reads tab separated columns and output a json using the given headers.
+
+    Headers are of form {key}[%{type}]
+    {type} can be one of {"f": float, "i": int, "b": bool, "s": string}.
+    Default type is string.
+    A special header "_" means interpret this column as json, and append all other
+    columns to it. Must appear only once and on last position.
+
+    Ex:
+    `echo '1\thello' | jsonql merge n t` --> `{"n": "1", "t": "hello"}`
+    `echo '1\thello" | jsonql merge n%i t` --> `{"n": 1, "t": "hello"}`
+    `echo '1\thello\t{"f": "bar"}' | jsonql merge n%i t _` --> `{"n": 1, "t": "hello", "f": "bar"}`
+    """
+    handle_newlines = lambda s: s.replace(newline, "\n")
+    type_mapping: Dict[str, Callable] = {
+        "f": float,
+        "i": int,
+        "b": bool,
+        "s": handle_newlines,
+    }
+    type_parsing = [
+        type_mapping.get(f.split("%")[-1], handle_newlines) for f in columns
+    ]
+    columns = [f.split("%")[0] for f in columns]
+    doc_index = columns.index("_") if "_" in columns else -1
+    read_json = JsonReader()
+
+    def parse(line):
+        parts = line.split(separator, len(columns) - 1)
+        doc: Dict[str, tp.Any] = {}
+        for i, value in enumerate(parts):
+            if columns[i] == "_":
+                doc.update(read_json(parts[doc_index]))
+            else:
+                try:
+                    doc[columns[i]] = type_parsing[i](value)
+                except ValueError:
+                    logging.error(
+                        f"Error when parsing column {i} of line: {line[:100]}..."
+                    )
+        return doc
+
+    for line in lines:
+        yield json.dumps(parse(line))
+
+
+class split(Transformer):
+    """Split a files in several smaller files based on the value of a field."""
+
+    # Not parallelisable since we are writing to files.
+    parallelisable = False
+
+    def __init__(
+        self,
+        pattern: Union[Path, str] = None,
+        split_fn: Callable[[dict], str] = None,
+        mkdir: bool = False,
+    ):
+        super().__init__()
+        assert not (
+            pattern and split_fn
+        ), "split can't have both a pattern and a split_fn"
+        if split_fn is not None:
+            self.split_fn = split_fn
+        else:
+            assert pattern, "split need either a pattern or a split_fn"
+            self.split_fn = self.make_split_fn(str(pattern))
+        self.mkdir = mkdir
+        self.o: dict = {}
+
+    def make_split_fn(self, pattern: str) -> Callable[[dict], str]:
+        candidates = list(re.findall(r"(?i:\{([_a-z][_a-z0-9]*)\})", pattern))
+        return lambda doc: pattern.format(**{c: doc[c] for c in candidates})
+
+    def do(self, doc):
+        filename = self.split_fn(doc)
+        if not filename:
+            return
+        o = self.o.get(filename, None)
+        if o is None:
+            if self.mkdir:
+                Path(filename).parent.mkdir(parents=True, exist_ok=True)
+            self.o[filename] = open_write(filename)
+        print(json.dumps(doc, ensure_ascii=False), file=self.o[filename], flush=True)
+
+    def summary(self):
+        summ = super().summary()
+        summ.append(f"Found {len(self.o)} splits.")
+        return summ
+
+    def close(self):
+        for file in self.o.values():
+            file.close()
+
+
+def histogram(values, bins, weights):
+    hist, bins = np.histogram(values, bins=bins)
+    # n_bins = len(hist)
+
+    if weights is not None:
+        # Bins can't be auto-determined if weights is supplied.
+        # So we first compute the bins without the weights then recompute
+        # the histogram with the weights.
+        hist, bins = np.histogram(values, bins=bins, weights=weights)
+    # cumsum = np.cumsum(hist)
+    # total = cumsum[-1]
+
+    # for i in range(n_bins - 1):
+    #     if cumsum[i] / total > 0.9:
+    #         useful_range = np.linspace(bins[0], bins[i + 1], n_bins)
+    #         new_bins = np.append(useful_range, [bins[-1]])
+    #         return np.histogram(values, bins=new_bins, weights=weights)
+
+    return hist, bins
+
+
+def _parse_bins(bins):
+    try:
+        if isinstance(bins, str):
+            if "," in bins:
+                bins = [int(b) for b in bins.split(",")]
+            else:
+                bins = int(bins)
+    except ValueError:
+        pass
+    return bins
+
+
+ALL_DOCUMENTS = "<ALL_DOCUMENTS>"
+MAX_LABEL_LEN = 100
+
+
+def bar_chart(hist, bins):
+    n = sum(hist)
+    max_h = max(hist)
+    out = []
+    for i, h in enumerate(hist):
+        h_size = 80 * h // max_h
+        dh_size = 80 * (h - hist[i - 1]) // max_h
+        if h_size == 0 or dh_size == 0:
+            continue
+        bar = "█" * h_size
+        out.append(f"{bins[i]:8.3f} {bar:80} ({h:5d}, {h / n:5.1%}) {bins[i+1]:8.3f}")
+    out.append(f"{bins[-1]:8.3f}")
+    return out
+
+
+def display_stats(stats, key, weights=None, bins="auto", cumulative=False):
+    out = []
+    documents = stats[ALL_DOCUMENTS]
+    count = stats.get(key, 0)
+    r = count / documents if documents else 0
+    out.append(f"Field {key} saw {count} times ({r:5.1%})")
+
+    length = stats.get(key + ".length", None)
+    avg_length = length // count if length else 0
+    if length is not None:
+        out[-1] += f", average length is {length // count}"
+
+    values = stats.get(key + ".val", None)
+    if values:
+        out[-1] += f", histogram is: (bins={bins})"
+        if weights:
+            if weights not in stats:
+                logging.warn(f"Warning: weights column {weights} not found.")
+            if weights + ".val" not in stats:
+                logging.warn(
+                    f"Warning: weights column {weights} is not a numeric column."
+                )
+            weights = stats.get(weights + ".val")
+        hist, bins = histogram(values, _parse_bins(bins), weights)
+        if cumulative:
+            hist = np.cumsum(hist)
+        out += bar_chart(hist, bins)
+
+    cnt = stats.get(key + ".cnt", None)
+    if avg_length < MAX_LABEL_LEN and cnt and max(cnt.values()) > 1:
+        cnt = sorted(cnt.items(), key=lambda kv: kv[1], reverse=True)
+        out[-1] += ", top 100 labels:"
+        for label, n in cnt[:100]:
+            if n < 5:
+                continue
+            out.append(f"{label:25}: {n:6} ({n / count:5.1%})")
+
+    return out
+
+
+def describe(source, columns=None, weights=None, **kwargs):
+    """Compute some statistics about a dataset.
+
+    Stats can be restricted to a subset of columns."""
+    MAX_HIST_SIZE = 100_000_000
+    MAX_CNT_SIZE = 1000
+    stats = {ALL_DOCUMENTS: 0}
+    needed = columns + [weights] if columns else None
+
+    for doc in read_jsons(source):
+        stats[ALL_DOCUMENTS] += 1
+        for k, v in doc.items():
+            if needed and k not in needed:
+                continue
+            stats[k] = get_or_set(stats, k, 0) + 1
+            if isinstance(v, str):
+                stats[k + ".length"] = get_or_set(stats, k + ".length", 0) + len(v)
+                if len(v) > MAX_LABEL_LEN:  # Don't treat too long string as labels
+                    continue
+                cnt = get_or_set(stats, k + ".cnt", collections.defaultdict(int))
+                if v in cnt or len(cnt) < MAX_CNT_SIZE:
+                    cnt[v] += 1
+            elif type(v) in (int, float):
+                values = get_or_set(stats, k + ".val", [])
+                if len(values) < MAX_HIST_SIZE:
+                    values.append(v)
+            elif type(v) is list and len(v) and type(v[0]) in (int, float):
+                values = get_or_set(stats, k + ".val", [])
+                if len(values) < MAX_HIST_SIZE:
+                    values += v
+            elif type(v) is dict:
+                cnt = get_or_set(stats, k + ".cnt", collections.defaultdict(int))
+                for label in v:
+                    if label in cnt or len(cnt) < MAX_CNT_SIZE:
+                        cnt[label] += 1
+
+    documents = stats[ALL_DOCUMENTS]
+    yield f"Stats computed on {documents} documents:"
+    for k in stats:
+        if columns and k not in columns:
+            continue
+        if "." in k or k == ALL_DOCUMENTS:
+            continue
+        for line in display_stats(stats, k, weights=weights, **kwargs):
+            yield line
+
+
+def shard(lines):
+    """Shard a file in several smaller ones."""
+    # The creation of the shard is handle in a generic way. Do we need this ?
+    return lines
+
+
+# *** Utils ***
+
+
+def get_or_set(dictionary, key, default):
+    if key not in dictionary:
+        dictionary[key] = default
+    return dictionary[key]
+
+
+class SimpleIO(Protocol):
+    """A subset of methods from TextIO."""
+
+    def close(self) -> None:
+        ...
+
+    def write(self, line: str) -> int:
+        ...
+
+    def __enter__(self) -> "SimpleIO":
+        ...
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        ...
+
+
+def open_read(filename: ReadableFileLike) -> Iterable[str]:
+    """Open the given file, list of files or files matching the given glob and read lines.
+
+    `filename` is None or "-" -> reads from stdin
+    `filename` is a Path / str -> interprets filename as a glob and open files matching it
+    `filename` is a list -> opens sequentially all files from the list using `open_read`
+    `filename` is something else -> returns the object wrapped in a `nullcontext`
+        This allows to pass already openened files or iterables.
+
+    `open_read` will decompress gzip files, given they have ".gz" suffix.
+    """
+    if filename is None:
+        return sys.stdin
+
+    if isinstance(filename, list):
+        assert isinstance(filename[0], Path)
+        if len(filename) == 0:
+            return []
+        if len(filename) > 1:
+            return _yield_from(filename)
+        filename = tp.cast(Path, filename[0])
+    if isinstance(filename, str):
+        if filename.startswith("http://") or filename.startswith("https://"):
+            return open_remote_file(filename)
+
+        filename = Path(filename)
+    if not isinstance(filename, Path):
+        # we might have received an iterable, return it unmodified.
+        return filename  # type: ignore
+
+    # Expand glob patterns only when reading
+    files = [Path(f) for f in sorted(glob.glob(str(filename)))]
+    if len(files) > 1:
+        return _yield_from(files)
+    if len(files) == 1:
+        filename = files[0]
+
+    assert isinstance(filename, Path)
+
+    if filename.name.endswith("]"):
+        return block_reader(filename)
+
+    logging.getLogger(__name__).info(f"Opening {filename} with mode 'rt'")
+    if filename.suffix == ".gz":
+        file: TextIO = gzip.open(filename, "rt")  # type: ignore
+    else:
+        file = open(filename, "rt")
+
+    return _close_when_exhausted(file)
+
+
+def _close_when_exhausted(file: TextIO) -> Iterable[str]:
+    with file:
+        yield from file
+
+
+def _yield_from(files: list) -> Iterable[str]:
+    for file in files:
+        yield from open_read(file)
+
+
+def open_write(
+    filename: WritableFileLike, max_size: str = "4G"
+) -> tp.ContextManager[TextIO]:
+    """Open the given file, list of files or files matching the given glob.
+
+    The return value is a ContextManager meant to be used inside a `with` block:
+    ```
+    with open_write("foo.txt") as o:
+        ...
+
+    Write mode:
+        replaces "?" from filename by numbers ranging from 0 to 9, generatings files of size `max_size`.
+        If filename ends with ".gz", creates a blocked gzip file with random access.
+    """
+    if filename is None:
+        return contextlib.nullcontext(sys.stdout)
+
+    if isinstance(filename, list):
+        if len(filename) > 1:
+            return MultiFile(filename, "w", max_size)
+        else:
+            filename = tp.cast(Path, filename[0])
+    if isinstance(filename, str):
+        filename = Path(filename)
+    if not isinstance(filename, Path):
+        assert hasattr(filename, "write"), f"{filename} doesn't have a .write method."
+        # We return a 'TextIO' even though we only check for `.write` method,
+        # this works better with eg `print`.
+        return contextlib.nullcontext(tp.cast(TextIO, filename))
+
+    mode = "wt"
+    if "?" in filename.name:
+        return sharded_file(filename, mode, max_size)
+
+    logging.getLogger(__name__).info(f"Opening {filename} with mode {mode}")
+    # TODO: should we use another format ?
+    if filename.suffix == ".gz":
+        return BlockedGzipWriter(Path(filename), mode, block_size="64M")
+
+    return open(filename, "wt")
+
+
+def parse_size(size):
+    unit_map = {"B": 1, "K": 1024, "M": 1024 ** 2, "G": 1024 ** 3}
+    unit = size[-1].upper()
+    assert (
+        unit in unit_map
+    ), f"Unsupported size unit for {size}. Use one of: {unit_map.keys()}."
+    return int(size[:-1]) * unit_map[unit]
+
+
+class MultiFile(SimpleIO):
+    def __init__(self, files: Iterable[Path], mode="w", max_size="4G"):
+        self.name = str(files)
+        self.mode = mode
+        self.files = iter(files)
+        self.max_size = parse_size(max_size)
+        self.current_handle: Optional[TextIO] = None
+        self.current_block_size = 0
+        self._open_next_handle()  # Opening 1st handle allows to write directly.
+
+    def write(self, content) -> int:
+        # Avoid splitting newlines to a new file.
+        # use current_block_size since it's faster than `tell()`
+        if content != "\n" and self.current_block_size >= self.max_size:
+            self._open_next_handle()
+        if self.current_handle is None:
+            raise Exception("No more files to write to...")
+
+        written = self.current_handle.write(content)
+        self.current_block_size += written
+        return written
+
+    def _open_next_handle(self) -> bool:
+        self.close()
+        file = next(self.files, None)
+        if file is None:
+            return False
+
+        self.current_handle = open_write(file).__enter__()
+        self.current_block_size = 0
+        return True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.close()
+
+    @property
+    def closed(self):
+        return self.current_handle is None
+
+    def close(self):
+        if self.current_handle is None:
+            return
+
+        # log("Closing", self.current_handle.name, "with mode", self.current_handle.mode)
+        self.current_handle.__exit__(None, None, None)
+        self.current_handle = None
+
+
+# not sure it helps since connections are reseted anyway.
+_session = functools.lru_cache()(requests.Session)
+
+
+def request_get_content(url: str, n_retry: int = 3) -> bytes:
+    """Retrieve the binary content at url.
+
+    Retry on connection errors.
+    """
+    t0 = time.time()
+    logging.info(f"Starting download of {url}")
+    for i in range(1, n_retry + 1):
+        try:
+            r = _session().get(url)
+            r.raise_for_status()
+            break
+        except requests.exceptions.RequestException as e:
+            # Sleep and try again on error, unless it's a 404.
+            message = e.args[0] if isinstance(e.args[0], str) else ""
+            if i == n_retry or "Client Error" in message:
+                raise e
+            warnings.warn(
+                f"Swallowed error {e} while downloading {url} ({i} out of {n_retry})"
+            )
+            time.sleep(10 * 2 ** i)
+    dl_time = time.time() - t0
+    dl_speed = len(r.content) / dl_time / 1024
+    logging.info(
+        f"Downloaded {url} [{r.status_code}] took {dl_time:.0f}s ({dl_speed:.1f}kB/s)"
+    )
+    return r.content
+
+
+def open_remote_file(url: str, cache: Path = None) -> Iterable[str]:
+    """Download the files at the given url to memory and opens it as a file.
+    Assumes that the file is small, and fetch it when this function is called.
+    """
+    if cache and cache.exists():
+        return open_read(cache)
+
+    # TODO: open the remote file in streaming mode.
+    # The hard part is that we need to write the content on disk at the same time,
+    # to implement disk caching.
+    raw_bytes = request_get_content(url)
+    content = io.BytesIO(raw_bytes)
+    if url.endswith(".gz"):
+        f: TextIO = gzip.open(content, mode="rt")  # type: ignore
+    else:
+        f = io.TextIOWrapper(content)
+
+    if cache and not cache.exists():
+        # The file might have been created while downloading/writing.
+        tmp_cache = _tmp(cache)
+        tmp_cache.write_bytes(raw_bytes)
+        if not cache.exists():
+            tmp_cache.replace(cache)
+        else:
+            tmp_cache.unlink()
+
+    return _close_when_exhausted(f)
+
+
+def sharded_file(file_pattern: Path, mode: str, max_size: str = "4G") -> MultiFile:
+    folder, name = file_pattern.parent, file_pattern.name
+    assert "?" in name, f"Can't expand give file_pattern: {file_pattern}"
+
+    n = name.count("?")
+    assert 0 < n < 8
+    assert "?" * n in name, f"The '?' need to be adjacents in {file_pattern}"
+    assert "r" not in mode
+    files = (folder / name.replace("?" * n, f"%0{n}d" % i) for i in range(10 ** n))
+
+    return MultiFile(files, mode, max_size)
+
+
+class SplitFile:
+    def __init__(self, filename: Path, chunk: int, n_chunks: int, mode: str = "r"):
+        assert mode == "r"
+        size = os.path.getsize(filename)
+        self.handle = open(filename, mode)
+        start = chunk * size // n_chunks
+        self.end: int = (chunk + 1) * size // n_chunks
+
+        if start > 0:
+            self.handle.seek(start - 1)
+            # Skip incomplete line. This avoid crashing when reading eg the middle
+            # of a unicode char. `self.handle.buffer` is a binary file reader.
+            self.handle.buffer.readline()  # type: ignore
+
+    def __enter__(self):
+        return self
+
+    def __iter__(self):
+        while True:
+            line = self.handle.readline()
+            if not line:
+                return
+
+            yield line
+            if self.handle.tell() >= self.end:
+                return
+
+    def readlines(self):
+        return list(self.__iter__())
+
+    def close(self):
+        self.handle.close()
+
+    def __exit__(self, *args):
+        self.close()
+
+
+def get_block_readers(filename: Path, n_readers, mode="t"):
+    index_filename = filename.parent / (filename.name + ".index")
+    if not index_filename.exists():
+        return [gzip.open(filename, "r" + mode)]
+    index: List[int] = np.load(index_filename)
+    n_chunks = len(index)
+    chunk_per_reader = int(np.ceil(n_chunks / n_readers))
+    n_readers = int(np.ceil(n_chunks / chunk_per_reader))
+
+    start = 0
+    readers = []
+    for i in range(n_readers):
+        end = index[min((i + 1) * chunk_per_reader - 1, n_chunks - 1)]
+        r = _blocked_gzip_reader(filename, start, end, mode)
+        readers.append(r)
+        start = end
+    return readers
+
+
+def block_reader(filename: Path) -> Iterable[str]:
+    root, pattern = str(filename)[:-1].split("[", 1)
+    assert root.endswith(".gz"), "Can only read block of a .gz file for now."
+
+    ii, nn = pattern.strip().split("/")
+    i, n_readers = int(ii), int(nn)
+
+    index_filename = root + ".index"
+    assert os.path.exists(
+        index_filename
+    ), f"Index {index_filename} not found for {filename}"
+    index: List[int] = np.load(index_filename)
+    n_chunks = len(index)
+    chunk_per_reader = int(np.ceil(n_chunks / n_readers))
+    n_readers = int(np.ceil(n_chunks / chunk_per_reader))
+    # I'm not sure how to handle the case where there is less reader than expected.
+    # Currently we return empty readers.
+
+    start = 0
+    if i > 0:
+        start = index[min((i - 1) * chunk_per_reader, n_chunks - 1)]
+    end = index[min(i * chunk_per_reader, n_chunks - 1)]
+    return _blocked_gzip_reader(root, start, end, mode="t")
+
+
+def _blocked_gzip_reader(filename, start, end, mode="t") -> Iterable[str]:
+    handle = gzip.open(filename, "r" + mode)
+    handle.seek(start)
+    try:
+        while handle.tell() < end:
+            line = handle.readline()
+            if not line:
+                break
+            yield line
+    finally:
+        handle.close()
+
+
+class BlockedGzipWriter(MultiFile):
+    """Writes a Gzip files which can be read by block.
+
+    Decreasing the block size may hurt compression, but provides more split points.
+    """
+
+    def __init__(self, filename: Path, mode: str, block_size: str = "256M"):
+        assert "w" in mode
+        self.filename = Path(filename)
+        self.index: List[int] = []
+        self.zipfile: Optional[gzip.GzipFile] = None
+        super().__init__([], mode, block_size)
+
+    def _open_next_handle(self) -> bool:
+        """Here we never actually close/open handles,
+        we just write the end of block sequence."""
+        if not self.current_handle:
+            mode = self.mode + "t"
+            self.current_handle = tp.cast(TextIO, gzip.open(self.filename, mode))
+            assert isinstance(self.current_handle.buffer, gzip.GzipFile)
+            self.zipfile = self.current_handle.buffer
+            return True
+
+        # Use Z_FULL_FLUSH to allow random access:
+        # https://github.com/madler/zlib/blob/cacf7f1d4e3d44d871b605da3b647f07d718623f/zlib.h#L313
+        self.current_handle.buffer.flush(zlib_mode=zlib.Z_FULL_FLUSH)  # type: ignore
+        self.index.append(self.current_handle.tell())
+        self.current_block_size = 0
+        return True
+
+    def flush(self):
+        assert self.current_handle is not None
+        self.current_handle.flush()
+
+    def close(self):
+        if self.current_handle is None:
+            return
+        self.current_handle.flush()
+        self.index.append(self.current_handle.tell())
+        self.current_handle.close()
+        self.current_handle = None
+        index = np.array(self.index, dtype=np.uint64)
+        with open(str(self.filename) + ".index", "wb") as o:
+            np.save(o, index)
+
+
+def grouper(iterable, n):
+    group = []
+    for x in iterable:
+        group.append(x)
+        if len(group) == n:
+            yield group
+            group = []
+    if group:
+        yield group
+
+
+PROCESS = psutil.Process()
+
+
+def mem_footprint_gb(pid=None):
+    rss = PROCESS.memory_info().rss
+    return rss / 1_000_000_000
+
+
+def _tmp(output: Path) -> Path:
+    suffix = "".join(output.suffixes)
+    suffix = ".tmp" + suffix
+    prefix = output.name[: -len(suffix)]
+    _, tmp_path = tempfile.mkstemp(dir=output.parent, prefix=prefix, suffix=suffix)
+    return Path(tmp_path)
+
+
+@functools.lru_cache()
+def _tmp_dir() -> Path:
+    job_id = os.environ.get("SLURM_JOB_ID")
+    if job_id:
+        return Path("/scratch/slurm_tmpdir") / job_id
+
+    checkpoint = Path("/checkpoint") / os.environ.get("USER", "")
+    if checkpoint.exists():
+        tmp = checkpoint / "tmp"
+        tmp.mkdir(exist_ok=True)
+        return tmp
+
+    return Path("/tmp")
+
+
+if __name__ == "__main__":
+    multiprocessing.set_start_method("fork")
+    main(sys.argv[1:])

cc-multilingual-main/cc_net/build/lib/cc_net/minify.py

@@ -0,0 +1,304 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import base64
+import hashlib
+import itertools
+import urllib.parse
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Union
+
+import numpy as np
+
+from cc_net import jsonql
+from cc_net.execution import get_executor
+from cc_net.jsonql import mem_footprint_gb
+
+HASH_SIZE = 4
+HASH_TYPE = np.uint32
+
+PUBLIC_FIELDS = ["url", "digest"]
+COMPUTED_FIELDS = ["cc_segment", "language", "language_score", "bucket", "perplexity"]
+DATA = Path(__file__).parent.parent / "data"
+
+
+# This is similar to dedup methods but with use 32 bits hashes.
+def _b2i(b: bytes) -> int:
+    return np.frombuffer(b[:HASH_SIZE], dtype=HASH_TYPE, count=1, offset=0).item(0)
+
+
+def _str_hash(s: str) -> int:
+    h = hashlib.sha1(bytes(s, encoding="utf-8"))
+    return _b2i(h.digest())
+
+
+def get_hashes(lines: Iterable[str]) -> List[bytes]:
+    h = HASH_SIZE
+    return [hashlib.sha1(bytes(l, encoding="utf-8")).digest()[:h] for l in lines]
+
+
+def encode_hashes(hashes: Iterable[bytes]) -> str:
+    return base64.b64encode(b"".join(hashes)).decode("ascii")
+
+
+def encode_as_hashes(lines: Iterable[str]) -> str:
+    return encode_hashes(get_hashes(lines))
+
+
+def decode_hashes(compact: str) -> List[bytes]:
+    all_hashes = base64.b64decode(compact)
+    res = []
+    assert len(all_hashes) % HASH_SIZE == 0
+    for i in range(len(all_hashes) // HASH_SIZE):
+        chunk = all_hashes[i * HASH_SIZE : (i + 1) * HASH_SIZE]
+        res.append(chunk)
+
+    return res
+
+
+def encode_line_ids(line_ids: Sequence[int]) -> str:
+    arr = np.array(line_ids, dtype="<u2")
+    return base64.b64encode(arr.tobytes()).decode("ascii")
+
+
+def decode_line_ids(compact: str) -> List[int]:
+    ids_bytes = bytearray(base64.b64decode(compact))
+    return np.ndarray(len(ids_bytes) // 2, dtype="<i2", buffer=ids_bytes)
+
+
+def get_doc_key(digest: str) -> int:
+    assert digest.startswith("sha1:")
+    h = base64.b32decode(digest[5:])
+    return _b2i(h[:HASH_SIZE])
+
+
+class Minifier(jsonql.Transformer):
+    ready = True
+
+    def __init__(self):
+        self.fields = frozenset(COMPUTED_FIELDS + PUBLIC_FIELDS)
+
+    def do(self, doc: dict) -> Optional[dict]:
+        line_ids: List[int] = doc.pop("line_ids")
+        fields = self.fields
+        keys = list(doc.keys())
+        for k in keys:
+            if k not in fields:
+                doc.pop(k, None)
+        p = doc.get("perplexity", 0)
+        doc["line_ids"] = encode_line_ids(line_ids)
+        if p:
+            doc["perplexity"] = round(p, 1)
+        s = doc.get("language_score", 0)
+        if s:
+            doc["language_score"] = round(s, 2)
+        return doc
+
+
+class MetadataFetcher(jsonql.Transformer):
+    """Reads documents from CC snapshot and join precomputed metadata.
+
+    CC snapshots are split in segments. Each segment is 64Mb long.
+    The metadata must also be stored in segments of the same size and names.
+    """
+
+    def __init__(self, folder: Union[Path, str]):
+        self.ready = True
+        self.metadata: Dict[int, dict] = {}
+
+        self._segments: Set[str] = set()
+        self.read_doc = 0
+        self.missed_doc = 0
+        self.missed_par = 0
+        self.processed_par = 0
+
+        if isinstance(folder, str):
+            # detect path passed as string
+            if urllib.parse.urlparse(folder).scheme == "":
+                folder = Path(folder)
+                assert folder.exists(), f"Metadata folder not found: {folder}"
+
+        self.folder = folder
+        self.segment: str = ""
+        self.segments_read_twice = 0
+
+    def meta_file(self, segment: str) -> str:
+        file_name = segment.split("/")[-1]
+        assert file_name.endswith(".warc.wet.gz") or file_name.endswith(".warc.wet")
+        if isinstance(self.folder, str):
+            return urllib.parse.urljoin(
+                self.folder, file_name.replace(".warc.wet", ".json")
+            )
+        meta_file = self.folder / file_name.replace(".warc.wet", ".json")
+        assert (
+            meta_file.exists()
+        ), f"Couldn't find metadata file for segment {segment} at {meta_file}"
+        return str(meta_file)
+
+    def fetch_metadata(self, segment: str) -> None:
+        meta_file = self.meta_file(segment)
+        k = get_doc_key
+        self.metadata = {}
+        collision = 0
+        for m in jsonql.read_jsons(meta_file):
+            key = k(m["digest"])
+            if key in self.metadata:
+                collision += 1
+            self.metadata[key] = m
+
+        self.log(f"Loaded {len(self.metadata)} metadatas from {meta_file}")
+        if collision > 0:
+            self._logger.warning(f"Found {collision} collisions !")
+
+        self.segment = segment
+        if segment in self._segments:
+            self.log("Cache miss")
+            self.segments_read_twice += 1
+        self._segments.add(segment)
+
+    def do(self, doc: dict) -> Optional[dict]:
+        if self.segment != doc["cc_segment"]:
+            self.fetch_metadata(doc["cc_segment"])
+        digest = doc["digest"]
+        key = get_doc_key(digest)
+        if key not in self.metadata:
+            return None
+
+        metadata = self.metadata.pop(key)
+        return self.clean(metadata, doc)
+
+    def clean(self, metadata: dict, full_doc: dict) -> Optional[dict]:
+        line_ids = decode_line_ids(metadata.pop("line_ids"))
+        lines = full_doc["raw_content"].split("\n")
+        cleaned = []
+        for l in line_ids:
+            if l >= len(lines) or l < 0:
+                self.missed_par += 1
+                continue
+            cleaned.append(lines[l])
+
+        self.processed_par += len(line_ids)
+        if not cleaned:
+            self.missed_doc += 1
+            return None
+
+        full_doc["raw_content"] = "\n".join(cleaned)
+        full_doc["original_nlines"] = full_doc["nlines"]
+        full_doc["original_length"] = full_doc["length"]
+        full_doc["nlines"] = len(cleaned)
+        full_doc["length"] = len(full_doc["raw_content"])
+        for key, value in metadata.items():
+            full_doc[key] = value
+        return full_doc
+
+    def summary(self) -> List[str]:
+        summ = super().summary()
+        mem = mem_footprint_gb()
+        len_cache = len(self.metadata)
+        summ.append(
+            f"Read {self.read_doc:_}, stocking {len_cache:_} doc in {mem:.1f}g."
+        )
+        if self.missed_doc:
+            r = self.missed_doc / self.processed
+            summ.append(f"! Missed {self.missed_doc} documents ({r:.1%}) !")
+
+        if self.missed_par:
+            r = self.missed_par / self.processed
+            summ.append(f"! Missed {self.missed_par} paragraphs ({r:.1%}) !")
+        return summ
+
+
+def _expand_files(files: List[Path]) -> List[Path]:
+    if len(files) == 1 and files[0].is_dir():
+        folder = files[0]
+        files = sorted(folder.glob("*.json.gz"))
+        print(f"Found {len(files)} files under {folder}/*.json.gz")
+    assert files, "No files found"
+    return files
+
+
+def minify_file(file: Path, output: Path) -> str:
+    """Minify the given file."""
+    jsonql.run_pipes(Minifier(), file=file, output=output)
+    return f"Minified {output}"
+
+
+def minify(
+    files: List[Path], output_dir: Path, execution: str = "mp", parallelism: int = -1
+):
+    """Minify all the files in the given folder."""
+    files = _expand_files(files)
+    output_dir.mkdir(exist_ok=True)
+    with open(output_dir / "files.txt", "w") as o:
+        for f in files:
+            print(f.name, file=o)
+    outputs = [output_dir / f.name for f in files]
+    ex = get_executor(
+        "minify",
+        output_dir / "logs",
+        execution,
+        timeout_hour=2,
+        cpus=1,
+        task_parallelism=parallelism,
+    )
+    ex(minify_file, files, outputs)
+
+
+def fetch_metadata_file(
+    file: Union[Path, str],
+    metadata_dir: Union[Path, str],
+    output: Path,
+    cache_dir: Path = None,
+):
+    unminifier = MetadataFetcher(metadata_dir)
+    tmp = output.with_name("tmp." + output.name)
+    jsonql.run_pipes(unminifier, file=file, output=tmp)
+    tmp.rename(output)
+    return f"Fetched metadata for {file}. Results at {output}."
+
+
+def fetch_metadata(
+    files: List[str],
+    metadata_dir: Union[Path, str],
+    output_dir: Path,
+    execution: str = "mp",
+    parallelism: int = -1,
+    cache_dir: Path = None,
+):
+    if len(files) == 1 and Path(files[0]).is_dir():
+        folder = Path(files[0])
+        files = [str(f) for f in sorted(folder.glob("*.json.gz"))]
+        print(f"Found {len(files)} files under {folder}/*.json.gz")
+
+    assert len(files) > 0, "No files given."
+    output_dir.mkdir(exist_ok=True)
+
+    outputs = [output_dir / str(f).split("/")[-1] for f in files]
+    if cache_dir is None:
+        cache_dir = output_dir / "wet_cache"
+        cache_dir.mkdir(exist_ok=True)
+    if str(cache_dir) == "none":
+        cache_dir = None
+    files = [f for f, o in zip(files, outputs) if not o.exists()]
+    outputs = [o for o in outputs if not o.exists()]
+    if not files:
+        return
+    ex = get_executor(
+        "unminify",
+        output_dir / "logs",
+        execution,
+        timeout_hour=8,
+        cpus=1,
+        task_parallelism=parallelism,
+        mem_gb=32,
+    )
+    ex(fetch_metadata_file, files, outputs, itertools.repeat(cache_dir))
+
+
+if __name__ == "__main__":
+    import func_argparse
+
+    func_argparse.main(minify_file, minify, fetch_metadata, fetch_metadata_file)

cc-multilingual-main/cc_net/build/lib/cc_net/split_by_lang.py

@@ -0,0 +1,151 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import argparse
+import collections
+from pathlib import Path
+from typing import Dict, Optional
+
+import fasttext  # type: ignore
+
+from cc_net import jsonql
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description="Read a list of json files and split them ",
+        parents=[jsonql.io_parser()],
+    )
+    parser.add_argument("--pattern", type=str)
+    parser.add_argument("--field", type=str, default="raw_content")
+    parser.add_argument("--threshold", type=float, default=0)
+    parser.add_argument("--model", type=str, required=True)
+    parser.add_argument("--out_field", type=str, default="language")
+    parser.add_argument("--top", type=int, default=1)
+    return vars(parser.parse_args())
+
+
+def predict(model, text: str, k: int = 1):
+    labels, scores = model.predict(text, k=k)
+    labels = [l.replace("__label__", "") for l in labels]
+    return labels, scores
+
+
+def avg_predict(model, text):
+    # Overall gives the same results than predict(model, text.replace("\n", ""))
+    text = text.split("\n")
+    text_len = sum(len(line) for line in text)
+    if text_len == 0:
+        return None, 0
+    scores = [predict(model, line) for line in text]
+    scores_by_label: Dict[str, float] = collections.defaultdict(float)
+    for (label, score), line in zip(scores, text):
+        scores_by_label[label] += score * len(line)
+
+    label, score = max(scores_by_label.items(), key=lambda kv: kv[1])
+    return label, score / text_len
+
+
+class Classifier(jsonql.Transformer):
+    def __init__(
+        self,
+        model: Path,
+        field: str,
+        out_field: str,
+        threshold: float = 0,
+        top: int = 1,
+        language: str = None,
+        rounding: int = 2,
+    ):
+        super().__init__()
+        self.model = model
+        assert model.exists(), f"Model {model} doesn't exist."
+        self.field = field
+        self.out_field = out_field
+        self.threshold = threshold
+        self.top = top
+        self.language = language
+        self.rounding = rounding
+        # Fasttext model is a C object and can't be pickled
+        self.fasttext_model: fasttext._FastText = None
+        self.n_doc, self.n_accepted, self.n_ignored, self.n_disagreement = 0, 0, 0, 0
+        self.cnt: Dict[str, int] = {}
+
+    def _prepare(self):
+        self.log(f"Loading {self.model}")
+        self.fasttext_model = fasttext.load_model(str(self.model))
+
+    def predict(self, text):
+        return predict(self.fasttext_model, text.replace("\n", ""), k=self.top)
+
+    def do(self, doc: dict) -> Optional[dict]:
+        text = doc.get(self.field, None)
+        if not text:
+            return None
+
+        if self.language and doc.get("language") != self.language:
+            self.n_ignored += 1
+            return doc
+
+        self.n_doc += 1
+        labels, scores = self.predict(text)
+        scores.round(self.rounding, out=scores)
+        for l in labels:
+            self.cnt[l] = self.cnt.get(l, 0) + 1
+
+        if self.top == 1:
+            existing_label = doc.get(self.out_field, None)
+            if existing_label and labels[0] != existing_label:
+                self.n_disagreement += 1
+
+        if all(s < self.threshold for s in scores):
+            return None
+
+        self.n_accepted += 1
+        if self.top == 1:
+            doc[self.out_field] = labels[0]
+            doc[self.out_field + "_score"] = scores[0]
+        else:
+            doc[self.out_field] = {l: s for l, s in zip(labels, scores)}
+        return doc
+
+    def summary(self):
+        n_doc, n_accepted, n_disagreement, cnt, out_field = (
+            self.n_doc,
+            self.n_accepted,
+            self.n_disagreement,
+            self.cnt,
+            self.out_field,
+        )
+        summ = super().summary()
+        if self.threshold > 0:
+            ratio = n_accepted / n_doc if n_doc else 0
+            summ.append(f"Kept {n_accepted} docs over {n_doc} ({ratio :.1%})")
+        summ.append(f"Found {len(cnt)} {out_field} labels: {cnt}")
+
+        disagreement = n_disagreement / n_doc if n_doc else 0
+        if disagreement:
+            summ.append(f"{out_field} disagreement is at {disagreement:.1%}.")
+        return summ
+
+    def __repr__(self):
+        return f"Classifier({self.model})"
+
+
+def classify_and_split(file, output, pattern, **kwargs):
+    classifier = Classifier(**kwargs)
+    splitter = jsonql.split(pattern)
+    jsonql.run_pipes(classifier, splitter, file=file, output=output)
+
+
+if __name__ == "__main__":
+    args = get_args()
+    pattern = args.get("pattern")
+    if pattern:
+        classify_and_split(**args)
+    else:
+        args.pop("pattern")
+        jsonql.run_pipe(Classifier, args)

cc-multilingual-main/cc_net/build/lib/cc_net/tokenizer.py

@@ -0,0 +1,79 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import time
+from typing import Dict, Optional
+
+import sacremoses  # type: ignore
+
+from cc_net import jsonql, text_normalizer
+
+
+class RobustTokenizer(jsonql.Transformer):
+    """Moses tokenizer with the expected preprocessing."""
+
+    LANG_WITHOUT_ACCENT = {"en", "my"}
+
+    def __init__(self, lang: str):
+        super().__init__()
+        self.lang = lang
+        self.moses = sacremoses.MosesTokenizer(lang)
+        self.rm_accent = lang in self.LANG_WITHOUT_ACCENT
+        self.ready = True
+
+    def do(self, text: str):
+        text = text_normalizer.normalize(
+            text, accent=self.rm_accent, case=False, numbers=False, punct=True
+        )
+        text = text_normalizer.normalize_spacing_for_tok(text, language=self.lang)
+        return self.moses.tokenize(text, return_str=True, escape=False)
+
+
+class DocTokenizer(jsonql.Transformer):
+    """Tokenize the text found in `output_field and store the result in `output_field`."""
+
+    def __init__(
+        self,
+        field: str,
+        output_field: str = "tokenized",
+        language_field: str = "language",
+    ):
+        super().__init__()
+        self.field = field
+        self.output_field = output_field
+        self.language_field = language_field
+        self.n_docs = 0
+        self.tokenizers: Dict[str, RobustTokenizer] = {}
+
+    def get_tokenizer(self, lang: str) -> Optional[RobustTokenizer]:
+        cache = self.tokenizers
+        if lang in cache:
+            return cache[lang]
+        if lang in ("th", "zh", "ja"):
+            # TODO find a tokenizer for those languages
+            return None
+
+        cache[lang] = RobustTokenizer(lang)
+        return cache[lang]
+
+    def do(self, document):
+        lang = document[self.language_field]
+        tok = self.get_tokenizer(lang)
+        if not tok:
+            return document
+
+        self.n_docs += 1
+        lines = document[self.field].split("\n")
+        tokenized = "\n".join(tok(l) for l in lines)
+        document[self.output_field] = tokenized
+        return document
+
+    def summary(self):
+        delay = (time.time() - self.start_time) / 3600
+        speed = self.n_docs / delay
+        return [
+            f"Tokenized {self.n_docs:_} documents in {delay:.2}h ({speed:.1} doc/s)."
+        ]

cc-multilingual-main/cc_net/cc_net/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#

cc-multilingual-main/cc_net/cc_net/__main__.py

@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+
+import func_argparse
+
+import cc_net.mine
+
+
+def main():
+    func_argparse.parse_and_call(cc_net.mine.get_main_parser())
+
+
+if __name__ == "__main__":
+    main()

cc-multilingual-main/cc_net/cc_net/data/cutoff.csv

@@ -0,0 +1,101 @@
+,de,it,fr,nl,pl,pt,es,no,da,id,lt,fi,en,hu,ro,ko,ar,bn,fa,ru,uk,ml,my,lv,is,ca,ne,et,hy,ja,hr,hi,az,el,cs,bg,he,zh,ka,km,gu,mk,kn,mr,af,mn,kk,be
+0,0,0,0,10,0,0,0,0,0,0,0,10,0,0,0,20,0,0,0,0,0,0,10,10,10,0,10,0,0,0,0,0,0,0,0,0,0,10,0,10,10,10,10,10,10,0,0,10
+1,150,100,70,170,50,70,70,170,160,210,70,400,160,30,70,20,100,70,110,70,40,480,550,430,410,80,330,470,210,400,290,190,130,210,270,120,400,600,230,410,510,190,730,460,130,240,50,170
+2,170,110,90,200,70,80,90,210,190,260,90,490,180,30,80,30,180,80,150,90,50,740,840,570,490,90,420,630,300,540,360,220,200,250,350,180,520,750,360,460,580,250,1020,630,190,300,110,250
+3,190,120,90,230,70,90,90,230,210,300,100,570,200,40,90,30,220,90,180,110,60,930,980,650,530,100,470,720,360,620,400,240,240,270,410,220,620,840,420,490,630,280,1170,720,220,330,150,300
+4,200,130,100,240,80,90,100,250,220,320,110,620,210,40,100,30,250,100,190,110,60,1080,1140,710,560,110,510,780,400,670,440,260,270,280,450,230,690,900,480,530,670,300,1280,790,260,360,190,340
+5,210,130,100,260,90,100,110,260,230,340,110,670,220,40,110,30,260,100,210,120,70,1210,1260,760,580,120,540,830,430,710,470,270,300,290,480,250,760,950,520,550,690,320,1370,840,290,380,210,370
+6,220,140,110,270,90,100,110,270,240,350,120,700,230,40,110,30,280,110,220,130,70,1310,1390,790,600,120,570,870,450,750,490,280,320,300,510,270,810,990,560,560,720,340,1440,880,310,400,240,390
+7,230,140,110,280,100,110,120,280,250,370,120,740,230,50,120,30,290,110,230,140,70,1400,1500,820,620,130,590,900,480,770,510,300,340,310,540,290,850,1030,580,570,740,350,1500,920,330,410,270,410
+8,230,150,110,290,100,110,120,290,260,380,130,770,240,50,120,40,310,120,240,140,80,1470,1590,840,640,130,610,930,500,800,530,310,360,320,560,300,880,1060,610,600,760,370,1550,950,350,430,280,430
+9,240,150,120,300,100,110,120,300,270,400,130,790,250,50,120,40,320,120,240,150,80,1540,1660,860,650,140,630,960,520,820,540,310,380,330,580,310,910,1090,630,610,780,380,1600,990,370,450,310,450
+10,250,160,120,310,110,120,130,310,270,410,140,810,250,50,130,40,330,130,250,150,90,1600,1740,880,660,140,650,980,530,840,550,320,390,340,600,320,940,1110,650,620,800,390,1640,1010,380,460,330,470
+11,250,160,120,310,110,120,130,310,280,420,140,830,260,50,130,60,340,130,260,150,90,1650,1810,900,680,150,660,1000,550,860,570,330,410,350,610,330,970,1140,670,640,820,400,1680,1040,390,480,350,480
+12,260,160,130,320,110,120,130,320,290,430,140,850,260,50,130,70,350,130,270,160,90,1700,1870,920,690,150,680,1020,570,880,580,340,420,350,630,340,990,1160,690,660,840,410,1720,1060,400,490,370,500
+13,270,170,130,330,120,130,140,330,290,440,150,870,270,60,140,80,360,140,270,160,90,1750,1930,930,700,150,690,1030,580,890,590,350,440,360,640,340,1010,1180,710,680,860,420,1760,1090,410,500,380,510
+14,270,170,130,340,120,130,140,340,300,450,150,890,270,60,140,110,370,140,280,170,100,1800,1990,950,710,160,700,1050,590,910,600,360,450,370,650,350,1030,1200,730,700,880,430,1790,1110,420,510,400,520
+15,280,170,140,340,120,130,140,340,300,460,150,900,280,60,140,110,380,140,290,170,100,1850,2040,960,720,160,720,1070,600,920,610,360,460,370,670,360,1050,1220,740,710,890,430,1820,1130,430,520,420,540
+16,280,180,140,350,120,130,140,350,310,470,160,920,280,60,150,120,380,150,290,170,100,1890,2080,980,730,160,730,1080,620,940,620,370,470,380,680,360,1070,1240,750,740,910,440,1850,1150,440,530,440,550
+17,290,180,140,360,130,140,150,350,320,480,160,940,280,60,150,120,390,150,300,180,110,1940,2120,990,740,170,740,1100,630,950,630,380,480,380,690,370,1090,1260,770,760,920,450,1880,1170,450,550,450,560
+18,300,180,150,360,130,140,150,360,320,490,160,950,290,60,150,160,400,150,300,180,110,1980,2170,1000,750,170,750,1110,640,970,640,390,490,390,700,380,1100,1270,780,770,940,460,1910,1190,450,560,470,570
+19,300,190,150,370,130,140,150,370,330,500,160,970,290,70,150,230,410,160,310,180,110,2030,2200,1010,760,170,760,1130,650,980,640,390,500,390,710,380,1120,1290,790,790,950,460,1940,1210,460,570,480,580
+20,310,190,150,370,130,140,150,370,330,510,170,980,300,70,160,330,420,160,310,180,110,2070,2240,1030,770,180,770,1140,660,990,650,400,510,400,720,390,1140,1310,800,810,970,470,1970,1220,470,580,490,590
+21,310,190,150,380,140,150,160,380,340,520,170,990,300,70,160,370,420,160,320,190,120,2110,2270,1040,770,180,780,1160,670,1010,660,410,520,400,740,400,1150,1320,820,830,980,480,1990,1240,480,590,510,600
+22,320,200,160,390,140,150,160,380,340,530,170,1010,300,70,160,450,430,170,330,190,120,2160,2300,1050,780,180,790,1170,670,1020,670,410,530,410,750,400,1170,1340,830,850,1000,480,2020,1260,490,600,520,610
+23,320,200,160,390,140,150,160,390,350,540,170,1020,310,70,160,600,440,170,330,190,120,2190,2340,1060,790,190,800,1180,680,1030,680,420,540,420,760,410,1180,1350,840,870,1010,490,2040,1270,490,610,530,620
+24,330,200,160,400,140,150,160,400,350,540,170,1030,310,70,170,670,450,170,340,200,130,2230,2360,1070,800,190,810,1190,690,1040,680,430,550,420,770,410,1200,1370,850,890,1020,500,2060,1290,500,620,550,630
+25,340,210,170,400,150,160,170,400,360,550,180,1050,320,80,170,740,460,170,340,200,130,2270,2390,1080,810,190,820,1210,700,1050,690,440,560,430,780,420,1210,1380,860,910,1040,500,2090,1300,510,630,560,640
+26,340,210,170,410,150,160,170,410,360,560,180,1060,320,80,170,790,460,180,350,200,130,2300,2420,1090,820,190,830,1220,710,1060,700,440,570,430,780,420,1220,1400,870,930,1050,510,2110,1320,510,640,570,640
+27,350,210,170,420,150,160,170,410,370,570,180,1070,320,80,170,840,470,180,350,200,130,2340,2450,1100,830,200,840,1230,720,1080,700,450,580,440,790,430,1240,1410,880,960,1070,510,2140,1330,520,650,580,650
+28,350,220,180,420,150,160,170,420,370,580,180,1090,330,80,180,840,480,180,360,210,140,2370,2470,1110,840,200,850,1240,730,1090,710,460,580,440,800,440,1250,1430,890,990,1080,520,2160,1350,530,660,590,660
+29,360,220,180,430,160,160,180,430,380,590,190,1100,330,80,180,890,490,190,370,210,140,2400,2500,1120,850,200,860,1250,740,1100,720,470,590,450,810,440,1270,1440,900,1010,1100,520,2180,1370,530,670,600,670
+30,370,220,180,430,160,170,180,430,380,600,190,1110,340,80,180,920,490,190,370,210,140,2430,2530,1130,850,210,860,1270,750,1110,720,480,600,450,820,450,1280,1460,910,1040,1110,530,2210,1380,540,680,610,670
+31,370,230,190,440,160,170,180,440,390,610,190,1120,340,80,180,920,500,190,380,220,140,2470,2550,1140,860,210,870,1280,750,1120,730,480,610,460,830,460,1290,1470,920,1070,1120,540,2230,1400,550,690,620,680
+32,380,230,190,450,160,170,180,440,390,620,190,1140,350,90,180,920,510,200,390,220,150,2510,2570,1150,870,210,880,1290,760,1130,740,490,620,460,840,460,1310,1490,930,1100,1140,540,2250,1410,550,700,630,690
+33,380,230,190,450,170,170,190,450,400,630,190,1150,350,90,190,940,520,200,390,220,150,2540,2590,1160,880,220,890,1300,770,1140,740,500,630,470,850,470,1320,1500,940,1120,1150,550,2270,1430,560,710,650,700
+34,390,240,200,460,170,180,190,460,410,640,200,1160,350,90,190,940,530,200,400,220,150,2570,2610,1170,890,220,900,1310,780,1150,750,510,640,470,860,470,1330,1520,960,1150,1160,550,2290,1440,570,720,660,700
+35,400,240,200,460,170,180,190,460,410,640,200,1170,360,90,190,940,530,210,410,230,150,2590,2630,1180,900,220,910,1320,790,1160,760,520,650,480,870,480,1350,1530,970,1180,1180,560,2310,1460,580,730,670,710
+36,400,240,200,470,170,180,190,470,420,660,200,1180,360,90,190,1010,540,210,410,230,160,2620,2650,1190,910,230,920,1330,800,1170,760,520,660,480,880,490,1360,1540,980,1210,1190,560,2330,1470,580,740,680,720
+37,410,250,210,480,180,190,200,480,420,670,200,1200,370,90,200,1010,550,210,420,230,160,2650,2660,1200,920,230,930,1340,810,1180,770,530,670,490,890,490,1370,1560,990,1240,1200,570,2350,1490,590,750,690,730
+38,410,250,210,480,180,190,200,480,430,680,210,1210,370,100,200,1020,560,210,430,230,160,2680,2680,1210,930,230,930,1350,820,1190,770,540,680,500,900,500,1390,1570,1000,1270,1220,580,2370,1500,600,760,700,730
+39,420,260,210,490,180,190,200,490,440,690,210,1220,380,100,200,1020,570,220,440,240,160,2710,2700,1220,930,240,940,1360,830,1200,780,550,690,500,910,510,1400,1590,1010,1300,1230,580,2390,1520,600,770,710,740
+40,430,260,220,490,190,190,210,500,440,700,210,1230,380,100,200,1020,570,220,440,240,170,2740,2720,1240,940,240,950,1370,840,1210,790,560,700,510,920,510,1410,1610,1020,1330,1250,590,2410,1540,610,780,720,750
+41,430,260,220,500,190,200,210,500,450,710,210,1240,390,100,210,1050,580,220,450,240,170,2770,2740,1250,950,240,960,1380,850,1230,790,570,710,510,930,520,1430,1620,1030,1360,1260,600,2430,1550,620,790,730,760
+42,440,270,220,510,190,200,210,510,450,720,210,1260,390,100,210,1050,590,230,460,250,170,2800,2760,1260,960,250,970,1390,860,1240,800,580,720,520,940,530,1440,1640,1040,1400,1270,600,2450,1570,630,800,740,770
+43,450,270,230,510,190,200,220,520,460,730,220,1270,400,110,210,1050,600,230,470,250,170,2820,2770,1270,970,250,980,1410,860,1250,800,590,730,530,940,530,1450,1650,1050,1430,1290,610,2470,1580,630,810,750,770
+44,450,280,230,520,200,210,220,530,470,740,220,1280,400,110,220,1050,610,230,480,250,180,2840,2790,1280,980,250,980,1420,870,1260,810,600,740,530,950,540,1470,1670,1070,1470,1300,610,2490,1600,640,820,750,780
+45,460,280,240,530,200,210,220,530,480,750,220,1290,410,110,220,1180,620,240,490,260,180,2870,2800,1290,990,260,990,1430,890,1270,820,610,760,540,970,550,1480,1690,1080,1510,1320,620,2510,1610,650,830,770,790
+46,470,280,240,530,200,210,230,540,480,760,220,1310,420,110,220,1180,630,240,500,260,180,2900,2820,1300,1000,260,1000,1440,900,1280,820,620,770,550,980,550,1500,1700,1090,1550,1330,630,2530,1630,650,840,780,790
+47,470,290,250,540,210,220,230,550,490,780,230,1320,420,110,220,1260,640,250,510,260,180,2930,2840,1310,1010,270,1010,1450,910,1290,830,630,780,550,990,560,1510,1720,1100,1580,1350,630,2540,1640,660,850,790,800
+48,480,290,250,550,210,220,230,560,500,790,230,1330,430,120,230,1410,650,250,520,270,190,2950,2850,1320,1020,270,1020,1460,920,1300,840,640,790,560,1000,570,1530,1740,1120,1620,1360,640,2570,1660,670,860,800,810
+49,490,300,260,560,210,220,240,570,500,800,230,1340,440,120,230,1430,660,250,530,270,190,2970,2870,1330,1030,270,1030,1470,930,1310,840,650,800,570,1010,580,1540,1750,1130,1650,1370,650,2580,1670,680,880,810,820
+50,500,300,260,560,220,230,240,570,510,810,230,1360,440,120,230,1540,670,260,550,270,190,3000,2880,1350,1050,280,1040,1480,940,1330,850,660,820,580,1020,590,1560,1770,1140,1690,1390,660,2600,1690,680,890,820,830
+51,500,310,270,570,220,230,250,580,520,830,240,1370,450,120,240,1560,680,260,560,280,200,3020,2900,1360,1060,280,1050,1500,950,1340,850,670,830,580,1030,600,1570,1790,1160,1730,1410,660,2620,1710,690,900,830,830
+52,510,310,270,580,220,230,250,590,530,840,240,1380,460,120,240,1610,690,270,570,280,200,3040,2910,1370,1070,290,1050,1510,970,1350,860,680,840,590,1040,600,1590,1810,1180,1780,1420,670,2640,1720,700,910,840,840
+53,520,320,280,590,230,240,250,600,540,850,240,1400,460,130,240,1700,700,270,580,280,200,3070,2930,1390,1090,290,1060,1520,980,1360,870,700,850,600,1050,610,1600,1830,1190,1820,1440,680,2660,1740,710,920,850,850
+54,530,320,280,590,230,240,260,610,550,870,250,1410,470,130,250,1730,710,280,600,290,200,3090,2940,1400,1100,300,1070,1540,990,1370,870,710,870,610,1060,620,1610,1840,1210,1870,1460,690,2680,1760,710,930,860,860
+55,540,330,290,600,240,250,260,620,560,880,250,1430,480,130,250,1800,720,280,620,290,210,3110,2960,1410,1120,300,1080,1550,1000,1380,880,720,880,620,1080,630,1630,1860,1220,1910,1480,700,2700,1780,720,950,870,860
+56,550,340,300,610,240,250,270,630,560,900,250,1440,490,130,250,1850,730,280,630,300,210,3130,2980,1430,1130,300,1090,1560,1020,1400,890,740,890,630,1090,640,1650,1880,1240,1960,1490,700,2720,1790,730,960,880,870
+57,560,340,300,620,240,260,270,640,570,910,250,1450,500,140,260,1950,750,290,650,300,210,3150,2990,1440,1150,310,1100,1580,1030,1410,890,750,900,640,1100,650,1660,1900,1260,2020,1510,710,2740,1810,740,970,900,880
+58,570,350,310,630,250,260,280,660,580,930,260,1470,510,140,260,1950,760,290,670,300,220,3170,3010,1450,1160,310,1110,1590,1050,1420,900,760,920,650,1110,660,1680,1920,1270,2070,1530,720,2760,1830,750,990,910,890
+59,580,350,320,640,250,260,280,670,590,950,260,1480,510,140,260,2040,770,300,680,310,220,3200,3020,1470,1170,320,1120,1600,1060,1440,910,780,930,660,1130,670,1700,1940,1290,2130,1550,730,2780,1850,760,1000,920,900
+60,590,360,330,650,260,270,290,680,600,970,270,1500,520,140,270,2130,790,300,700,310,220,3220,3040,1480,1190,330,1130,1620,1080,1450,910,790,950,670,1140,680,1710,1950,1310,2180,1570,740,2800,1870,770,1010,930,910
+61,600,370,340,660,260,270,290,690,620,980,270,1510,530,150,270,2210,800,310,720,320,230,3240,3050,1500,1210,330,1140,1630,1090,1460,920,810,960,680,1160,690,1730,1970,1330,2230,1580,750,2820,1890,780,1030,940,920
+62,610,370,340,670,270,280,300,710,630,1000,270,1530,550,150,280,2280,810,320,740,320,230,3260,3060,1510,1220,340,1160,1650,1110,1470,930,830,980,690,1170,700,1750,2000,1350,2290,1600,760,2840,1920,790,1040,950,920
+63,620,380,350,680,270,290,300,720,640,1020,280,1550,560,150,280,2290,830,320,770,330,230,3280,3080,1530,1240,340,1170,1660,1130,1490,930,840,990,700,1190,720,1770,2020,1370,2350,1620,770,2860,1940,800,1060,970,930
+64,630,390,360,690,280,290,310,730,650,1040,280,1560,570,160,290,2310,850,330,790,330,240,3300,3090,1540,1260,350,1180,1680,1150,1500,940,860,1010,720,1200,730,1790,2040,1400,2400,1650,780,2880,1960,810,1080,980,950
+65,640,400,370,700,280,300,320,750,670,1060,280,1580,580,160,290,2380,860,330,810,340,240,3320,3110,1560,1280,360,1190,1690,1170,1520,950,880,1020,730,1220,740,1810,2060,1420,2460,1670,790,2900,1990,820,1100,990,950
+66,660,410,380,710,290,300,320,770,680,1090,290,1600,600,160,300,2400,880,340,840,340,240,3340,3120,1580,1310,360,1200,1710,1190,1530,960,900,1030,740,1230,750,1830,2090,1450,2510,1690,810,2920,2010,830,1120,1010,960
+67,670,410,400,730,300,310,330,780,690,1110,290,1620,610,170,300,2420,900,350,870,350,250,3360,3140,1600,1330,370,1210,1730,1210,1550,960,920,1050,760,1250,770,1850,2120,1480,2570,1710,820,2950,2030,840,1130,1020,970
+68,680,420,410,740,300,320,340,800,710,1130,300,1640,630,170,310,2450,920,360,890,350,250,3380,3150,1620,1350,380,1230,1740,1230,1570,970,940,1070,770,1270,780,1870,2140,1510,2620,1740,830,2970,2050,850,1150,1030,980
+69,700,430,420,750,310,320,340,820,720,1150,300,1650,640,170,310,2490,940,360,920,360,260,3400,3170,1640,1380,390,1240,1760,1250,1580,980,960,1080,790,1290,790,1890,2170,1540,2670,1760,850,2990,2080,870,1180,1050,990
+70,710,440,430,770,320,330,350,840,740,1180,310,1670,660,180,320,2500,960,370,950,370,260,3420,3190,1660,1400,400,1250,1780,1270,1600,990,980,1100,800,1300,810,1910,2200,1570,2710,1790,860,3010,2100,880,1200,1060,1000
+71,730,460,450,780,320,340,360,860,760,1200,310,1690,680,180,320,2570,980,380,980,370,270,3440,3210,1680,1430,400,1270,1800,1290,1620,990,1010,1120,820,1320,830,1940,2230,1600,2760,1810,880,3030,2130,890,1220,1080,1010
+72,740,470,460,800,330,350,370,890,770,1230,320,1710,700,190,330,2660,1000,390,1010,380,270,3460,3220,1700,1460,410,1280,1820,1320,1640,1000,1030,1140,840,1340,840,1960,2260,1640,2810,1840,890,3060,2160,900,1250,1100,1030
+73,760,480,480,810,340,350,380,910,790,1260,330,1740,720,190,340,2730,1030,400,1050,390,280,3480,3240,1730,1490,420,1300,1840,1340,1660,1010,1060,1170,860,1360,860,1990,2290,1670,2860,1870,910,3080,2190,920,1270,1110,1040
+74,780,500,500,830,350,360,390,940,810,1290,330,1760,740,200,340,2850,1050,410,1080,400,280,3500,3260,1750,1520,430,1320,1860,1360,1680,1020,1080,1190,880,1390,880,2010,2320,1710,2900,1900,930,3110,2220,930,1300,1130,1050
+75,800,510,520,850,360,370,400,970,830,1320,340,1780,770,200,350,2930,1070,420,1110,400,290,3520,3280,1780,1560,440,1330,1880,1390,1710,1030,1110,1220,900,1410,900,2030,2350,1760,2940,1930,950,3130,2250,950,1330,1150,1060
+76,820,530,530,870,370,380,410,1000,860,1350,350,1810,800,210,360,2980,1100,440,1150,410,290,3540,3290,1800,1600,460,1350,1900,1420,1730,1040,1150,1240,920,1430,920,2060,2390,1800,2980,1940,970,3160,2280,970,1360,1170,1070
+77,840,550,550,890,380,390,430,1030,880,1380,350,1830,830,210,360,2990,1130,450,1190,420,300,3560,3310,1830,1630,470,1370,1930,1450,1750,1060,1180,1260,950,1460,940,2090,2420,1850,3020,1980,990,3190,2320,980,1400,1190,1090
+78,860,570,570,910,390,400,440,1070,910,1420,360,1860,860,220,370,3080,1160,470,1230,430,310,3580,3330,1860,1670,480,1390,1950,1480,1780,1070,1220,1290,970,1490,960,2120,2460,1900,3060,2010,1010,3210,2350,1000,1430,1210,1100
+79,890,590,600,930,400,410,450,1110,940,1460,370,1880,890,220,380,3170,1200,480,1270,440,310,3600,3350,1890,1720,500,1400,1980,1510,1810,1080,1260,1320,1000,1520,990,2150,2500,1950,3100,2050,1030,3240,2390,1030,1470,1230,1120
+80,920,620,630,960,410,420,470,1150,970,1500,380,1910,930,230,390,3210,1230,500,1320,450,320,3620,3370,1920,1760,510,1430,2010,1540,1830,1090,1300,1350,1030,1550,1010,2180,2540,2020,3140,2100,1060,3260,2420,1050,1510,1250,1130
+81,950,640,660,990,430,440,480,1200,1000,1540,390,1940,970,240,410,3290,1260,520,1370,460,330,3640,3390,1960,1810,520,1450,2040,1580,1860,1110,1340,1390,1060,1580,1040,2220,2590,2080,3180,2140,1090,3290,2460,1070,1540,1280,1150
+82,980,670,700,1010,440,450,500,1260,1030,1580,400,1980,1010,250,420,3370,1300,540,1430,480,340,3660,3410,1990,1860,540,1470,2070,1610,1890,1120,1390,1430,1100,1620,1070,2250,2630,2160,3230,2190,1120,3320,2500,1100,1590,1310,1170
+83,1010,710,740,1050,450,460,520,1320,1070,1630,410,2010,1060,260,430,3420,1340,570,1490,490,350,3680,3430,2030,1920,560,1500,2110,1640,1930,1140,1440,1470,1130,1650,1100,2290,2680,2230,3260,2240,1150,3350,2540,1130,1640,1340,1190
+84,1050,750,780,1080,470,480,540,1390,1110,1690,420,2050,1110,260,450,3460,1390,590,1550,510,360,3690,3460,2080,1990,580,1530,2150,1680,1960,1150,1490,1520,1170,1690,1140,2330,2730,2320,3310,2290,1190,3380,2590,1170,1690,1370,1210
+85,1100,800,830,1120,490,500,560,1470,1160,1740,440,2090,1170,270,470,3540,1440,630,1620,520,370,3710,3480,2120,2060,600,1560,2190,1730,2000,1170,1550,1570,1220,1740,1180,2370,2780,2420,3350,2350,1230,3410,2600,1200,1740,1400,1220
+86,1150,860,890,1170,500,520,590,1560,1210,1810,450,2130,1230,280,490,3620,1490,660,1680,540,390,3730,3510,2170,2140,630,1600,2230,1770,2040,1190,1620,1630,1260,1780,1220,2410,2830,2550,3390,2410,1280,3440,2660,1240,1790,1450,1250
+87,1200,930,960,1210,520,540,630,1660,1270,1870,460,2180,1300,300,510,3670,1550,700,1710,560,400,3750,3540,2220,2210,650,1630,2280,1820,2080,1210,1690,1680,1320,1830,1260,2460,2890,2700,3430,2490,1330,3470,2700,1280,1850,1490,1280
+88,1260,1010,1040,1260,550,570,660,1770,1340,1930,480,2240,1380,310,540,3670,1610,740,1740,590,420,3770,3560,2270,2280,690,1670,2320,1880,2130,1240,1760,1750,1380,1890,1320,2520,2950,2880,3470,2570,1380,3510,2750,1330,1920,1540,1310
+89,1340,1100,1140,1320,570,600,710,1870,1420,2010,500,2300,1460,330,570,3670,1680,780,1760,610,430,3790,3590,2340,2360,720,1720,2380,1930,2190,1260,1840,1820,1450,1950,1370,2580,3020,3080,3520,2640,1440,3540,2810,1380,2000,1590,1350
+90,1420,1220,1260,1390,610,630,760,1980,1510,2110,520,2370,1570,350,620,3670,1760,840,1800,640,460,3810,3610,2400,2430,760,1770,2440,2000,2250,1290,1920,1910,1530,2010,1440,2630,3090,3350,3560,2710,1510,3580,2870,1420,2090,1650,1390
+91,1530,1360,1390,1460,650,670,820,2100,1620,2220,550,2440,1700,380,680,3670,1850,900,1880,670,480,3830,3650,2470,2510,800,1830,2510,2070,2310,1320,2000,2000,1620,2090,1510,2700,3160,3750,3600,2800,1590,3610,2930,1470,2200,1710,1430
+92,1660,1440,1560,1550,690,720,900,2240,1730,2340,580,2530,1860,410,750,3670,1940,970,2000,710,510,3850,3680,2550,2590,850,1900,2590,2150,2380,1360,2100,2100,1730,2180,1600,2770,3240,3850,3650,2900,1670,3650,3010,1530,2310,1790,1490
+93,1830,1610,1760,1650,750,780,980,2380,1870,2480,610,2630,2060,450,830,3680,2050,1060,2110,760,550,3870,3710,2640,2650,920,1960,2680,2250,2450,1410,2200,2220,1850,2280,1700,2860,3320,3860,3690,2990,1760,3690,3050,1610,2420,1880,1540
+94,2060,1910,1870,1780,820,860,1090,2500,2010,2640,650,2750,2270,500,890,3680,2170,1170,2220,820,590,3890,3750,2740,2740,1000,2060,2780,2360,2530,1460,2320,2360,1990,2400,1820,2950,3400,3870,3730,3100,1870,3730,3140,1720,2560,1990,1620
+95,2350,2300,2030,1930,920,960,1260,2640,2200,2810,700,2880,2520,550,960,3750,2320,1300,2350,900,640,3910,3780,2850,2840,1100,2180,2900,2480,2640,1530,2480,2510,2130,2540,1980,3060,3490,3870,3770,3220,2020,3760,3230,1840,2730,2120,1720
+96,2690,2570,2390,2110,1050,1090,1520,2830,2450,3060,770,3050,2750,580,1010,3800,2480,1470,2540,990,710,3930,3820,2980,2950,1250,2330,3040,2620,2770,1620,2680,2690,2350,2710,2170,3180,3590,3880,3810,3340,2180,3810,3340,2010,2930,2280,1860
+97,3140,2790,2910,2360,1220,1290,1870,3090,2770,3420,850,3250,3260,680,1060,3860,2680,1710,2770,1130,790,3950,3860,3150,3090,1450,2530,3210,2790,2950,1740,2920,2890,2610,2860,2440,3320,3680,3880,3850,3480,2410,3850,3470,2230,3170,2500,2010
+98,3560,3270,3230,2670,1500,1610,2260,3370,3160,3840,990,3470,3460,830,1140,3920,2950,2070,2990,1370,950,3970,3910,3350,3280,1680,2800,3440,3030,3160,1930,3210,3150,2930,3100,2820,3500,3780,3880,3910,3610,2730,3900,3620,2590,3400,2820,2310
+99,3560,3660,3520,3150,1880,2290,2540,3630,3590,3860,1270,3720,3590,1230,1630,3950,3330,2640,3370,1850,1320,3990,3950,3630,3570,2210,3240,3710,3370,3460,2290,3570,3500,3370,3470,3410,3730,3890,3890,3950,3800,3200,3950,3810,3200,3690,3270,2850

cc-multilingual-main/cc_net/cc_net/data/test_stats.json

@@ -0,0 +1,38 @@
+{
+  "2019-09/de_head_0000.json.gz": {
+    "size": 5264993,
+    "checksum": "fc12ba3dc982ef06e7e44a916f298e1c16f9a806"
+  },
+  "2019-09/de_middle_0000.json.gz": {
+    "size": 9195535,
+    "checksum": "2369ff0296ab1d924c81083f17ce41f22a10ad69"
+  },
+  "2019-09/de_tail_0000.json.gz": {
+    "size": 33029074,
+    "checksum": "18865040a7263242d298958f358f7cb5511114d4"
+  },
+  "2019-09/fr_head_0000.json.gz": {
+    "size": 4076580,
+    "checksum": "4eef4017bbbe042fc01c45b5fbcf94de49f5138e"
+  },
+  "2019-09/fr_middle_0000.json.gz": {
+    "size": 8075095,
+    "checksum": "fd251a5b924c4aa66a63c375ca3a8fae23b3273b"
+  },
+  "2019-09/fr_tail_0000.json.gz": {
+    "size": 27248949,
+    "checksum": "4a8aed38abc6b9d04459e8d424bd47426f063638"
+  },
+  "2019-09/it_head_0000.json.gz": {
+    "size": 1760696,
+    "checksum": "e5e50e49b4a5147ea82b385babd5c83f74d2a4ed"
+  },
+  "2019-09/it_middle_0000.json.gz": {
+    "size": 4461832,
+    "checksum": "7daab7b7acb93d81e50534196ada4e94947b8224"
+  },
+  "2019-09/it_tail_0000.json.gz": {
+    "size": 14754298,
+    "checksum": "1adc018519a598ff162261d7e480ea41d3458768"
+  }
+}

cc-multilingual-main/cc_net/cc_net/dedup.py

@@ -0,0 +1,478 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Tools to remove duplicate paragraphs across one or several shards.
+"""
+
+import argparse
+import gc
+import hashlib
+import logging
+import multiprocessing
+import os
+import tempfile
+import time
+from pathlib import Path
+from typing import Iterable, List, Optional, Set, Union
+
+import numpy as np
+
+from cc_net import jsonql
+from cc_net.flat_hash_set import HASH_TYPE, AbstractDedupHashSet, FlatHashSet
+from cc_net.jsonql import mem_footprint_gb
+from cc_net.text_normalizer import normalize_for_dedup
+
+BYTE_ORDER = "little"
+HASH_SIZE = HASH_TYPE(0).nbytes
+DISABLE_MULTI_PROCESSING = False
+
+FilesOrDir = Union[List[Path], Path]
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description="Read a set of json files and allow to query them",
+        parents=[jsonql.io_parser()],
+    )
+
+    parser.add_argument("--field", type=str, default="raw_content")
+    parser.add_argument("--output_hashes", type=str)
+    parser.add_argument("--no_finalize", action="store_false", dest="finalize")
+    # parser.add_argument("--mem_gb", type=int)
+    parser.add_argument("--hashes", type=str)
+
+    return vars(parser.parse_args())
+
+
+def _b2i(b: bytes) -> int:
+    return np.frombuffer(b[:HASH_SIZE], dtype=HASH_TYPE, count=1, offset=0).item(0)
+
+
+def str_hash(s: str) -> int:
+    h = hashlib.sha1(bytes(s, encoding="utf-8"))
+    return _b2i(h.digest())
+
+
+log = logging.getLogger(__name__).info
+
+
+def run_par(processes):
+    # This is different from multiprocessing.map since it allows for kwargs.
+    processes = list(processes)
+    if len(processes) == 1 or DISABLE_MULTI_PROCESSING:
+        for f, args, kwargs in processes:
+            f(*args, **kwargs)
+        return
+
+    log(f"Starting {len(processes)} subprocess")
+    processes = [
+        multiprocessing.Process(target=f, args=a, kwargs=kw) for (f, a, kw) in processes
+    ]
+    for p in processes:
+        p.start()
+    for p in processes:
+        p.join()
+    failed = 0
+    for p in processes:
+        if p.exitcode != 0:
+            log(f"Process failed with code {p.exitcode}: {p}")
+            failed += 1
+    assert failed == 0, f"{failed} processes failed..."
+
+
+def split_file(file, n_splits):
+    for i in range(n_splits):
+        yield jsonql.SplitFile(file, i, n_splits)
+
+
+def merge(hashes_1, hashes_2, output):
+    if isinstance(hashes_1, str):
+        h1 = FlatHashSet()
+        h1.load(hashes_1)
+    else:
+        h1 = hashes_1
+
+    if isinstance(hashes_2, str):
+        h2 = FlatHashSet()
+        h2.load(hashes_2)
+    else:
+        h2 = hashes_2
+
+    h2_np = np.fromiter(h2.keys(), dtype=FlatHashSet.dtype, count=len(h2))
+    dup = h1.__contains__(h2_np)
+
+    # Dups between h1 and h2 will be set to 1, keys unique to h2 are copied to
+    # h1 with their value.
+    h1[h2_np] = dup
+    if output:
+        h1.dump(output)
+    return h1
+
+
+def merge_shard(hash_files, output):
+    h = FlatHashSet()
+    h.load(hash_files[0])
+    for hash_file in hash_files[1:]:
+        h = merge(h, hash_file, output=None)
+        print(f"Merged {hash_file}. We now have {len(h)} hashes.")
+
+    h.dump(output)
+    print(f"Saved {len(h)} hashes to {output}.")
+
+
+def _dump_sentence_hashes(source: Path, output: Path, field: str):
+    treated = 0
+    started = time.time()
+    with open(output, "wb") as o:
+        for doc in jsonql.read_jsons(source):
+            content = doc.get(field)
+            if not content:
+                continue
+            h = compute_hashes(content)
+            if h is None:
+                continue
+            h.tofile(o)
+            treated += 1
+            if treated % 100_000 == 0:
+                delay = time.time() - started
+                log(
+                    f"Computed {treated} documents hashes in {delay / 3600:.2f}h ({treated / delay} doc / s)"
+                )
+
+
+def _remove_duplicate_hashes(duplicates, source, output):
+    batch_size = 100_000
+    n_lines, n_lines_kept = 0, 0
+    with open(source, "rb") as f, open(output, "wb") as o:
+        log(f"Opening {source} with mode rb")
+        log(f"Opening {output} with mode wb")
+        while True:
+            hashes = np.fromfile(f, dtype=HASH_TYPE, count=batch_size)
+            if hashes.size == 0:
+                break
+
+            keep = duplicates[hashes] < 1
+            kept = keep.sum()
+            hashes *= keep
+            hashes.tofile(o)
+
+            n_lines += hashes.size
+            n_lines_kept += kept
+
+    removed = n_lines - n_lines_kept
+    selectivity = n_lines_kept / n_lines if n_lines else 0
+    log(f"Removed {removed} duplicate hashes with selectivity: {selectivity:3.1%}")
+
+
+def remove_duplicates_sharded(
+    files: List[Path],
+    outputs: List[Path],
+    hashes_dir: FilesOrDir,
+    field: str,
+    group_hashes: int = 1,
+    tmp_dir: Path = None,
+    min_len: int = 0,
+):
+    """Remove duplicates in several passes, when all hashes don't fit in RAM.
+
+    Note: The current implementation is not doing a 'perfect' deduplication.
+    If a hash appear exactly once in each shard of hashes it won't be detected
+    as a duplicate. This can be fixed if hashes are fully dedup beforehand.
+    """
+    assert len(files) == len(outputs)
+
+    if isinstance(hashes_dir, list):
+        hashes_files = hashes_dir
+    else:
+        hashes_files = sorted(
+            h for h in Path(hashes_dir).iterdir() if h.suffix == ".bin"
+        )
+
+    assert len(hashes_files) > 0, f"no hashes files found in: {hashes_dir}"
+
+    if len(hashes_files) <= group_hashes:
+        log(f"All hashes can be done in one pass, using DuplicatesRemover on {files}")
+        rm_dups = DuplicatesRemover(field, hashes_files)
+        rm_dups._prepare()
+        run_par(
+            (jsonql.run_pipes, (rm_dups,), dict(file=f, output=o))
+            for f, o in zip(files, outputs)
+        )
+        return
+
+    log(f"Starting deduplicate_sharded on {files}.")
+    tmp_directory = tempfile.TemporaryDirectory(dir=str(tmp_dir) if tmp_dir else None)
+
+    def tmp_files(i):
+        return [
+            Path(tmp_directory.name) / (f.name.split(".")[0] + f".{i}.bin")
+            for f in files
+        ]
+
+    last = tmp_files(0)
+    run_par((_dump_sentence_hashes, (f, tmp, field), {}) for f, tmp in zip(files, last))
+
+    if isinstance(hashes_dir, list):
+        hashes_files = hashes_dir
+    else:
+        hashes_files = sorted(
+            h for h in Path(hashes_dir).iterdir() if h.suffix == ".bin"
+        )
+    for i, group in enumerate(jsonql.grouper(hashes_files, group_hashes)):
+        hashes = FlatHashSet()
+        for h in group:
+            hashes.load(h)
+            log(f"Loaded {h}, up to {len(hashes)} hashes ({mem_footprint_gb()}GB)")
+
+        intermediates = tmp_files(i + 1)
+        # Remove hashes in parallel. Since modern OS have "copy-on-write" and
+        # `hashes` is read-only, we will only have one version of it in RAM.
+        run_par(
+            (_remove_duplicate_hashes, (hashes, f, tmp), {})
+            for f, tmp in zip(last, intermediates)
+        )
+        # Force hashes to be freed, before we start allocating a new one.
+        del hashes
+        gc.collect()
+
+        for tmp in last:
+            os.remove(tmp)
+        last = intermediates
+
+    def finalize(source, dedup_hashes, min_len):
+        n_chars, n_chars_kept = 0, 0
+        with open(dedup_hashes, "rb") as hashes:
+            for doc in jsonql.read_jsons(source):
+                content = doc.get(field)
+                if not content or len(content) < min_len:
+                    continue
+                sentences = content.split("\n")
+                doc_hashes = np.fromfile(hashes, dtype=HASH_TYPE, count=len(sentences))
+                chars, kept_chars = finalize_doc(doc, field, doc_hashes)
+                n_chars += chars
+                n_chars_kept += kept_chars
+                yield doc
+        selectivity = n_chars_kept / n_chars if n_chars else 0
+        log(f"Kept {n_chars_kept} chars out of {n_chars} ({selectivity:.1%}).")
+
+    dedup_hashes = last
+    run_par(
+        [
+            (
+                jsonql.run_pipe,
+                (finalize,),
+                dict(kwargs=dict(dedup_hashes=h, min_len=min_len), file=f, output=o),
+            )
+            for h, f, o in zip(dedup_hashes, files, outputs)
+        ]
+    )
+
+    tmp_directory.cleanup()
+
+
+def compute_hashes(content) -> Optional[np.ndarray]:
+    if not content:
+        return None
+    lines = content.split("\n")
+    # save hashes as bytes but reinterpret them as uint64.
+    hashes = np.fromiter(
+        (
+            hashlib.sha1(bytes(normalize_for_dedup(l), encoding="utf-8")).digest()[
+                :HASH_SIZE
+            ]
+            for l in lines
+        ),
+        dtype=np.dtype((bytes, HASH_SIZE)),
+        count=len(lines),
+    )
+    return np.ndarray(dtype=HASH_TYPE, buffer=hashes.data, shape=hashes.shape)
+
+
+def finalize_doc(doc, field, hashes=None):
+    content = doc.get(field)
+    lines = content.split("\n")
+    n_chars = len(content)
+    if "original_nlines" not in doc:
+        doc["original_nlines"] = doc.get("nlines", len(lines))
+    if "original_length" not in doc:
+        doc["original_length"] = doc.get("length", n_chars)
+    if hashes is None:
+        hashes = doc.pop(field + "_hash")
+
+    # Remove duplicates inside doc
+    seen: Set[int] = set()
+    original_line_ids = doc.get("line_ids", range(len(hashes)))
+    line_ids = []
+    new_lines = []
+    for l, line, h in zip(original_line_ids, lines, hashes):
+        if h not in seen and h != 0:
+            line_ids.append(l)
+            new_lines.append(line)
+        seen.add(h)
+
+    doc[field] = "\n".join(new_lines)
+    doc["nlines"] = len(line_ids)
+    n_chars_kept = len(doc[field])
+    doc["length"] = n_chars_kept
+    doc["line_ids"] = line_ids
+    return n_chars, n_chars_kept
+
+
+class HashesCollector(jsonql.Transformer):
+    """
+    Collect all hashes found of lines found in the `field` of the source documents.
+    """
+
+    parallelisable = False
+
+    def __init__(
+        self, field: str, output: Path = None, hashes: AbstractDedupHashSet = None
+    ):
+        super().__init__()
+        self.n_lines = 0
+        self.field = field
+        self.output = output
+        self.hashes = FlatHashSet() if hashes is None else hashes
+        self.num_hashes_end = 0
+        self.num_hashes_start = len(self.hashes)
+
+    def summary(self) -> List[str]:
+        summ = super().summary()
+        h = self.num_hashes_end if self.hashes is None else len(self.hashes)
+        h = (h - self.num_hashes_start) // 1000
+        max_mem = mem_footprint_gb()
+        n = self.n_lines // 1000
+        summ.append(
+            f"Found {h:_}k unique hashes over {n:_}k lines. Using {max_mem:.1f}GB of RAM."
+        )
+        return summ
+
+    def do(self, doc: dict) -> None:
+        doc_hashes = compute_hashes(doc.get(self.field))
+        if doc_hashes is None:
+            return
+        self.hashes.add(doc_hashes)
+        self.n_lines += doc_hashes.size
+
+    def close(self):
+        if self.output and self.hashes:
+            self.hashes.dump(self.output)
+            self.log(f"Saved {len(self.hashes)} hashes to {self.output}")
+            # Save the number of hashes.
+            self.num_hashes_end = len(self.hashes)
+            # Free up mem even if the transformer is kept somewhere else.
+            self.hashes = None  # type: ignore
+
+
+class DuplicatesRemover(jsonql.Transformer):
+    """DuplicatesRemover"""
+
+    # The hashes can't be pickled so they will have to be read back from disk.
+    warn_when_pickling = True
+
+    def __init__(self, field: str, hashes_files: List[Path], collect: bool = False):
+        """
+        Remove duplicates
+        """
+        super().__init__()
+        self.field = field
+        self.collect = collect
+
+        self.hashes_files = hashes_files
+        self.duplicates: Optional[AbstractDedupHashSet] = None
+
+        self.n_lines, self.n_lines_kept = 0, 0
+        self.n_chars, self.n_chars_kept = 0, 0
+
+    def _prepare(self):
+        if self.duplicates is not None:
+            return
+        self.duplicates = FlatHashSet()
+
+        start = time.time()
+        for h in self.hashes_files:
+            shard_start = time.time()
+            self.duplicates.load(str(h))
+            delay = time.time() - shard_start
+            self.log(
+                f"Loaded hashes from {h} ({mem_footprint_gb():.3f}GB total, took {delay / 60:.1}m)"
+            )
+
+        delay = time.time() - start
+        self.log(
+            f"Loaded {len(self.duplicates):_d} hashes from {len(self.hashes_files)} files. ({mem_footprint_gb():.1f}GB total, took {delay / 60:.1}m)"
+        )
+
+    def do(self, doc: dict) -> Optional[dict]:
+        content = doc.get(self.field)
+        if not content:
+            return None
+        doc_hashes = compute_hashes(content)
+
+        assert self.duplicates is not None
+        seen = (
+            self.duplicates.add(doc_hashes)
+            if self.collect
+            else self.duplicates[doc_hashes]
+        )
+        keep = seen < True
+        kept = keep.sum()
+        if kept == 0:
+            return None
+        doc_hashes = doc_hashes * keep
+        self.n_lines += keep.size
+        self.n_lines_kept += kept
+        chars, kept_chars = finalize_doc(doc, self.field, hashes=doc_hashes)
+        self.n_chars += chars
+        self.n_chars_kept += kept_chars
+        return doc
+
+    def summary(self) -> List[str]:
+        summ = super().summary()
+        end_time = time.time()
+        n_lines_kept, n_lines, n_docs = self.n_lines_kept, self.n_lines, self.processed
+        speed = n_docs / (end_time - self.start_time)
+        summ.append(
+            f"Processed {self.n_lines} lines in {n_docs} docs. [{speed:.1f} doc/s]"
+        )
+        selectivity = self.n_lines_kept / self.n_lines if n_lines else 0
+        summ.append(f"Kept {n_lines_kept} lines out of {n_lines} ({selectivity:.1%}).")
+
+        n_chars_kept, n_chars = self.n_chars_kept, self.n_chars
+        selectivity = n_chars_kept / n_chars if n_chars else 0
+        summ.append(f"Kept {n_chars_kept} chars out of {n_chars} ({selectivity:.1%}).")
+        return summ
+
+
+def deduplicate(
+    file: jsonql.ReadableFileLike, field: str = "raw_content"
+) -> Iterable[dict]:
+    """Remove duplicates of the given file (but keep the first occurence)."""
+    dup_remover = DuplicatesRemover(field, [], collect=True)
+    return dup_remover.map(jsonql.read_jsons(file))
+
+
+def deduplicate_two_pass(
+    file: jsonql.FileDescriptor, field: str = "raw_content"
+) -> Iterable[dict]:
+    """Remove duplicates of the given file (even removing the first occurence).
+
+    This is what is done in the paper, and in mine.py
+    """
+    try:
+        if isinstance(file, Path):
+            hash_file: Path = file.with_suffix(".bin")
+        else:
+            hash_file = jsonql._tmp(Path("hashes.bin"))
+        jsonql.run_pipes(
+            jsonql.JsonReader(), HashesCollector(field, output=hash_file), file=file
+        )
+        dup_remover = DuplicatesRemover(field, [hash_file])
+        return dup_remover.map(jsonql.read_jsons(file))
+    finally:
+        if hash_file.exists():
+            hash_file.unlink()

cc-multilingual-main/cc_net/cc_net/execution.py

@@ -0,0 +1,248 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import functools
+import itertools
+import logging
+import os
+import sys
+import time
+import warnings
+from pathlib import Path
+from typing import Callable, Dict, Iterable, List, Optional, Sequence, Sized
+
+import submitit
+from typing_extensions import Protocol
+# import pdb
+from concurrent.futures import ThreadPoolExecutor
+
+
+class Executor(Protocol):
+    def __call__(self, function: Callable[..., str], *args: Iterable) -> None:
+        ...
+
+
+class SubmititRetryOnTimeout(submitit.helpers.Checkpointable):
+    def __init__(self, fn: Callable):
+        self.fn = fn
+        self.__name__ = fn.__name__
+
+    def __call__(self, *args, **kwargs):
+        return self.fn(*args, **kwargs)
+
+
+def get_executor(
+    name: str,
+    log_dir: Path,
+    execution: str,
+    timeout_hour: float = 1.0,
+    mem_gb: int = 1,
+    cpus: int = 1,
+    task_parallelism: int = -1,
+    options: dict = {},
+) -> Executor:
+
+    execution_mode = execution.split(",")[0]
+    options.update(
+        {kv.split("=", 1)[0]: kv.split("=", 1)[1] for kv in execution.split(",")[1:]}
+    )
+
+    if execution_mode == "mp":
+        warnings.warn("Execution mode 'mp' is deprecated, use 'local'.")
+        execution_mode = "local"
+
+    cluster = None if execution_mode == "auto" else execution_mode
+    # use submitit to detect which executor is available
+    ex = submitit.AutoExecutor(log_dir, cluster=cluster)
+    ex.parameters['timeout_min'] = int(timeout_hour * 60)
+
+    if ex.cluster == "local":
+        # LocalExecutor doesn't respect task_parallelism
+        return functools.partial(custom_map_array, ex, task_parallelism)
+    if ex.cluster == "debug":
+        return debug_executor
+    # pdb.set_trace()
+    # We are on slurm
+    if task_parallelism == -1:
+        task_parallelism = 500
+
+    ex.update_parameters(
+        name=name,
+        timeout_min=int(timeout_hour * 60),
+        mem_gb=mem_gb,
+        cpus_per_task=cpus,
+        slurm_array_parallelism=task_parallelism,
+        **options,
+    )
+    return functools.partial(map_array_and_wait, ex)
+
+
+def map_array_and_wait(
+    ex: submitit.AutoExecutor, function: Callable[..., str], *args: Iterable
+):
+    f_name = function.__name__
+
+    assert len(args) > 0, f"No arguments passed to {f_name}"
+    approx_length = _approx_length(*args)
+
+    print(f"Submitting {f_name} in a job array ({approx_length} jobs)")
+    jobs = ex.map_array(function, *args)
+    if not jobs:
+        return
+    failed_jobs = []
+    done = 0
+    total = len(jobs)
+    job_array_id = jobs[0].job_id.split("_")[0]
+    # pdb.set_trace()
+    print(f"Started {f_name} in job array {job_array_id} ({len(jobs)} jobs).")
+    for job in submitit.helpers.as_completed(jobs):
+        done += 1
+        e = job.exception()
+        if not e:
+            print(f"Finished job {job.job_id} ({done} / {total}).", job.result())
+            continue
+
+        print(f"Failed job {job.job_id} ({done} / {total}):", e)
+        failed_jobs.append(job)
+
+    if failed_jobs:
+        n_failures = 10
+        message = f"{len(failed_jobs)} / {done} jobs failed while running {f_name}"
+        print(message)
+        for job in failed_jobs[:n_failures]:
+            print(f"Failed {job.job_id} -> {job.paths.stderr}")
+        if len(failed_jobs) > n_failures:
+            print(f"... ({len(failed_jobs) - n_failures} failed job skipped)")
+        raise Exception(message)
+
+
+def debug_executor(function: Callable[..., Optional[str]], *args: Iterable) -> None:
+    logging.getLogger().setLevel(logging.DEBUG)
+    approx_length = _approx_length(*args)
+    for i, x in enumerate(zip(*args)):
+        try:
+            message = function(*x)
+        except Exception:
+            exit(1)
+            try:
+                import ipdb as pdb  # type: ignore
+            except ImportError:
+                import pdb  # type: ignore
+            import traceback
+
+            traceback.print_exc()
+            print("")
+            pdb.post_mortem()
+            sys.exit(1)
+        if message is not None:
+            print(message, f"({i + 1} / {approx_length})")
+
+# def debug_executor(function: Callable[..., Optional[str]], *args: Iterable) -> None:
+#     logging.getLogger().setLevel(logging.DEBUG)
+#     approx_length = _approx_length(*args)
+#     with ThreadPoolExecutor(max_workers=4) as executor:
+#         futures = []
+#         for i, x in enumerate(zip(*args)):
+#             future = executor.submit(_execute_function, function, x, i + 1, approx_length)
+#             futures.append(future)
+#         for future in futures:
+#             future.result()
+
+# def _execute_function(function: Callable[..., Optional[str]], args: tuple, index: int, total: int):
+#     try:
+#         message = function(*args)
+#         if message is not None:
+#             print(message, f"({index} / {total})")
+#     except Exception:
+#         # traceback.print_exc()
+#         sys.exit(1)
+
+def _approx_length(*args: Iterable):
+    for a in args:
+        if isinstance(a, Sized):
+            return len(a)
+    return -1
+
+
+def custom_map_array(
+    ex: submitit.AutoExecutor,
+    parallelism: int,
+    function: Callable[..., Optional[str]],
+    *args: Iterable,
+) -> None:
+    f_name = function.__name__
+    assert len(args) > 0, f"No arguments passed to {f_name}"
+
+    jobs_args = list(zip(*args))
+    total = len(jobs_args)
+    if parallelism < 0:
+        parallelism = os.cpu_count() or 0
+    assert parallelism >= 0, f"Can't run any jobs with task_parallelism={parallelism}"
+    print(f"Submitting {total} jobs for {f_name}, with task_parallelism={parallelism}")
+    enqueued = 0
+    done = 0
+    running_jobs: List[submitit.Job] = []
+    failed_jobs: List[submitit.Job] = []
+
+    while done < len(jobs_args):
+        # Try to queue more job if we have some bandwidth.
+        if enqueued < total and len(running_jobs) < parallelism:
+            running_jobs.append(ex.submit(function, *jobs_args[enqueued]))
+            enqueued += 1
+            continue
+
+        # Else wait for some job to finish
+        if not running_jobs:
+            warnings.warn(
+                f"No more running jobs, yet we submitted only {enqueued} / {total} and finished {done} / {total}"
+            )
+            break
+
+        job = get_next_job(running_jobs)
+        running_jobs.remove(job)
+        done += 1
+        e = job.exception()
+        if not e:
+            print(f"Finished job {job.job_id} ({done} / {total}).", job.result())
+            continue
+
+        print(f"Failed job {job.job_id} ({done} / {total}):", e)
+        failed_jobs.append(job)
+
+    if failed_jobs:
+        n_failures = 10
+        message = f"{len(failed_jobs)} / {done} jobs failed while running {f_name}"
+        print(message)
+        for job in failed_jobs[:n_failures]:
+            print(f"Failed {job.job_id} -> {job.paths.stderr}")
+        if len(failed_jobs) > n_failures:
+            print(f"... ({len(failed_jobs) - n_failures} failed job skipped)")
+        raise Exception(message)
+
+
+def get_next_job(
+    jobs: Sequence[submitit.Job], poll_frequency: float = 10
+) -> submitit.Job:
+    """
+    Waits for any of the job to finish and returns it.
+
+    jobs: list of jobs
+    poll_frequency: frequency in second at which we check job status
+    """
+    start = time.time()
+    waiting = False
+    while True:
+        for job in jobs:
+            if job.done():
+                return job
+        if not waiting:
+            job_ids = [j.job_id for j in jobs[:4]]
+            suffix = "..." if len(jobs) > 4 else ""
+            print(
+                f"Waiting on {len(jobs)} running jobs. Job ids: {','.join(job_ids)}{suffix}"
+            )
+            waiting = True
+        time.sleep(poll_frequency)

cc-multilingual-main/cc_net/cc_net/flat_hash_set.py

@@ -0,0 +1,247 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import sys
+import time
+import warnings
+from typing import Iterable, Iterator, Sequence, Sized, Tuple, Type
+
+import numpy as np
+
+HASH_TYPE: Type[np.uint64] = np.uint64
+
+GETPY_WARNING = False
+
+
+class AbstractDedupHashSet(Sized, Iterable[np.uint64]):
+    """A dict-like that returns `True` for keys that have been added more than once.
+
+    The API is batched and expect np.array as input. This batching grants better
+    perf when using the C++ implementation.
+    """
+
+    dtype: Type[np.uint64] = HASH_TYPE
+
+    def __repr__(self):
+        implementation = type(self).__name__
+        return f"[{implementation}, len: {len(self)}"
+
+    def __len__(self) -> int:
+        ...
+
+    def __contains__(self, values: Sequence[np.uint64]) -> np.ndarray:
+        ...
+
+    def __getitem__(self, values) -> np.ndarray:
+        ...
+
+    def __setitem__(self, keys, values) -> None:
+        ...
+
+    def items(self) -> Iterable[Tuple[np.uint64, np.uint8]]:
+        ...
+
+    def keys(self) -> Iterable[np.uint64]:
+        ...
+
+    def __iter__(self) -> Iterator[np.uint64]:
+        return iter(self.keys())
+
+    def add(self, h, contains=None):
+        """Add the given keys. First time a key is added the value is set to 0,
+        then it's set to one."""
+        if not isinstance(h, np.ndarray):
+            h = np.array(h, dtype=HASH_TYPE)
+        if contains is None:
+            contains = self.__contains__(h)
+
+        self.__setitem__(h, contains)
+        return contains
+
+    def merge(self, keys, values):
+        contains = self.__contains__(keys)
+        self.__setitem__(keys, contains | values)
+
+    def dump(self, filename):
+        return self.dump_np(filename)
+
+    def load(self, filename):
+        return self.load_np(filename)
+
+    def dump_np(self, filename):
+        kv_type = np.dtype([("k", HASH_TYPE), ("v", np.uint8)])
+        items = np.fromiter(self.items(), dtype=kv_type, count=len(self))
+        with open(filename, "wb") as f:
+            np.save(f, items)
+
+    def load_np(self, filename):
+        items = np.load(str(filename))
+        keys = items["k"].copy()
+        values = items["v"].copy()
+        self.merge(keys, values)
+
+    def dump_np2(self, filename):
+        keys = np.fromiter(
+            (k for (k, v) in self.items()), dtype=HASH_TYPE, count=len(self)
+        )
+        with open(filename, "wb") as f:
+            np.save(f, keys)
+
+        values = np.fromiter(
+            (v for (k, v) in self.items()), dtype=np.uint8, count=len(self)
+        )
+        with open(str(filename) + ".val", "wb") as f:
+            np.save(f, values)
+
+    def load_np2(self, filename):
+        keys = np.load(filename)
+        values = np.load(str(filename) + ".val")
+        self.merge(keys, values)
+
+
+class NaiveHashSet(dict, AbstractDedupHashSet):
+    """Pure python implementation of AbstractDedupHashSet.
+
+    This implementation is quite fast, since Python dict are heavily optimized.
+    """
+
+    def __init__(self, iterable=None):
+        super().__init__()
+        global GETPY_WARNING
+        if GETPY_WARNING:
+            warnings.warn(
+                "Module 'getpy' not found. Deduplication will take more RAM."
+                " Try `pip install cc_net[getpy]"
+            )
+        GETPY_WARNING = False
+
+    def __contains__(self, values):
+        """Returns `True` if the object has been added at list once."""
+        contains_point = super().__contains__
+        return np.fromiter(
+            map(contains_point, values), count=len(values), dtype=np.uint8
+        )
+
+    def __getitem__(self, values):
+        """Returns `True` if the object has been added at list twice."""
+        get_point = super().get
+        return np.fromiter(
+            map(lambda x: get_point(x, False), values),
+            count=len(values),
+            dtype=np.uint8,
+        )
+
+    def __setitem__(self, keys, values):
+        assert len(keys) == len(values)
+        for k, v in zip(keys, values):
+            dict.__setitem__(self, k, v)
+
+
+try:
+    import getpy as gp  # type: ignore
+
+    class _FlatHashSet(gp.Dict, AbstractDedupHashSet):
+        """C++ backed implementation of AbstractDedupHashSet.
+
+        This implementation is slightly slower than the Python one but uses
+        3x less RAM.
+        See https://github.com/atom-moyer/getpy.
+        """
+
+        def __init__(self):
+            super().__init__(HASH_TYPE, np.uint8, default_value=False)
+
+        def __contains__(self, h):
+            """Returns `True` if the object has been added at list once."""
+            if not isinstance(h, np.ndarray):
+                h = np.array(h, dtype=HASH_TYPE)
+            c = gp.Dict.__contains__(self, h)
+            c.dtype = np.uint8
+            return c
+
+        def dump(self, filename):
+            return self.dump_gp(filename)
+
+        def load(self, filename):
+            return self.load_gp(filename)
+
+        def dump_gp(self, filename):
+            return gp.Dict.dump(self, str(filename))
+
+        def load_gp(self, filename):
+            """Override gp.Dict.load, to correctly merge values instead of overwriting."""
+            other = gp.Dict(HASH_TYPE, np.uint8, default_value=False)
+            other.load(str(filename))
+            n = len(other)
+            keys = np.fromiter(
+                (k for (k, v) in other.items()), dtype=HASH_TYPE, count=n
+            )
+            values = np.fromiter(
+                (v for (k, v) in other.items()), dtype=np.uint8, count=n
+            )
+            self.merge(keys, values)
+
+    FlatHashSet: Type[AbstractDedupHashSet] = _FlatHashSet
+except ImportError:
+    GETPY_WARNING = True
+    FlatHashSet = NaiveHashSet
+
+
+def timeit(message, function, *args):
+    start = time.time()
+    function(*args)
+    end = time.time()
+    print(message, f"took {end - start:.0f}s")
+
+
+def compare_load(*filenames):
+    assert filenames, "No file given"
+
+    def load_list():
+        hashes = []
+        for f in filenames:
+            h = FlatHashSet()
+            h.load(f)
+            print(f"Loaded {h} from {f}.")
+            hashes.append(h)
+        return hashes
+
+    def load_all(load, ext):
+        hashes = FlatHashSet()
+        for f in filenames:
+            load(hashes, f + ext)
+
+    def dump_all(hashes, dump, ext):
+        for h, f in zip(hashes, filenames):
+            dump(h, f + ext)
+
+    hashes = load_list()
+    dump_gp = getattr(FlatHashSet, "dump_gp")
+    if dump_gp is not None:
+        timeit("Dumping using gp.dump", dump_all, hashes, dump_gp, ".gp.test")
+    timeit("Dumping using dump_np", dump_all, hashes, FlatHashSet.dump_np, ".npy.test")
+    timeit(
+        "Dumping using dump_np2", dump_all, hashes, FlatHashSet.dump_np2, ".npy2.test"
+    )
+
+    load_gp = getattr(FlatHashSet, "load_gp")
+    if load_gp is not None:
+        timeit("Loading using gp.load", load_all, load_gp, ".gp.test")
+    timeit("Loading using load_np", load_all, FlatHashSet.load_np, ".npy.test")
+    timeit("Loading using load_np2", load_all, FlatHashSet.load_np2, ".npy2.test")
+
+    # Loading 10 shards:
+    # [dedup] Dumping using gp.dump took 52s
+    # [dedup] Dumping using dump_np took 270s
+    # [dedup] Dumping using dump_np2 took 483s
+    #
+    # [dedup] Loading using gp.load took 654s
+    # [dedup] Loading using load_np took 82s
+    # [dedup] Loading using load_np2 took 76s
+
+
+if __name__ == "__main__":
+    compare_load(*sys.argv[1:])

cc-multilingual-main/cc_net/cc_net/get_wiki_cirrus.py

@@ -0,0 +1,127 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Creates mono-lingual corpus from Wikipedia.
+"""
+
+import functools
+import re
+import subprocess
+import urllib.request
+from pathlib import Path
+from typing import Dict
+
+import func_argparse
+from bs4 import BeautifulSoup  # type: ignore
+
+from cc_net import jsonql, text_normalizer
+
+CIRRUS_URL = "https://dumps.wikimedia.org/other/cirrussearch"
+CIRRUS_DUMP_RE = re.compile(r"^(.*)wiki-\d+-cirrussearch-content\.json\.gz")
+
+
+def tmp(file: Path) -> Path:
+    return file.parent / ("tmp." + file.name)
+
+
+def opening(file: Path, output: Path = None, n_docs: int = 1_000_000):
+    """Will dump the tokenized opening text of the given Wikipedia.
+
+    Args:
+        - file: File containing the Wikipedia dump.
+        - output: Output file.
+        - n_docs: How many docs to parse
+        - tokenize: whether to tokenize the text
+        - lang: Language code used to chose the tokenizer
+    """
+    assert file.exists()
+    return jsonql.run_pipes(
+        functools.partial(extract_opening_text, n_docs=n_docs),
+        file=file,
+        output=tmp(output) if output else None,
+    )
+    if output:
+        tmp(output).replace(output)
+
+
+def extract_opening_text(source, n_docs: int = 10_000):
+    i = 0
+    for doc in jsonql.read_jsons(source):
+        if not doc:
+            continue
+
+        text = doc.get("opening_text")
+        if not text:
+            continue
+
+        yield text_normalizer.normalize(text)
+        i += 1
+        if i >= n_docs:
+            break
+
+
+def dl(lang: str, output_dir: Path, date: str = None):
+    """Download the cirrus extract for the given lang.
+
+    See https://dumps.wikimedia.org/other/cirrussearch for the full list of files.
+
+    Args:
+        - lang: The Wikipedia code for the language.
+        - output_dir: Output directory. File will be `{lang}.json.gz`
+        - date: Date of a specific Cirrus dump.
+    """
+
+    urls = get_cirrus_urls(date)
+    assert (
+        lang in urls
+    ), f"--lang {lang} not found. Available languages are: {urls.keys()}"
+
+    assert output_dir, "--output_dir folder needed."
+    output_dir.mkdir(exist_ok=True)
+    output = output_dir / (lang + ".json.gz")
+    print(f"Downloading {lang} wiki from {urls[lang]} to {output}")
+    wget(urls[lang], output)
+
+
+def get_cirrus_urls(date: str = None) -> Dict[str, str]:
+    if date is None:
+        cirrus_page = BeautifulSoup(
+            urllib.request.urlopen(CIRRUS_URL), features="html.parser"
+        )
+        dumps = [a.get("href").strip("/") for a in cirrus_page.findAll("a")]
+        dumps.remove("..")
+        dumps.remove("current")
+        # We take the oldest dump since the most recent might be incomplete.
+        # The page only link to the N latest dumps so the dump won't be too old.
+        date = min(dumps)
+
+    cirrus_url = "/".join((CIRRUS_URL, date))
+    print("Will use the Wikipedia dump from:", date, cirrus_url)
+    cirrus_page = BeautifulSoup(
+        urllib.request.urlopen(cirrus_url), features="html.parser"
+    )
+    urls = {}
+    for link in cirrus_page.findAll("a"):
+        match = CIRRUS_DUMP_RE.match(link.get("href"))
+        if not match:
+            continue
+
+        urls[match.group(1)] = "/".join([cirrus_url, link.get("href")])
+    assert urls, f"No valid download urls found at {cirrus_url}"
+    return urls
+
+
+def wget(url: str, output: Path):
+    subprocess.run(["wget", url, "-O", tmp(output), "-q"], check=True)
+    tmp(output).replace(output)
+    assert (
+        output.stat().st_size > 10_000
+    ), f"File {output} downloaded from {url} looks too small"
+
+
+if __name__ == "__main__":
+    func_argparse.main(dl, opening)

cc-multilingual-main/cc_net/cc_net/jsonql.py

@@ -0,0 +1,1340 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Manipulate files containing one json per line.
+"""
+import argparse
+import collections
+import contextlib
+import functools
+import glob
+import gzip
+import importlib
+import inspect
+import io
+import itertools
+import json
+import logging
+import multiprocessing
+import os
+import re
+import sys
+import tempfile
+import time
+import typing as tp
+import warnings
+import zlib
+from pathlib import Path
+from typing import (
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    TextIO,
+    Tuple,
+    Union,
+)
+
+import numpy as np
+import psutil  # type: ignore
+import requests
+from typing_extensions import Protocol
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(process)d:%(name)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M",
+)
+
+NEWLINE = " N3WL1N3 "
+
+FilterFn = Callable[[dict], bool]
+FileDescriptor = Union[Path, List[Path], str]
+WritableFileLike = Union[FileDescriptor, TextIO, "SimpleIO", None]
+ReadableFileLike = Union[Iterable[str], FileDescriptor, None]
+
+
+def io_parser():
+    """Parser shared by all commands to get input/output files."""
+    parser = argparse.ArgumentParser(add_help=False)
+    file_help = """File to read from. Can be specified several times for several files.
+    Be careful that bash will expand glob patterns **before** sending the args
+    to python. To use globs put it inside single quotes:
+        jsonql where --file 'data/perplexity/*.json' '{length} > 100' | head -1
+        jsonql --file 'data/perplexity/*.json' where '{length} > 100' | head -1
+        [Invalid] jsonql where '{length} > 100' --file data/perplexity/*.json | head -1
+        [Invalid] jsonql where --file data/perplexity/*.json '{length} > 100' | head -1
+    """
+    parser.add_argument("-f", "--file", type=Path, action="append", help=file_help)
+    parser.add_argument("-o", "--output", type=Path, default="-")
+    parser.add_argument("--processes", type=int, default=1)
+    return parser
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="Read a set of json files and allow to query them"
+    )
+    subparsers = parser.add_subparsers()
+
+    def add_subparser(function, arguments):
+        doc = function.__doc__.split("\n")[0]
+        p = subparsers.add_parser(function.__name__, help=doc, parents=[io_parser()])
+        p.set_defaults(command=function)
+        for k, v in arguments.items():
+            p.add_argument(k, **v)
+
+    add_subparser(
+        select,
+        {
+            "columns": dict(nargs="+", help="Extract the value of the given fields"),
+            "--skip_empty": dict(
+                action="store_true", help="Skip lines without the requested fields"
+            ),
+            "--separator": dict(
+                default="\t", help="Separator to use between the different columns"
+            ),
+            "--newline": dict(
+                default=NEWLINE,
+                help="Replace newlines found in the text by the given string",
+            ),
+        },
+    )
+
+    add_subparser(
+        where,
+        {
+            "clauses": dict(nargs="+", help=""),
+            "--requires": dict(
+                action="append", help="Python module required by the clauses code."
+            ),
+        },
+    )
+
+    add_subparser(
+        merge,
+        {
+            "columns": dict(nargs="+", help=""),
+            "--separator": dict(
+                default="\t", help="Separator to use between the different columns"
+            ),
+            "--newline": dict(
+                default=NEWLINE, help="Replace the given string by actual newlines"
+            ),
+        },
+    )
+
+    add_subparser(
+        describe,
+        {
+            "columns": dict(nargs="*", help=""),
+            "--bins": dict(
+                default="auto", help="Number of bins for computing the histograms"
+            ),
+            "--cumulative": dict(
+                action="store_true", help="Compute cumulative histograms"
+            ),
+            "--weights": dict(type=str, help="Column used to weight histograms"),
+        },
+    )
+
+    add_subparser(split, {"--pattern": dict(type=str)})
+    add_subparser(shard, {})
+    return parser
+
+
+def _split_array(array, sep):
+    last = 0
+    for i, x in enumerate(array):
+        if x != sep:
+            continue
+        yield array[last:i]
+        last = i + 1
+    if last != len(array):
+        yield array[last:]
+
+
+def main(raw_args):
+    parser = get_parser()
+    pipeline = []
+    file = "-"
+    output = "-"
+    processes = 1
+
+    for args_group in _split_array(raw_args, "--"):
+        args = vars(parser.parse_args(args_group))
+        command = args.pop("command")
+        file = args.pop("file") or file
+        output = args.pop("output") or output
+        processes = args.pop("processes") or processes
+        pipeline.append(as_pipe(command, args))
+
+    if not pipeline:
+        parser.print_help()
+        return
+
+    run_pipes(*pipeline, file=Path(file), output=Path(output), processes=processes)
+
+
+class Transformer:
+    """
+    Wrapper around functions transforming documents.
+
+    This allows `run_pipes` to automatically parallelize the pipeline.
+    Provides:
+    * Automatic logging. Logging can be changed with the `summary` method.
+        Loggin frequency with _log_freq (in second) or $JSONQL_LOG_FREQ env variable.
+    * Automatic parallelization without pickling. The transformers are shared
+    across processes, and the object is usually not pickled.
+    * Basic pickling / unpickling in case it's still needed.
+    By default will only pickle the arguments passed to the constructor.
+    * Delayed initialization. Internal state which is not pickable should be set
+    inside the `_prepare` function.
+    """
+
+    parallelisable: bool = True
+    expect_json: bool = False
+    warn_when_pickling: bool = False
+    ready: bool = False
+
+    def __init_subclass__(cls, expect_json: bool = None):
+        """Detects if the subclass expects json as input."""
+        spec = inspect.getfullargspec(cls.do)
+        if expect_json is None:
+            expect_json = spec.annotations.get(spec.args[1], None) == dict
+
+        cls.expect_json = expect_json
+
+    def __new__(cls, *args, **kwargs):
+        """Creates the transformer and save the arguments passed to the constructor."""
+        t = super().__new__(cls)
+        Transformer.__init__(t, args, kwargs)
+        return t
+
+    def __init__(self, state_args: tuple = None, state_kwargs: dict = None):
+        """
+        Init the transformer counters.
+
+        If state_args/state_kwargs are set they will override whatever was
+        originally passed to the subclass constructor.
+        """
+        if state_args is not None:
+            self.__args = state_args
+        if state_kwargs is not None:
+            self.__kwargs = state_kwargs
+
+        self.start_time = time.time()
+        self.__last_log = self.start_time
+        self.processed = 0
+        # Log every 5 min unless specified other wise.
+        self._log_freq = int(os.environ.get("JSONQL_LOG_FREQ", 5 * 60))
+        self.__cls = type(self)
+        self._logger = logging.getLogger(self.__cls.__name__)
+
+    def __call__(self, x):
+        assert self.ready, f"{self} is not ready."
+        if x is None:
+            return
+        y = self.do(x)
+        self.processed += 1
+        if time.time() - self.__last_log > self._log_freq:
+            self.log_summary()
+        return y
+
+    def do(self, x):
+        raise NotImplementedError(f"'do' not implemented in {type(self)}")
+
+    def summary(self) -> List[str]:
+        return [self.speed_summary()]
+
+    def speed_summary(self) -> str:
+        delay = time.time() - self.start_time
+        h = delay / 3600
+        s = self.processed / delay
+        return f"Processed {self.processed:_} documents in {h:.2}h ({s:5.1f} doc/s)."
+
+    def log(self, message):
+        self._logger.info(message)
+
+    def log_summary(self) -> None:
+        if not self.ready:
+            self.log("Not ready.")
+            return
+        summ = self.summary() or []
+        for line in summ:
+            self.log(line)
+        self.__last_log = time.time()
+
+    def map(self, source: Iterable) -> Iterator:
+        if self.ready:
+            for x in source:
+                yield self(x)
+            # since we have been prepared by caller,
+            # caller is also responsible for calling `close`.
+            return
+        else:
+            with self:
+                for x in source:
+                    yield self(x)
+
+    def __getstate__(self) -> Tuple[tuple, dict, bool]:
+        return (self.__args, self.__kwargs, self.expect_json)
+
+    def __setstate__(self, state: Tuple[tuple, dict, bool]):
+        if self.warn_when_pickling:
+            warnings.warn(f"Unpickling transformer: {type(self)}. This can be slow.")
+        (args, kwargs, expect_json) = state
+        # When unpickling `__new__` isn't called so we have to doit ourselves.
+        Transformer.__init__(self, state_args=args, state_kwargs=kwargs)
+        type(self).__init__(self, *args, **kwargs)
+        assert self.expect_json == expect_json
+        # __setstate__ is called by multiprocessing right before calling
+        # the object so we need to initialize everything.
+        self.__enter__()
+
+    def _prepare(self) -> None:
+        pass
+
+    def __enter__(self) -> "Transformer":
+        # In multiprocessing __enter__ is always called twice, so we are idempotent.
+        # Because we call __enter__ when deserializing this transformer and
+        # also when the parent transformer is deserialized.
+        self.start_time = time.time()
+        if self.ready:
+            return self
+        self._prepare()
+        self.ready = True
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+        self.log_summary()
+
+    def close(self) -> None:
+        pass
+
+
+def as_pipe(transformer, kwargs):
+    if isinstance(transformer, type):
+        return transformer(**kwargs)
+    return lambda source: transformer(source, **kwargs)
+
+
+def compose(fns: List[Transformer]) -> Transformer:
+    if len(fns) == 1:
+        return fns[0]
+    return MultiTransformer(fns)
+
+
+class MultiTransformer(Transformer):
+    def __init__(self, transformers: List[Transformer]):
+        super().__init__()
+        self.transformers = transformers
+
+    def __repr__(self) -> str:
+        pipeline = " | ".join(type(t).__name__ for t in self.transformers)
+        return f"<{pipeline}>"
+
+    def do(self, x):
+        for t in self.transformers:
+            x = t(x)
+        return x
+
+    def _prepare(self):
+        for t in self.transformers:
+            t.__enter__()
+        return self
+
+    def __exit__(self, *args):
+        for t in self.transformers:
+            t.__exit__(*args)
+
+    def summary(self):
+        return itertools.chain(*(t.summary() for t in self.transformers))
+
+
+class Mapper(Transformer):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def do(self, x):
+        return self.fn(x)
+
+
+def run_pipe(
+    command,
+    kwargs: dict = None,
+    file: ReadableFileLike = None,
+    output: WritableFileLike = None,
+):
+    kwargs = kwargs or {}
+    if isinstance(kwargs, argparse.ArgumentParser):
+        kwargs = vars(kwargs.parse_args())
+    file = file or Path(kwargs.pop("file", "-"))
+    output = output or Path(kwargs.pop("output", "-"))
+
+    return run_pipes(as_pipe(command, kwargs), file=file, output=output)
+
+
+def run_pipes(
+    *fns: Union[Transformer, Callable[[Iterable], Iterable]],
+    inputs: Iterable[dict] = None,
+    file: ReadableFileLike = None,
+    output: WritableFileLike = None,
+    processes: int = 1,
+    chunksize: int = 10_000,
+):
+    """
+    Run full document processing pipeline.
+
+    - fns: list of functions to run over the documents. Can be:
+        * `Iterable -> Iterable` function
+        * jsonql.Transformer instance
+        Using transformers allow the pipeline to process documents in parallel.
+    - inputs: iterable to read the documents from
+    - file: if inputs is not given, will read documents from this file.
+    - output: writable file like.
+    - processes: number of processes to use. -1 means all CPU available.
+    - chunksize: chunksize for multiprocessing.Pool.imap_unordered
+    """
+    expect_json = len(fns) and isinstance(fns[0], Transformer) and fns[0].expect_json
+    if expect_json and inputs is None:
+        fns = (JsonReader(),) + fns
+    transformers = []
+    for t in fns:
+        if not isinstance(t, Transformer):
+            break
+        if not t.parallelisable:
+            break
+        transformers.append(t)
+    pipes = fns[len(transformers) :]
+
+    log = logging.getLogger(__name__).info
+    if inputs is None:
+        data: Iterable = open_read(file)
+    else:
+        data = inputs
+
+    if processes == -1:
+        processes = os.cpu_count() or 0
+
+    with contextlib.suppress(BrokenPipeError), contextlib.ExitStack() as stack:
+        if transformers:
+            log(f"preparing {transformers}")
+            transform = stack.enter_context(compose(transformers))
+            if processes <= 1:
+                data = transform.map(data)
+            else:
+                p = multiprocessing.current_process()
+                log(f"Will start {processes} processes from {p.name}, Pid: {p.pid}")
+                pool = stack.enter_context(
+                    multiprocessing.Pool(
+                        processes=processes,
+                        initializer=_set_global_transformer,
+                        initargs=(transform,),
+                    )
+                )
+                data = pool.imap_unordered(
+                    _global_transformer, data, chunksize=chunksize
+                )
+
+        for fn in pipes:
+            if isinstance(fn, Transformer):
+                data = fn.map(data)
+            else:
+                data = fn(data)
+
+        write_jsons(data, output)
+
+
+# Allows to share transformer acroos subprocess.
+# Used by `run_pipes`
+_GLOBAL_TRANSFORMER: Optional[Transformer] = None
+
+
+def _set_global_transformer(transformer: Transformer):
+    global _GLOBAL_TRANSFORMER
+    p = multiprocessing.current_process()
+    logging.info(
+        f"Started subprocess {p.name}:{p.pid} from {os.getppid()} for {transformer}"
+    )
+    assert transformer.ready, f"{transformer} isn't ready"
+    _GLOBAL_TRANSFORMER = transformer
+
+
+def _global_transformer(document: str) -> Optional[dict]:
+    assert _GLOBAL_TRANSFORMER is not None
+    return _GLOBAL_TRANSFORMER(document)
+
+
+def lines(file: ReadableFileLike) -> Iterator[str]:
+    return (line.strip("\n") for line in open_read(file))
+
+
+def read_jsons(file: ReadableFileLike, strict=False) -> Iterator[dict]:
+    reader = JsonReader(strict=strict)
+    lines = open_read(file)
+    for line in lines:
+        if line is None:
+            continue
+        yield reader(line)
+
+    reader.log_summary()
+
+
+def write_jsons(source: Iterable[dict], file: WritableFileLike) -> None:
+    eol = os.linesep
+    with open_write(file) as o:
+        for res in source:
+            if res is None:
+                continue
+            if isinstance(res, dict):
+                json.dump(res, o, ensure_ascii=False)
+                o.write(eol)
+                continue
+            if isinstance(res, str):
+                res = res.rstrip("\n")
+            print(res, file=o)
+
+
+class JsonReader(Transformer):
+    def __init__(self, strict: bool = False):
+        super().__init__()
+        self.ready = True
+        self.strict = strict
+        self.num_errors = 0
+
+    def do(self, line: str) -> Optional[dict]:
+        if line is None:
+            return None
+        if isinstance(line, dict):
+            return line
+        line = line.rstrip("\n")
+        if not line:
+            return None
+        try:
+            return json.loads(line)
+        except json.decoder.JSONDecodeError as e:
+            self.log_error(e)
+            if self.strict:
+                raise
+            return None
+
+    def log_error(self, e: json.decoder.JSONDecodeError):
+        self.num_errors += 1
+        if self.num_errors > 10:
+            return
+
+        MAX_LEN = 80
+        snippet, snippet_len = e.doc, len(e.doc)
+        col = e.pos
+        if snippet_len > MAX_LEN:
+            if col < MAX_LEN:
+                start = 0
+            elif snippet_len - col < MAX_LEN:
+                start = snippet_len - MAX_LEN
+            else:
+                start = col - MAX_LEN // 2
+            snippet = e.doc[start : start + MAX_LEN]
+            col = col - start
+        logging.warning(
+            "\n".join(
+                [
+                    f"Invalid json (length={len(e.doc)}) {e}",
+                    snippet,
+                    " " * (col - 1) + "^",
+                ]
+            )
+        )
+
+    def summary(self):
+        summ = super().summary()
+        if self.num_errors > 0:
+            summ.append(f"Skipped {self.num_errors} invalid json.")
+        return summ
+
+
+def compile_column(column, newline):
+    if callable(column):
+        return column
+
+    if column == "*":
+        return json.dumps
+
+    if re.match(r"[_a-z][_a-z0-9]*", column):
+
+        def extract_col(doc):
+            v = doc.get(column, "")
+            if isinstance(v, str) and newline != "\n":
+                v = v.rstrip("\n").replace("\n", newline)
+            return v
+
+        return extract_col
+
+    return compile_expr(column)
+
+
+def select(lines, columns, skip_empty=False, separator="\t", newline="\n"):
+    """Yields the content of the requested columns."""
+    column_parsers = [compile_column(c, newline) for c in columns]
+    for doc in read_jsons(lines):
+        values = []
+        empty = True
+        for parse_col in column_parsers:
+            v = parse_col(doc)
+            values.append(str(v) or "")
+            empty = empty and v is None
+
+        if skip_empty and empty:
+            continue
+
+        yield separator.join(values)
+
+
+def compile_expr(clause: Union[str, FilterFn], requires: List[str] = None):
+    if not isinstance(clause, str):
+        return clause
+
+    args_re = r"(?i:\{([_a-z][_a-z0-9]*)\})"
+    args_list = list(re.findall(args_re, clause))
+    if not args_list:
+        # This is only a warning because you may want to have eg random sampling
+        # that doesn't depend on the document.
+        logging.warn(
+            f"Warning: No variable found in expression: <{clause}>\n"
+            "Variables should be written inside braces, eg: {language}=='en'"
+        )
+    python_like = re.sub(args_re, r"doc.get('\1', None)", clause)
+    requires = requires or []
+    modules = {r: importlib.import_module(r) for r in requires}
+    return eval(f"lambda doc: {python_like}", modules)
+
+
+class where(Transformer):
+    """Filters the data using python code.
+
+    Ex: `jsonql where 'len({text}) > 100'`
+    """
+
+    def __init__(
+        self, clauses: Sequence[Union[str, FilterFn]], requires: List[str] = []
+    ):
+        super().__init__()
+        self.raw_clauses = clauses
+        self.requires = requires
+        self.n_selected = 0
+        self.clauses: List[FilterFn] = []
+
+    def _prepare(self):
+        self.clauses = [compile_expr(c, self.requires) for c in self.raw_clauses]
+
+    def do(self, doc: dict) -> Optional[dict]:
+        assert self.clauses
+        if not doc or not all((c(doc) for c in self.clauses)):
+            return None
+        self.n_selected += 1
+        return doc
+
+    def summary(self):
+        n_selected, n_docs = self.n_selected, self.processed
+        selectivity = n_selected / n_docs if n_docs else 0
+        return [f"Selected {n_selected} documents out of {n_docs} ({selectivity:5.1%})"]
+
+
+def merge(lines, columns, separator="\t", newline=NEWLINE):
+    """Reads tab separated columns and output a json using the given headers.
+
+    Headers are of form {key}[%{type}]
+    {type} can be one of {"f": float, "i": int, "b": bool, "s": string}.
+    Default type is string.
+    A special header "_" means interpret this column as json, and append all other
+    columns to it. Must appear only once and on last position.
+
+    Ex:
+    `echo '1\thello' | jsonql merge n t` --> `{"n": "1", "t": "hello"}`
+    `echo '1\thello" | jsonql merge n%i t` --> `{"n": 1, "t": "hello"}`
+    `echo '1\thello\t{"f": "bar"}' | jsonql merge n%i t _` --> `{"n": 1, "t": "hello", "f": "bar"}`
+    """
+    handle_newlines = lambda s: s.replace(newline, "\n")
+    type_mapping: Dict[str, Callable] = {
+        "f": float,
+        "i": int,
+        "b": bool,
+        "s": handle_newlines,
+    }
+    type_parsing = [
+        type_mapping.get(f.split("%")[-1], handle_newlines) for f in columns
+    ]
+    columns = [f.split("%")[0] for f in columns]
+    doc_index = columns.index("_") if "_" in columns else -1
+    read_json = JsonReader()
+
+    def parse(line):
+        parts = line.split(separator, len(columns) - 1)
+        doc: Dict[str, tp.Any] = {}
+        for i, value in enumerate(parts):
+            if columns[i] == "_":
+                doc.update(read_json(parts[doc_index]))
+            else:
+                try:
+                    doc[columns[i]] = type_parsing[i](value)
+                except ValueError:
+                    logging.error(
+                        f"Error when parsing column {i} of line: {line[:100]}..."
+                    )
+        return doc
+
+    for line in lines:
+        yield json.dumps(parse(line))
+
+
+class split(Transformer):
+    """Split a files in several smaller files based on the value of a field."""
+
+    # Not parallelisable since we are writing to files.
+    parallelisable = False
+
+    def __init__(
+        self,
+        pattern: Union[Path, str] = None,
+        split_fn: Callable[[dict], str] = None,
+        mkdir: bool = False,
+    ):
+        super().__init__()
+        assert not (
+            pattern and split_fn
+        ), "split can't have both a pattern and a split_fn"
+        if split_fn is not None:
+            self.split_fn = split_fn
+        else:
+            assert pattern, "split need either a pattern or a split_fn"
+            self.split_fn = self.make_split_fn(str(pattern))
+        self.mkdir = mkdir
+        self.o: dict = {}
+
+    def make_split_fn(self, pattern: str) -> Callable[[dict], str]:
+        candidates = list(re.findall(r"(?i:\{([_a-z][_a-z0-9]*)\})", pattern))
+        return lambda doc: pattern.format(**{c: doc[c] for c in candidates})
+
+    def do(self, doc):
+        filename = self.split_fn(doc)
+        if not filename:
+            return
+        o = self.o.get(filename, None)
+        if o is None:
+            if self.mkdir:
+                Path(filename).parent.mkdir(parents=True, exist_ok=True)
+            self.o[filename] = open_write(filename)
+        print(json.dumps(doc, ensure_ascii=False), file=self.o[filename], flush=True)
+
+    def summary(self):
+        summ = super().summary()
+        summ.append(f"Found {len(self.o)} splits.")
+        return summ
+
+    def close(self):
+        for file in self.o.values():
+            file.close()
+
+
+def histogram(values, bins, weights):
+    hist, bins = np.histogram(values, bins=bins)
+    # n_bins = len(hist)
+
+    if weights is not None:
+        # Bins can't be auto-determined if weights is supplied.
+        # So we first compute the bins without the weights then recompute
+        # the histogram with the weights.
+        hist, bins = np.histogram(values, bins=bins, weights=weights)
+    # cumsum = np.cumsum(hist)
+    # total = cumsum[-1]
+
+    # for i in range(n_bins - 1):
+    #     if cumsum[i] / total > 0.9:
+    #         useful_range = np.linspace(bins[0], bins[i + 1], n_bins)
+    #         new_bins = np.append(useful_range, [bins[-1]])
+    #         return np.histogram(values, bins=new_bins, weights=weights)
+
+    return hist, bins
+
+
+def _parse_bins(bins):
+    try:
+        if isinstance(bins, str):
+            if "," in bins:
+                bins = [int(b) for b in bins.split(",")]
+            else:
+                bins = int(bins)
+    except ValueError:
+        pass
+    return bins
+
+
+ALL_DOCUMENTS = "<ALL_DOCUMENTS>"
+MAX_LABEL_LEN = 100
+
+
+def bar_chart(hist, bins):
+    n = sum(hist)
+    max_h = max(hist)
+    out = []
+    for i, h in enumerate(hist):
+        h_size = 80 * h // max_h
+        dh_size = 80 * (h - hist[i - 1]) // max_h
+        if h_size == 0 or dh_size == 0:
+            continue
+        bar = "█" * h_size
+        out.append(f"{bins[i]:8.3f} {bar:80} ({h:5d}, {h / n:5.1%}) {bins[i+1]:8.3f}")
+    out.append(f"{bins[-1]:8.3f}")
+    return out
+
+
+def display_stats(stats, key, weights=None, bins="auto", cumulative=False):
+    out = []
+    documents = stats[ALL_DOCUMENTS]
+    count = stats.get(key, 0)
+    r = count / documents if documents else 0
+    out.append(f"Field {key} saw {count} times ({r:5.1%})")
+
+    length = stats.get(key + ".length", None)
+    avg_length = length // count if length else 0
+    if length is not None:
+        out[-1] += f", average length is {length // count}"
+
+    values = stats.get(key + ".val", None)
+    if values:
+        out[-1] += f", histogram is: (bins={bins})"
+        if weights:
+            if weights not in stats:
+                logging.warn(f"Warning: weights column {weights} not found.")
+            if weights + ".val" not in stats:
+                logging.warn(
+                    f"Warning: weights column {weights} is not a numeric column."
+                )
+            weights = stats.get(weights + ".val")
+        hist, bins = histogram(values, _parse_bins(bins), weights)
+        if cumulative:
+            hist = np.cumsum(hist)
+        out += bar_chart(hist, bins)
+
+    cnt = stats.get(key + ".cnt", None)
+    if avg_length < MAX_LABEL_LEN and cnt and max(cnt.values()) > 1:
+        cnt = sorted(cnt.items(), key=lambda kv: kv[1], reverse=True)
+        out[-1] += ", top 100 labels:"
+        for label, n in cnt[:100]:
+            if n < 5:
+                continue
+            out.append(f"{label:25}: {n:6} ({n / count:5.1%})")
+
+    return out
+
+
+def describe(source, columns=None, weights=None, **kwargs):
+    """Compute some statistics about a dataset.
+
+    Stats can be restricted to a subset of columns."""
+    MAX_HIST_SIZE = 100_000_000
+    MAX_CNT_SIZE = 1000
+    stats = {ALL_DOCUMENTS: 0}
+    needed = columns + [weights] if columns else None
+
+    for doc in read_jsons(source):
+        stats[ALL_DOCUMENTS] += 1
+        for k, v in doc.items():
+            if needed and k not in needed:
+                continue
+            stats[k] = get_or_set(stats, k, 0) + 1
+            if isinstance(v, str):
+                stats[k + ".length"] = get_or_set(stats, k + ".length", 0) + len(v)
+                if len(v) > MAX_LABEL_LEN:  # Don't treat too long string as labels
+                    continue
+                cnt = get_or_set(stats, k + ".cnt", collections.defaultdict(int))
+                if v in cnt or len(cnt) < MAX_CNT_SIZE:
+                    cnt[v] += 1
+            elif type(v) in (int, float):
+                values = get_or_set(stats, k + ".val", [])
+                if len(values) < MAX_HIST_SIZE:
+                    values.append(v)
+            elif type(v) is list and len(v) and type(v[0]) in (int, float):
+                values = get_or_set(stats, k + ".val", [])
+                if len(values) < MAX_HIST_SIZE:
+                    values += v
+            elif type(v) is dict:
+                cnt = get_or_set(stats, k + ".cnt", collections.defaultdict(int))
+                for label in v:
+                    if label in cnt or len(cnt) < MAX_CNT_SIZE:
+                        cnt[label] += 1
+
+    documents = stats[ALL_DOCUMENTS]
+    yield f"Stats computed on {documents} documents:"
+    for k in stats:
+        if columns and k not in columns:
+            continue
+        if "." in k or k == ALL_DOCUMENTS:
+            continue
+        for line in display_stats(stats, k, weights=weights, **kwargs):
+            yield line
+
+
+def shard(lines):
+    """Shard a file in several smaller ones."""
+    # The creation of the shard is handle in a generic way. Do we need this ?
+    return lines
+
+
+# *** Utils ***
+
+
+def get_or_set(dictionary, key, default):
+    if key not in dictionary:
+        dictionary[key] = default
+    return dictionary[key]
+
+
+class SimpleIO(Protocol):
+    """A subset of methods from TextIO."""
+
+    def close(self) -> None:
+        ...
+
+    def write(self, line: str) -> int:
+        ...
+
+    def __enter__(self) -> "SimpleIO":
+        ...
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        ...
+
+
+def open_read(filename: ReadableFileLike) -> Iterable[str]:
+    """Open the given file, list of files or files matching the given glob and read lines.
+
+    `filename` is None or "-" -> reads from stdin
+    `filename` is a Path / str -> interprets filename as a glob and open files matching it
+    `filename` is a list -> opens sequentially all files from the list using `open_read`
+    `filename` is something else -> returns the object wrapped in a `nullcontext`
+        This allows to pass already openened files or iterables.
+
+    `open_read` will decompress gzip files, given they have ".gz" suffix.
+    """
+    if filename is None:
+        return sys.stdin
+
+    if isinstance(filename, list):
+        assert isinstance(filename[0], Path)
+        if len(filename) == 0:
+            return []
+        if len(filename) > 1:
+            return _yield_from(filename)
+        filename = tp.cast(Path, filename[0])
+    if isinstance(filename, str):
+        if filename.startswith("http://") or filename.startswith("https://"):
+            return open_remote_file(filename)
+
+        filename = Path(filename)
+    if not isinstance(filename, Path):
+        # we might have received an iterable, return it unmodified.
+        return filename  # type: ignore
+
+    # Expand glob patterns only when reading
+    files = [Path(f) for f in sorted(glob.glob(str(filename)))]
+    if len(files) > 1:
+        return _yield_from(files)
+    if len(files) == 1:
+        filename = files[0]
+
+    assert isinstance(filename, Path)
+
+    if filename.name.endswith("]"):
+        return block_reader(filename)
+
+    logging.getLogger(__name__).info(f"Opening {filename} with mode 'rt'")
+    if filename.suffix == ".gz":
+        file: TextIO = gzip.open(filename, "rt")  # type: ignore
+    else:
+        file = open(filename, "rt")
+
+    return _close_when_exhausted(file)
+
+
+def _close_when_exhausted(file: TextIO) -> Iterable[str]:
+    with file:
+        yield from file
+
+
+def _yield_from(files: list) -> Iterable[str]:
+    for file in files:
+        yield from open_read(file)
+
+
+def open_write(
+    filename: WritableFileLike, max_size: str = "4G"
+) -> tp.ContextManager[TextIO]:
+    """Open the given file, list of files or files matching the given glob.
+
+    The return value is a ContextManager meant to be used inside a `with` block:
+    ```
+    with open_write("foo.txt") as o:
+        ...
+
+    Write mode:
+        replaces "?" from filename by numbers ranging from 0 to 9, generatings files of size `max_size`.
+        If filename ends with ".gz", creates a blocked gzip file with random access.
+    """
+    if filename is None:
+        return contextlib.nullcontext(sys.stdout)
+
+    if isinstance(filename, list):
+        if len(filename) > 1:
+            return MultiFile(filename, "w", max_size)
+        else:
+            filename = tp.cast(Path, filename[0])
+    if isinstance(filename, str):
+        filename = Path(filename)
+    if not isinstance(filename, Path):
+        assert hasattr(filename, "write"), f"{filename} doesn't have a .write method."
+        # We return a 'TextIO' even though we only check for `.write` method,
+        # this works better with eg `print`.
+        return contextlib.nullcontext(tp.cast(TextIO, filename))
+
+    mode = "wt"
+    if "?" in filename.name:
+        return sharded_file(filename, mode, max_size)
+
+    logging.getLogger(__name__).info(f"Opening {filename} with mode {mode}")
+    # TODO: should we use another format ?
+    if filename.suffix == ".gz":
+        return BlockedGzipWriter(Path(filename), mode, block_size="64M")
+
+    return open(filename, "wt")
+
+
+def parse_size(size):
+    unit_map = {"B": 1, "K": 1024, "M": 1024 ** 2, "G": 1024 ** 3}
+    unit = size[-1].upper()
+    assert (
+        unit in unit_map
+    ), f"Unsupported size unit for {size}. Use one of: {unit_map.keys()}."
+    return int(size[:-1]) * unit_map[unit]
+
+
+class MultiFile(SimpleIO):
+    def __init__(self, files: Iterable[Path], mode="w", max_size="4G"):
+        self.name = str(files)
+        self.mode = mode
+        self.files = iter(files)
+        self.max_size = parse_size(max_size)
+        self.current_handle: Optional[TextIO] = None
+        self.current_block_size = 0
+        self._open_next_handle()  # Opening 1st handle allows to write directly.
+
+    def write(self, content) -> int:
+        # Avoid splitting newlines to a new file.
+        # use current_block_size since it's faster than `tell()`
+        if content != "\n" and self.current_block_size >= self.max_size:
+            self._open_next_handle()
+        if self.current_handle is None:
+            raise Exception("No more files to write to...")
+
+        written = self.current_handle.write(content)
+        self.current_block_size += written
+        return written
+
+    def _open_next_handle(self) -> bool:
+        self.close()
+        file = next(self.files, None)
+        if file is None:
+            return False
+
+        self.current_handle = open_write(file).__enter__()
+        self.current_block_size = 0
+        return True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.close()
+
+    @property
+    def closed(self):
+        return self.current_handle is None
+
+    def close(self):
+        if self.current_handle is None:
+            return
+
+        # log("Closing", self.current_handle.name, "with mode", self.current_handle.mode)
+        self.current_handle.__exit__(None, None, None)
+        self.current_handle = None
+
+
+# not sure it helps since connections are reseted anyway.
+_session = functools.lru_cache()(requests.Session)
+
+
+def request_get_content(url: str, n_retry: int = 3) -> bytes:
+    """Retrieve the binary content at url.
+
+    Retry on connection errors.
+    """
+    t0 = time.time()
+    logging.info(f"Starting download of {url}")
+    for i in range(1, n_retry + 1):
+        try:
+            r = _session().get(url)
+            r.raise_for_status()
+            break
+        except requests.exceptions.RequestException as e:
+            # Sleep and try again on error, unless it's a 404.
+            message = e.args[0] if isinstance(e.args[0], str) else ""
+            if i == n_retry or "Client Error" in message:
+                raise e
+            warnings.warn(
+                f"Swallowed error {e} while downloading {url} ({i} out of {n_retry})"
+            )
+            time.sleep(10 * 2 ** i)
+    dl_time = time.time() - t0
+    dl_speed = len(r.content) / dl_time / 1024
+    logging.info(
+        f"Downloaded {url} [{r.status_code}] took {dl_time:.0f}s ({dl_speed:.1f}kB/s)"
+    )
+    return r.content
+
+
+def open_remote_file(url: str, cache: Path = None) -> Iterable[str]:
+    """Download the files at the given url to memory and opens it as a file.
+    Assumes that the file is small, and fetch it when this function is called.
+    """
+    if cache and cache.exists():
+        return open_read(cache)
+
+    # TODO: open the remote file in streaming mode.
+    # The hard part is that we need to write the content on disk at the same time,
+    # to implement disk caching.
+    raw_bytes = request_get_content(url)
+    content = io.BytesIO(raw_bytes)
+    if url.endswith(".gz"):
+        f: TextIO = gzip.open(content, mode="rt")  # type: ignore
+    else:
+        f = io.TextIOWrapper(content)
+
+    if cache and not cache.exists():
+        # The file might have been created while downloading/writing.
+        tmp_cache = _tmp(cache)
+        tmp_cache.write_bytes(raw_bytes)
+        if not cache.exists():
+            tmp_cache.replace(cache)
+        else:
+            tmp_cache.unlink()
+
+    return _close_when_exhausted(f)
+
+
+def sharded_file(file_pattern: Path, mode: str, max_size: str = "4G") -> MultiFile:
+    folder, name = file_pattern.parent, file_pattern.name
+    assert "?" in name, f"Can't expand give file_pattern: {file_pattern}"
+
+    n = name.count("?")
+    assert 0 < n < 8
+    assert "?" * n in name, f"The '?' need to be adjacents in {file_pattern}"
+    assert "r" not in mode
+    files = (folder / name.replace("?" * n, f"%0{n}d" % i) for i in range(10 ** n))
+
+    return MultiFile(files, mode, max_size)
+
+
+class SplitFile:
+    def __init__(self, filename: Path, chunk: int, n_chunks: int, mode: str = "r"):
+        assert mode == "r"
+        size = os.path.getsize(filename)
+        self.handle = open(filename, mode)
+        start = chunk * size // n_chunks
+        self.end: int = (chunk + 1) * size // n_chunks
+
+        if start > 0:
+            self.handle.seek(start - 1)
+            # Skip incomplete line. This avoid crashing when reading eg the middle
+            # of a unicode char. `self.handle.buffer` is a binary file reader.
+            self.handle.buffer.readline()  # type: ignore
+
+    def __enter__(self):
+        return self
+
+    def __iter__(self):
+        while True:
+            line = self.handle.readline()
+            if not line:
+                return
+
+            yield line
+            if self.handle.tell() >= self.end:
+                return
+
+    def readlines(self):
+        return list(self.__iter__())
+
+    def close(self):
+        self.handle.close()
+
+    def __exit__(self, *args):
+        self.close()
+
+
+def get_block_readers(filename: Path, n_readers, mode="t"):
+    index_filename = filename.parent / (filename.name + ".index")
+    if not index_filename.exists():
+        return [gzip.open(filename, "r" + mode)]
+    index: List[int] = np.load(index_filename)
+    n_chunks = len(index)
+    chunk_per_reader = int(np.ceil(n_chunks / n_readers))
+    n_readers = int(np.ceil(n_chunks / chunk_per_reader))
+
+    start = 0
+    readers = []
+    for i in range(n_readers):
+        end = index[min((i + 1) * chunk_per_reader - 1, n_chunks - 1)]
+        r = _blocked_gzip_reader(filename, start, end, mode)
+        readers.append(r)
+        start = end
+    return readers
+
+
+def block_reader(filename: Path) -> Iterable[str]:
+    root, pattern = str(filename)[:-1].split("[", 1)
+    assert root.endswith(".gz"), "Can only read block of a .gz file for now."
+
+    ii, nn = pattern.strip().split("/")
+    i, n_readers = int(ii), int(nn)
+
+    index_filename = root + ".index"
+    assert os.path.exists(
+        index_filename
+    ), f"Index {index_filename} not found for {filename}"
+    index: List[int] = np.load(index_filename)
+    n_chunks = len(index)
+    chunk_per_reader = int(np.ceil(n_chunks / n_readers))
+    n_readers = int(np.ceil(n_chunks / chunk_per_reader))
+    # I'm not sure how to handle the case where there is less reader than expected.
+    # Currently we return empty readers.
+
+    start = 0
+    if i > 0:
+        start = index[min((i - 1) * chunk_per_reader, n_chunks - 1)]
+    end = index[min(i * chunk_per_reader, n_chunks - 1)]
+    return _blocked_gzip_reader(root, start, end, mode="t")
+
+
+def _blocked_gzip_reader(filename, start, end, mode="t") -> Iterable[str]:
+    handle = gzip.open(filename, "r" + mode)
+    handle.seek(start)
+    try:
+        while handle.tell() < end:
+            line = handle.readline()
+            if not line:
+                break
+            yield line
+    finally:
+        handle.close()
+
+
+class BlockedGzipWriter(MultiFile):
+    """Writes a Gzip files which can be read by block.
+
+    Decreasing the block size may hurt compression, but provides more split points.
+    """
+
+    def __init__(self, filename: Path, mode: str, block_size: str = "256M"):
+        assert "w" in mode
+        self.filename = Path(filename)
+        self.index: List[int] = []
+        self.zipfile: Optional[gzip.GzipFile] = None
+        super().__init__([], mode, block_size)
+
+    def _open_next_handle(self) -> bool:
+        """Here we never actually close/open handles,
+        we just write the end of block sequence."""
+        if not self.current_handle:
+            mode = self.mode + "t"
+            self.current_handle = tp.cast(TextIO, gzip.open(self.filename, mode))
+            assert isinstance(self.current_handle.buffer, gzip.GzipFile)
+            self.zipfile = self.current_handle.buffer
+            return True
+
+        # Use Z_FULL_FLUSH to allow random access:
+        # https://github.com/madler/zlib/blob/cacf7f1d4e3d44d871b605da3b647f07d718623f/zlib.h#L313
+        self.current_handle.buffer.flush(zlib_mode=zlib.Z_FULL_FLUSH)  # type: ignore
+        self.index.append(self.current_handle.tell())
+        self.current_block_size = 0
+        return True
+
+    def flush(self):
+        assert self.current_handle is not None
+        self.current_handle.flush()
+
+    def close(self):
+        if self.current_handle is None:
+            return
+        self.current_handle.flush()
+        self.index.append(self.current_handle.tell())
+        self.current_handle.close()
+        self.current_handle = None
+        index = np.array(self.index, dtype=np.uint64)
+        with open(str(self.filename) + ".index", "wb") as o:
+            np.save(o, index)
+
+
+def grouper(iterable, n):
+    group = []
+    for x in iterable:
+        group.append(x)
+        if len(group) == n:
+            yield group
+            group = []
+    if group:
+        yield group
+
+
+PROCESS = psutil.Process()
+
+
+def mem_footprint_gb(pid=None):
+    rss = PROCESS.memory_info().rss
+    return rss / 1_000_000_000
+
+
+def _tmp(output: Path) -> Path:
+    suffix = "".join(output.suffixes)
+    suffix = ".tmp" + suffix
+    prefix = output.name[: -len(suffix)]
+    _, tmp_path = tempfile.mkstemp(dir=output.parent, prefix=prefix, suffix=suffix)
+    return Path(tmp_path)
+
+
+@functools.lru_cache()
+def _tmp_dir() -> Path:
+    job_id = os.environ.get("SLURM_JOB_ID")
+    if job_id:
+        return Path("/scratch/slurm_tmpdir") / job_id
+
+    checkpoint = Path("/checkpoint") / os.environ.get("USER", "")
+    if checkpoint.exists():
+        tmp = checkpoint / "tmp"
+        tmp.mkdir(exist_ok=True)
+        return tmp
+
+    return Path("/tmp")
+
+
+if __name__ == "__main__":
+    multiprocessing.set_start_method("fork")
+    main(sys.argv[1:])

cc-multilingual-main/cc_net/cc_net/mine.py

@@ -0,0 +1,648 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Main script to download a CC dump, remove duplicates, split by language and
+filter the documents.
+
+The pipeline parameters are described in the `Config` class.
+"""
+
+import hashlib
+import json
+import time
+import warnings
+from argparse import ArgumentParser
+from collections import defaultdict
+from itertools import repeat
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Sequence, Tuple
+
+import func_argparse
+
+# Local scripts
+from cc_net import dedup, execution, jsonql, minify, perplexity, process_wet_file
+from cc_net import regroup as regroup_module
+from cc_net import split_by_lang
+from cc_net.execution import Executor
+
+# Constant
+FILE_DIR = Path(__file__).parent
+CUTOFF_CSV = FILE_DIR / "data" / "cutoff.csv"
+
+DEFAULT_PIPELINE = [
+    # "dedup",
+    "lid",
+    "keep_lang",
+    "sp",
+    "lm",
+    "pp_bucket",
+    "drop",
+    "split_by_lang",
+]
+
+
+class Config(NamedTuple):
+    """
+    Mine Common Crawl with the given settings.
+
+    config_name
+    dump: CC dump id
+    output_dir: working directory
+    mined_dir: name of the destination folder, full path will be {ouput_dir}/{mined_dir}/{dump_id}
+    execution: chose how to parallelize the execution
+    num_shards: number of shards to split the dump
+    num_segments_per_shard: allow to download a small portion of CC (eg for tests)
+    min_len: remove documents shorter than this (in chars)
+    hashes_in_mem: number of shards hashes to use for dedup
+    lang_whitelist: only treat those languages
+    lang_blacklist: ignore those languages
+    lang_threshold: remove docs whose top language score is lower than this
+    keep_bucket: keep only those perplexity bucket chose from (head, middle, tail, all)
+    lm_dir: folder containing LMs
+    lm_languages: only use LMs for the following languages
+    cutoff: cutoff file to use for split in head/middle/tail
+    mine_num_processes: number of processes to use for mining
+    target_size: size of finals files produce during `regroup` stage
+    cleanup_after_regroup: delete intermediary files after regroup
+    task_parallelism: max number of task to run in parallel
+    pipeline: restricts the mining pipeline to the given steps. Order is important !
+    experiments: (HACK) enable specific experiments in the code
+    """
+
+    config_name: str = "base"
+    dump: str = "2017-51"
+    output_dir: Path = Path("data")
+    mined_dir: str = "mined"
+    execution: str = "auto"
+    num_shards: int = 1600
+    num_segments_per_shard: int = -1
+    metadata: Optional[str] = None
+    min_len: int = 300
+    hash_in_mem: int = 50
+    lang_whitelist: Sequence[str] = ['hi']
+    lang_blacklist: Sequence[str] = []
+    lang_threshold: float = 0.5
+    keep_bucket: Sequence[str] = []
+    lm_dir: Path = Path("data/lm_sp")
+    cutoff: Path = CUTOFF_CSV
+    lm_languages: Optional[Sequence[str]] = None
+    mine_num_processes: int = 16
+    target_size: str = "4G"
+    cleanup_after_regroup: bool = False
+    task_parallelism: int = -1
+    pipeline: Sequence[str] = DEFAULT_PIPELINE
+    experiments: Sequence[str] = []
+    cache_dir: Optional[Path] = None
+
+    def get_executor(
+        self, name: str, timeout_hour: int = 1, mem_gb: int = 1, cpus: int = 1
+    ) -> Executor:
+        name = "_".join((name, self.config_name, *self.experiments))
+        return execution.get_executor(
+            name,
+            self.output_dir / "logs",
+            self.execution,
+            timeout_hour=timeout_hour,
+            mem_gb=mem_gb,
+            cpus=cpus,
+            task_parallelism=self.task_parallelism,
+        )
+
+    def get_cc_shard(self, shard: int) -> process_wet_file.CCShardReader:
+        dump_cache: Optional[Path] = None
+        if self.cache_dir:
+            self.cache_dir.mkdir(exist_ok=True)
+            dump_cache = self.cache_dir / self.dump
+            dump_cache.mkdir(exist_ok=True)
+
+        return process_wet_file.CCShardReader(
+            self.dump,
+            shard=shard,
+            num_shards=self.num_shards,
+            num_segments_per_shard=self.num_segments_per_shard,
+            min_len=self.min_len,
+            cache_dir=dump_cache,
+        )
+
+    @classmethod
+    def from_json(cls, json_file: Path) -> "Config":
+        raw_lines = json_file.read_text().splitlines()
+        raw_lines = [l for l in raw_lines if not l.strip().startswith("//")]
+        json_config = json.loads("".join(raw_lines))
+        path_keys = ["cache_dir", "lm_dir", "output_dir"]
+        for key in path_keys:
+            if key in json_config:
+                json_config[key] = Path(json_config[key])
+        return Config(**json_config)
+
+    @property
+    def will_split(self) -> bool:
+        return "split_by_lang" in self.pipeline or "split_by_segment" in self.pipeline
+
+    def get_lm_languages(self) -> Sequence[str]:
+        if self.lm_languages is not None:
+            return self.lm_languages
+
+        if self.lang_whitelist:
+            return self.lang_whitelist
+
+        languages = [m.name.split(".")[0] for m in self.lm_dir.glob("*.arpa.bin")]
+        if self.lang_blacklist:
+            languages = [l for l in languages if l not in self.lang_blacklist]
+        return languages
+
+    def get_mined_dir(self, regroup: bool = False) -> Path:
+        if self.will_split and not regroup:
+            return self.output_dir / f"{self.mined_dir}_split" / self.dump
+        return self.output_dir / self.mined_dir / self.dump
+
+
+BASE_CONFIG = Config()
+
+BYLANG_CONFIG = Config(
+    config_name="by_lang",
+    mined_dir="mined_by_lang",
+    pipeline=list(BASE_CONFIG.pipeline[:-1]) + ["split_by_lang"],
+)
+
+REPRODUCE_CONFIG = Config(
+    config_name="reproduce",
+    dump="2019-09",
+    mined_dir="reproduce",
+    pipeline=["fetch_metadata", "keep_lang", "keep_bucket", "split_by_lang"],
+    metadata="https://dl.fbaipublicfiles.com/cc_net/1.0.0",
+    # Optional filtering:
+    # It won't change much the execution speed, but decreases the disk requirement.
+    # Restrict languages
+    lang_whitelist=["fr"],
+    # Restrict perplexity buckets
+    # Top languages have been split in perplexity buckets according
+    # to a Wikipedia trained LM.
+    # The buckets from low perplexity (good) to high (bad) are:
+    # ["head", "middle", "tail"]
+    # Languages without a LM have only one bucket "all".
+    # It won't change much the execution speed, but decreases the disk requirement.
+    keep_bucket=["head", "all"],
+    mine_num_processes=1,
+)
+
+TEST_CONFIG = BASE_CONFIG._replace(
+    config_name="test",
+    dump="2019-09",
+    output_dir=Path("test_data"),
+    execution="local",
+    num_shards=4,
+    num_segments_per_shard=1,
+    hash_in_mem=2,
+    mine_num_processes=2,
+    lang_whitelist=["de", "it", "fr"],
+    target_size="32M",
+    cleanup_after_regroup=False,
+    cache_dir=Path("test_data/wet_cache"),
+)
+
+PREDEF_CONFIGS = {
+    "base": BASE_CONFIG,
+    "by_lang": BYLANG_CONFIG,
+    "test": TEST_CONFIG,
+    "test_slurm": TEST_CONFIG._replace(execution="slurm,partition=dev"),
+    "debug": TEST_CONFIG._replace(config_name="debug", mine_num_processes=0),
+    "reproduce": REPRODUCE_CONFIG,
+    "augment": BASE_CONFIG._replace(
+        config_name="augment", dump="2019-13", lang_blacklist=["en"]
+    ),
+}
+
+
+def tmp(output: Path) -> Path:
+    return output.parent / (output.stem + ".tmp" + output.suffix)
+
+
+def finalize(tmp_output: Path, output: Path) -> None:
+    if not tmp_output.exists():
+        warnings.warn(f"Targeted tmp output {tmp_output} doesn't exists.")
+        return
+
+    tmp_index = tmp_output.parent / (tmp_output.name + ".index")
+    tmp_output.rename(output)
+
+    if tmp_index.exists():
+        tmp_index.rename(output.parent / (output.name + ".index"))
+
+
+def _transpose(iterable: Sequence[Tuple[Any, ...]], n=-1) -> Tuple[List, ...]:
+    if n < 0:
+        n = len(iterable[0])
+    columns: tuple = tuple([] for _ in range(n))
+    for row in iterable:
+        assert len(row) == n, f"Found tuple of len({len(row)}, expected {n}: {row}"
+        for i in range(n):
+            columns[i].append(row[i])
+
+    return columns
+
+
+def hashes(conf: Config) -> List[Path]:
+    """Computes hashes for each shard."""
+
+    hashes_dir = conf.output_dir / "hashes" / conf.dump
+    outputs = [hashes_dir / f"{shard:04d}.bin" for shard in range(conf.num_shards)]
+    missing_outputs = [(shard, o) for shard, o in enumerate(outputs) if not o.exists()]
+
+    if not missing_outputs:
+        return outputs
+
+    hashes_dir.mkdir(parents=True, exist_ok=True)
+    # With FlatHashSet we need ~2Gb of RAM / shard, but we need to account for
+    # overhead due to how the dynamic allocation works.
+    ex = conf.get_executor(f"hashes_{conf.dump}", mem_gb=4, timeout_hour=6, cpus=2)
+    ex(_hashes_shard, repeat(conf), *_transpose(missing_outputs))
+
+    # Wait a bit so that files appears on the disk.
+    time.sleep(20)
+    assert all(o.exists() for o in outputs)
+    return outputs
+
+
+def _hashes_shard(conf: Config, shard: int, output: Path):
+    tmp_output = tmp(output)
+    jsonql.run_pipes(
+        dedup.HashesCollector(field="raw_content", output=tmp_output),
+        inputs=conf.get_cc_shard(shard),
+    )
+    finalize(tmp_output, output)
+    return f"Hashed {output}"
+
+
+HASHES_IN_MEM = [0, 1, 2, 5, 10, 20, 50, 100, 200, 400]
+
+
+def mine(conf: Config) -> List[Path]:
+    """Remove dups, run LID and LMs, and split by lang and quality."""
+    mined_dir = conf.get_mined_dir()
+    if conf.will_split:
+        # Give a directories when splitting
+        outputs = [mined_dir / f"{shard:04d}" for shard in range(conf.num_shards)]
+    else:
+        # Files otherwise
+        outputs = [
+            mined_dir / f"{shard:04d}.json.gz" for shard in range(conf.num_shards)
+        ]
+
+    if "mini_again" in conf.experiments:
+        mined_dir = conf.output_dir / "mini_again" / conf.dump
+        outputs = [mined_dir / f"{shard:04d}" for shard in range(conf.num_shards)]
+
+    # TODO: try to reduce this / make it a function of "hash_in_mem" / num_langs
+    mem_gb = 60 + 1 * conf.hash_in_mem
+    timeout_hour = 5
+    if "hashes" in conf.experiments:
+        # HACK: used for generating paper figures
+        outputs = [
+            conf.output_dir / f"hashes_exp/{conf.dump}_0000_dedup{h:03d}.json.gz"
+            for h in HASHES_IN_MEM
+        ]
+        mem_gb = int(max(HASHES_IN_MEM) * 1.2)
+        timeout_hour = 8
+
+    missing_outputs = [(shard, o) for shard, o in enumerate(outputs) if not o.exists()]
+
+    if "mini_again" in conf.experiments:
+        missing_outputs = [
+            (shard, o)
+            for shard, o in enumerate(outputs)
+            if shard in [5, 139] and not o.exists()
+        ]
+
+    if not missing_outputs:
+        return outputs
+
+    mined_dir.mkdir(parents=True, exist_ok=True)
+    ex = conf.get_executor(
+        f"mine_{conf.dump}",
+        mem_gb=mem_gb,
+        timeout_hour=timeout_hour,
+        cpus=conf.mine_num_processes + 1,
+    )
+
+    # Compute hashes firsts.
+    if "dedup" in conf.pipeline:
+        hashes_groups = list(jsonql.grouper(hashes(conf), conf.hash_in_mem))
+        hashes_files: Iterable[List[Path]] = [
+            hashes_groups[shard // conf.hash_in_mem] for shard, o in missing_outputs
+        ]
+    else:
+        hashes_files = repeat([])
+
+    ex(_mine_shard, repeat(conf), hashes_files, *_transpose(missing_outputs))
+
+    assert all(o.exists() for o in outputs)
+    return outputs
+
+
+def _get_segment(tmp_output: Path, doc: dict) -> str:
+    segment: str = doc["cc_segment"].split("/")[-1]
+    return str(tmp_output / segment.replace(".warc.wet.gz", ".json.gz"))
+
+
+def _mine_shard(conf: Config, hashes: List[Path], shard: int, output: Path) -> str:
+    assert conf.pipeline
+    tmp_output = tmp(output)
+    if "hashes" in conf.experiments:
+        # HACK: used for generating paper figures
+        hashes_in_mem = shard
+        hashes = hashes[: HASHES_IN_MEM[hashes_in_mem]]
+        shard = 0
+    cc_shard = conf.get_cc_shard(shard)
+
+    steps: Dict[str, Optional[jsonql.Transformer]] = {}
+    lang_id = Path("bin") / "lid.bin"
+    steps["lid_before_dedup"] = split_by_lang.Classifier(
+        model=lang_id, field="raw_content", out_field="lid_before_dedup", top=5
+    )
+    steps["dedup"] = dedup.DuplicatesRemover(field="raw_content", hashes_files=hashes)
+
+    steps["lid"] = split_by_lang.Classifier(
+        model=lang_id,
+        field="raw_content",
+        out_field="language",
+        top=1,
+        threshold=conf.lang_threshold,
+    )
+    steps["lid_after_dedup"] = split_by_lang.Classifier(
+        model=lang_id, field="raw_content", out_field="lid_after_dedup", top=5
+    )
+
+    if conf.lang_blacklist:
+        steps["keep_lang"] = jsonql.where(
+            [lambda doc: doc.get("language") not in set(conf.lang_blacklist)]
+        )
+    elif conf.lang_whitelist:
+        steps["keep_lang"] = jsonql.where(
+            [lambda doc: doc.get("language") in set(conf.lang_whitelist)]
+        )
+    else:
+        steps["keep_lang"] = None
+
+    tok_field = "tokenized"
+    steps["sp"] = perplexity.MultiSentencePiece(
+        {l: conf.lm_dir / f"{l}.sp.model" for l in conf.get_lm_languages()},
+        field="raw_content",
+        output_field=tok_field,
+        normalize=True,
+    )
+    steps["lm"] = perplexity.DocLM(
+        {l: conf.lm_dir / f"{l}.arpa.bin" for l in conf.get_lm_languages()},
+        field=tok_field,
+        output_field="perplexity",
+        normalize=False,  # Normalization is done before SentencePiece
+        # load_method=kenlm.LoadMethod.PARALLEL_READ,
+    )
+    steps["pp_bucket"] = perplexity.PerplexityBucket(CUTOFF_CSV)
+    steps["drop"] = perplexity.DropKeys(tok_field)
+
+    steps["keep_bucket"] = None
+    if conf.keep_bucket:
+        steps["keep_bucket"] = jsonql.where(
+            [lambda doc: doc.get("bucket", "all") in conf.keep_bucket]
+        )
+
+    if "fetch_metadata" in conf.pipeline:
+        # TODO: better default
+        assert conf.metadata is not None
+        steps["fetch_metadata"] = minify.MetadataFetcher(
+            f"{conf.metadata}/{conf.dump}/"
+        )
+
+    steps["minify"] = minify.Minifier()
+
+    pattern = str(tmp_output / "{language}_{bucket}.json.gz")
+    steps["split_by_lang"] = jsonql.split(pattern=str(pattern), mkdir=True)
+
+    steps["split_by_segment"] = jsonql.split(
+        split_fn=lambda doc: _get_segment(tmp_output, doc), mkdir=True
+    )
+
+    pipeline = filter(None, (steps[s] for s in conf.pipeline))
+
+    jsonql.run_pipes(
+        *pipeline,
+        inputs=cc_shard,
+        processes=conf.mine_num_processes,
+        chunksize=100,
+        # The splitter takes care of writing to files.
+        output=tmp_output if not conf.will_split else None,
+    )
+    finalize(tmp_output, output)
+    return f"Mined {output}"
+
+
+def regroup(conf: Config, all_dirs: List[Path]) -> Path:
+    """Reshards each language/quality after 'mine'."""
+    regroup_dir = conf.get_mined_dir(regroup=True)
+    assert all_dirs
+    all_files = [f for d in all_dirs for f in d.glob("*.json.gz")]
+    if not all_files:
+        print(f"No .json.gz file found in {all_dirs[0]}")
+
+    splits: Dict[str, List[Path]] = defaultdict(list)
+    for f in all_files:
+        split = f.name.split(".")[0]
+        splits[split].append(f)
+
+    print(f"Identified {len(all_files)} files to regroup from {len(splits)} splits.")
+    inputs: List[List[Path]] = []
+    outputs: List[Path] = []
+    target_size = jsonql.parse_size(conf.target_size)
+    for split, files in splits.items():
+        cuts = list(regroup_module.determine_groups(files, target_size=target_size))
+        if not cuts:
+            continue
+
+        pattern = f"{split}_????.json.gz"
+        existing_outputs = sorted(regroup_dir.glob(pattern))
+
+        if not conf.cleanup_after_regroup:
+            # We still have all the inputs so it is safe to overwrite existing outputs.
+            assert len(existing_outputs) <= len(cuts)
+            existing_outputs = []
+
+        if len(existing_outputs) > 0 and len(cuts) == 1:
+            # append to existing file if size allows it.
+            new_size = (
+                sum(f.stat().st_size for f in cuts[0])
+                + existing_outputs[-1].stat().st_size
+            )
+            if new_size < target_size:
+                print(f"Will append {cuts[0]} to {existing_outputs[-1]}")
+                cuts[0].insert(0, existing_outputs.pop(-1))
+
+        n_existing = len(existing_outputs)
+        for i, cut in enumerate(cuts):
+            # avoid overwriting existing files.
+            j = i + n_existing
+            output = regroup_dir / f"{split}_{j:04}.json.gz"
+            inputs.append(cut)
+            outputs.append(output)
+        print(
+            str(regroup_dir / pattern),
+            "->",
+            len(cuts),
+            f"shards ({n_existing} already there).",
+        )
+
+    ex = conf.get_executor(f"regroup_{conf.dump}", mem_gb=1, timeout_hour=12, cpus=2)
+    ex(_regroup, repeat(conf), inputs, outputs)
+
+    return regroup_dir
+
+
+def _regroup(conf: Config, inputs: List[Path], output: Path) -> str:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    regroup_module.fast_reshard(
+        inputs, output, tmp=tmp(output), rm_original=conf.cleanup_after_regroup
+    )
+    return f"Regrouped {output}"
+
+
+def move_segments(conf: Config, all_dirs: Sequence[Path]) -> Path:
+    """Reshards each language/quality after 'mine'."""
+    # check that mining is over.
+    regroup_dir = conf.get_mined_dir(regroup=True)
+    assert all_dirs, "Received no dirs to move"
+    assert all(
+        d.is_dir() for d in all_dirs
+    ), f"move_segments was expecting dirs received files: {all_dirs[:10]}..."
+
+    regroup_dir.parent.mkdir(exist_ok=True)
+    regroup_dir.mkdir(exist_ok=True)
+    ex = conf.get_executor(f"moveseg_{conf.dump}", mem_gb=1, timeout_hour=1, cpus=2)
+
+    def _move_segments(subdir: Path, regroup_dir: Path) -> str:
+        n = 0
+        for f in subdir.iterdir():
+            if not f.is_file() or f.is_symlink():
+                continue
+            n += f.name.endswith(".json.gz")
+            new_name = regroup_dir / f.name
+            target = new_name.resolve()
+            assert f.resolve() != target
+            # this make the job idempotent.
+            f.rename(new_name)
+            f.symlink_to(target)
+
+        if n == 0:
+            return ""
+
+        return f"Moved {n} .json.gz files from {subdir} to {regroup_dir}"
+
+    ex(_move_segments, all_dirs, repeat(regroup_dir))
+    print(f"Results are in {regroup_dir}")
+    return regroup_dir
+
+
+def _validate_test(conf: Config, output_dir: Path, generate: bool = False):
+    stats: Dict[str, dict] = {}
+    for file in sorted(output_dir.glob("*.json.gz")):
+        fname = "/".join((file.parent.name, file.name))
+        # The order of documents is not guaranteed inside a shard,
+        lines = sorted(jsonql.open_read(file))
+        content = "\n".join(lines)
+        size = len(content)
+        checksum = hashlib.sha1(bytes(content, encoding="utf-8")).hexdigest()
+        # first_document = json.loads(lines[0])
+        stats[fname] = {"size": size, "checksum": checksum}
+
+    def dump(x):
+        return json.dumps(x, indent=2, ensure_ascii=False)
+
+    print("*** Stats ***")
+    stats_raw = dump(stats)
+    stats_file = FILE_DIR / "data" / "test_stats.json"
+    if generate:
+        print("Saving stats to", stats_file)
+        stats_file.write_text(stats_raw)
+        return
+
+    expected_stats: Dict[str, dict] = {}
+    if stats_file.exists():
+        expected_stats = json.loads(stats_file.read_text())
+
+    if expected_stats == stats:
+        print("Everything looks good !")
+        return
+
+    stats_file.with_suffix(".actual.json").write_text(stats_raw)
+    print("*** Expected Stats ***")
+    print(dump(expected_stats))
+
+    print("*** Diff ***")
+    for fname in sorted(expected_stats.keys()):
+        print(fname)
+        assert fname in expected_stats, "missing file " + fname
+        if expected_stats[fname]["size"] != stats[fname]["size"]:
+            print(
+                "  - Expected size",
+                expected_stats[fname]["size"],
+                ", size",
+                stats[fname]["size"],
+            )
+        if expected_stats[fname]["checksum"] != stats[fname]["checksum"]:
+            print(
+                "  - Expected checksum",
+                expected_stats[fname]["checksum"],
+                ", checksum",
+                stats[fname]["checksum"],
+            )
+
+
+def get_main_parser() -> ArgumentParser:
+    # Generates the 'main' parser by patching a 'Config' parser
+    p = func_argparse.func_argparser(Config)
+
+    # Override defaults value to None, so we know what was set by the user.
+    # Note that it will keep the original default values in the help message.
+    p.set_defaults(**{f: None for f in Config._fields})
+    p.add_argument("--config", type=str, default="base")
+    p.set_defaults(__command=main)
+    return p
+
+
+def main(config: str = "base", **config_as_dict: Any) -> None:
+    # Use the given 'config' as default value.
+    config_base = config
+    if config_base in PREDEF_CONFIGS:
+        conf = PREDEF_CONFIGS[config_base]
+    elif Path(config_base).exists():
+        conf = Config.from_json(Path(config_base))
+    else:
+        raise ValueError(
+            f"Invalid value {config_base} for --config. "
+            f"Choose from ({', '.join(PREDEF_CONFIGS)}) or give an existing .json file."
+        )
+    conf = conf._replace(**{k: v for (k, v) in config_as_dict.items() if v is not None})
+
+    print(f"Will run cc_net.mine.main with the following config:", conf)
+
+    all_files = mine(conf)
+    if conf.will_split:
+        assert all_files
+        assert all(d.is_dir() for d in all_files)
+        all_dirs = all_files
+        if "split_by_lang" in conf.pipeline:
+            # Only try regrouping if we split the shards.
+            regroup(conf, all_dirs)
+        elif "split_by_segment" in conf.pipeline:
+            # If we split by segment then regrouping is trivial, since segments appear in only one shard.
+            move_segments(conf, all_dirs)
+
+    if conf.config_name == "test":
+        _validate_test(conf, conf.get_mined_dir(regroup=True))
+
+
+if __name__ == "__main__":
+    func_argparse.parse_and_call(get_main_parser())