chore: import upstream snapshot with attribution

spacy/cli/__init__.py

@@ -0,0 +1,47 @@
+from wasabi import msg
+
+# Needed for testing
+from . import download as download_module  # noqa: F401
+from ._util import app, setup_cli  # noqa: F401
+from .apply import apply  # noqa: F401
+from .assemble import assemble_cli  # noqa: F401
+
+# These are the actual functions, NOT the wrapped CLI commands. The CLI commands
+# are registered automatically and won't have to be imported here.
+from .benchmark_speed import benchmark_speed_cli  # noqa: F401
+from .convert import convert  # noqa: F401
+from .debug_config import debug_config  # noqa: F401
+from .debug_data import debug_data  # noqa: F401
+from .debug_diff import debug_diff  # noqa: F401
+from .debug_model import debug_model  # noqa: F401
+from .download import download  # noqa: F401
+from .evaluate import evaluate  # noqa: F401
+from .find_function import find_function  # noqa: F401
+from .find_threshold import find_threshold  # noqa: F401
+from .info import info  # noqa: F401
+from .init_config import fill_config, init_config  # noqa: F401
+from .init_pipeline import init_pipeline_cli  # noqa: F401
+from .package import package  # noqa: F401
+from .pretrain import pretrain  # noqa: F401
+from .profile import profile  # noqa: F401
+from .project.assets import project_assets  # type: ignore[attr-defined]  # noqa: F401
+from .project.clone import project_clone  # type: ignore[attr-defined]  # noqa: F401
+from .project.document import (  # type: ignore[attr-defined]  # noqa: F401
+    project_document,
+)
+from .project.dvc import project_update_dvc  # type: ignore[attr-defined]  # noqa: F401
+from .project.pull import project_pull  # type: ignore[attr-defined]  # noqa: F401
+from .project.push import project_push  # type: ignore[attr-defined]  # noqa: F401
+from .project.run import project_run  # type: ignore[attr-defined]  # noqa: F401
+from .train import train_cli  # type: ignore[attr-defined]  # noqa: F401
+from .validate import validate  # type: ignore[attr-defined]  # noqa: F401
+
+
+@app.command("link", no_args_is_help=True, deprecated=True, hidden=True)
+def link(*args, **kwargs):
+    """As of spaCy v3.0, symlinks like "en" are not supported anymore. You can load trained
+    pipeline packages using their full names or from a directory path."""
+    msg.warn(
+        "As of spaCy v3.0, model symlinks are not supported anymore. You can load trained "
+        "pipeline packages using their full names or from a directory path."
+    )

spacy/cli/_util.py

@@ -0,0 +1,301 @@
+import os
+import sys
+from configparser import InterpolationError
+from contextlib import contextmanager
+from pathlib import Path
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    overload,
+)
+
+import srsly
+import typer
+from click import NoSuchOption
+from click.shell_completion import split_arg_string
+from thinc.api import ConfigValidationError, require_gpu
+from thinc.util import gpu_is_available
+from typer.main import get_command
+from wasabi import Printer, msg
+from weasel import app as project_cli
+
+from ..compat import Literal
+from ..util import (
+    ENV_VARS,
+    import_file,
+    logger,
+    registry,
+    run_command,
+)
+
+SDIST_SUFFIX = ".tar.gz"
+WHEEL_SUFFIX = "-py3-none-any.whl"
+
+PROJECT_FILE = "project.yml"
+COMMAND = "python -m spacy"
+NAME = "spacy"
+HELP = """spaCy Command-line Interface
+
+DOCS: https://spacy.io/api/cli
+"""
+PROJECT_HELP = f"""Command-line interface for spaCy projects and templates.
+You'd typically start by cloning a project template to a local directory and
+fetching its assets like datasets etc. See the project's {PROJECT_FILE} for the
+available commands.
+"""
+DEBUG_HELP = """Suite of helpful commands for debugging and profiling. Includes
+commands to check and validate your config files, training and evaluation data,
+and custom model implementations.
+"""
+BENCHMARK_HELP = """Commands for benchmarking pipelines."""
+INIT_HELP = """Commands for initializing configs and pipeline packages."""
+
+# Wrappers for Typer's annotations. Initially created to set defaults and to
+# keep the names short, but not needed at the moment.
+Arg = typer.Argument
+Opt = typer.Option
+
+app = typer.Typer(name=NAME, help=HELP, rich_markup_mode=None)
+benchmark_cli = typer.Typer(name="benchmark", help=BENCHMARK_HELP, no_args_is_help=True)
+debug_cli = typer.Typer(name="debug", help=DEBUG_HELP, no_args_is_help=True)
+init_cli = typer.Typer(name="init", help=INIT_HELP, no_args_is_help=True)
+
+app.add_typer(project_cli, name="project", help=PROJECT_HELP, no_args_is_help=True)
+app.add_typer(debug_cli)
+app.add_typer(benchmark_cli)
+app.add_typer(init_cli)
+
+
+def setup_cli() -> None:
+    # Make sure the entry-point for CLI runs, so that they get imported.
+    registry.cli.get_all()
+    # Ensure that the help messages always display the correct prompt
+    command = get_command(app)
+    command(prog_name=COMMAND)
+
+
+def parse_config_overrides(
+    args: List[str], env_var: Optional[str] = ENV_VARS.CONFIG_OVERRIDES
+) -> Dict[str, Any]:
+    """Generate a dictionary of config overrides based on the extra arguments
+    provided on the CLI, e.g. --training.batch_size to override
+    "training.batch_size". Arguments without a "." are considered invalid,
+    since the config only allows top-level sections to exist.
+
+    env_vars (Optional[str]): Optional environment variable to read from.
+    RETURNS (Dict[str, Any]): The parsed dict, keyed by nested config setting.
+    """
+    env_string = os.environ.get(env_var, "") if env_var else ""
+    env_overrides = _parse_overrides(split_arg_string(env_string))
+    cli_overrides = _parse_overrides(args, is_cli=True)
+    if cli_overrides:
+        keys = [k for k in cli_overrides if k not in env_overrides]
+        logger.debug("Config overrides from CLI: %s", keys)
+    if env_overrides:
+        logger.debug("Config overrides from env variables: %s", list(env_overrides))
+    return {**cli_overrides, **env_overrides}
+
+
+def _parse_overrides(args: List[str], is_cli: bool = False) -> Dict[str, Any]:
+    result = {}
+    while args:
+        opt = args.pop(0)
+        err = f"Invalid config override '{opt}'"
+        if opt.startswith("--"):  # new argument
+            orig_opt = opt
+            opt = opt.replace("--", "")
+            if "." not in opt:
+                if is_cli:
+                    raise NoSuchOption(orig_opt)
+                else:
+                    msg.fail(f"{err}: can't override top-level sections", exits=1)
+            if "=" in opt:  # we have --opt=value
+                opt, value = opt.split("=", 1)
+                opt = opt.replace("-", "_")
+            else:
+                if not args or args[0].startswith("--"):  # flag with no value
+                    value = "true"
+                else:
+                    value = args.pop(0)
+            result[opt] = _parse_override(value)
+        else:
+            msg.fail(f"{err}: name should start with --", exits=1)
+    return result
+
+
+def _parse_override(value: Any) -> Any:
+    # Just like we do in the config, we're calling json.loads on the
+    # values. But since they come from the CLI, it'd be unintuitive to
+    # explicitly mark strings with escaped quotes. So we're working
+    # around that here by falling back to a string if parsing fails.
+    # TODO: improve logic to handle simple types like list of strings?
+    try:
+        return srsly.json_loads(value)
+    except ValueError:
+        return str(value)
+
+
+@contextmanager
+def show_validation_error(
+    file_path: Optional[Union[str, Path]] = None,
+    *,
+    title: Optional[str] = None,
+    desc: str = "",
+    show_config: Optional[bool] = None,
+    hint_fill: bool = True,
+):
+    """Helper to show custom config validation errors on the CLI.
+
+    file_path (str / Path): Optional file path of config file, used in hints.
+    title (str): Override title of custom formatted error.
+    desc (str): Override description of custom formatted error.
+    show_config (bool): Whether to output the config the error refers to.
+    hint_fill (bool): Show hint about filling config.
+    """
+    try:
+        yield
+    except ConfigValidationError as e:
+        title = title if title is not None else e.title
+        if e.desc:
+            desc = f"{e.desc}" if not desc else f"{e.desc}\n\n{desc}"
+        # Re-generate a new error object with overrides
+        err = e.from_error(e, title="", desc=desc, show_config=show_config)
+        msg.fail(title)
+        print(err.text.strip())
+        if hint_fill and "value_error.missing" in err.error_types:
+            config_path = (
+                file_path
+                if file_path is not None and str(file_path) != "-"
+                else "config.cfg"
+            )
+            msg.text(
+                "If your config contains missing values, you can run the 'init "
+                "fill-config' command to fill in all the defaults, if possible:",
+                spaced=True,
+            )
+            print(f"{COMMAND} init fill-config {config_path} {config_path} \n")
+        sys.exit(1)
+    except InterpolationError as e:
+        msg.fail("Config validation error", e, exits=1)
+
+
+def import_code(code_path: Optional[Union[Path, str]]) -> None:
+    """Helper to import Python file provided in training commands / commands
+    using the config. This makes custom registered functions available.
+    """
+    if code_path is not None:
+        if not Path(code_path).exists():
+            msg.fail("Path to Python code not found", code_path, exits=1)
+        try:
+            import_file("python_code", code_path)
+        except Exception as e:
+            msg.fail(f"Couldn't load Python code: {code_path}", e, exits=1)
+
+
+def get_git_version(
+    error: str = "Could not run 'git'. Make sure it's installed and the executable is available.",
+) -> Tuple[int, int]:
+    """Get the version of git and raise an error if calling 'git --version' fails.
+    error (str): The error message to show.
+    RETURNS (Tuple[int, int]): The version as a (major, minor) tuple. Returns
+        (0, 0) if the version couldn't be determined.
+    """
+    try:
+        ret = run_command("git --version", capture=True)
+    except:
+        raise RuntimeError(error)
+    stdout = ret.stdout.strip()
+    if not stdout or not stdout.startswith("git version"):
+        return 0, 0
+    version = stdout[11:].strip().split(".")
+    return int(version[0]), int(version[1])
+
+
+@overload
+def string_to_list(value: str, intify: Literal[False] = ...) -> List[str]: ...
+
+
+@overload
+def string_to_list(value: str, intify: Literal[True]) -> List[int]: ...
+
+
+def string_to_list(value: str, intify: bool = False) -> Union[List[str], List[int]]:
+    """Parse a comma-separated string to a list and account for various
+    formatting options. Mostly used to handle CLI arguments that take a list of
+    comma-separated values.
+
+    value (str): The value to parse.
+    intify (bool): Whether to convert values to ints.
+    RETURNS (Union[List[str], List[int]]): A list of strings or ints.
+    """
+    if not value:
+        return []  # type: ignore[return-value]
+    if value.startswith("[") and value.endswith("]"):
+        value = value[1:-1]
+    result = []
+    for p in value.split(","):
+        p = p.strip()
+        if p.startswith("'") and p.endswith("'"):
+            p = p[1:-1]
+        if p.startswith('"') and p.endswith('"'):
+            p = p[1:-1]
+        p = p.strip()
+        if intify:
+            p = int(p)  # type: ignore[assignment]
+        result.append(p)
+    return result
+
+
+def setup_gpu(use_gpu: int, silent=None) -> None:
+    """Configure the GPU and log info."""
+    if silent is None:
+        local_msg = Printer()
+    else:
+        local_msg = Printer(no_print=silent, pretty=not silent)
+    if use_gpu >= 0:
+        local_msg.info(f"Using GPU: {use_gpu}")
+        require_gpu(use_gpu)
+    else:
+        local_msg.info("Using CPU")
+        if gpu_is_available():
+            local_msg.info("To switch to GPU 0, use the option: --gpu-id 0")
+
+
+def walk_directory(path: Path, suffix: Optional[str] = None) -> List[Path]:
+    """Given a directory and a suffix, recursively find all files matching the suffix.
+    Directories or files with names beginning with a . are ignored, but hidden flags on
+    filesystems are not checked.
+    When provided with a suffix `None`, there is no suffix-based filtering."""
+    if not path.is_dir():
+        return [path]
+    paths = [path]
+    locs = []
+    seen = set()
+    for path in paths:
+        if str(path) in seen:
+            continue
+        seen.add(str(path))
+        if path.parts[-1].startswith("."):
+            continue
+        elif path.is_dir():
+            paths.extend(path.iterdir())
+        elif suffix is not None and not path.parts[-1].endswith(suffix):
+            continue
+        else:
+            locs.append(path)
+    # It's good to sort these, in case the ordering messes up cache.
+    locs.sort()
+    return locs
+
+
+def _format_number(number: Union[int, float], ndigits: int = 2) -> str:
+    """Formats a number (float or int) rounding to `ndigits`, without truncating trailing 0s,
+    as happens with `round(number, ndigits)`"""
+    if isinstance(number, float):
+        return f"{number:.{ndigits}f}"
+    else:
+        return str(number)

spacy/cli/apply.py

@@ -0,0 +1,145 @@
+from itertools import chain
+from pathlib import Path
+from typing import Iterable, List, Optional, Union, cast
+
+import srsly
+import tqdm
+from wasabi import msg
+
+from ..tokens import Doc, DocBin
+from ..util import ensure_path, load_model
+from ..vocab import Vocab
+from ._util import Arg, Opt, app, import_code, setup_gpu, walk_directory
+
+path_help = """Location of the documents to predict on.
+Can be a single file in .spacy format or a .jsonl file.
+Files with other extensions are treated as single plain text documents.
+If a directory is provided it is traversed recursively to grab
+all files to be processed.
+The files can be a mixture of .spacy, .jsonl and text files.
+If .jsonl is provided the specified field is going
+to be grabbed ("text" by default)."""
+
+out_help = "Path to save the resulting .spacy file"
+code_help = (
+    "Path to Python file with additional code (registered functions) to be imported"
+)
+gold_help = "Use gold preprocessing provided in the .spacy files"
+force_msg = (
+    "The provided output file already exists. "
+    "To force overwriting the output file, set the --force or -F flag."
+)
+
+
+DocOrStrStream = Union[Iterable[str], Iterable[Doc]]
+
+
+def _stream_docbin(path: Path, vocab: Vocab) -> Iterable[Doc]:
+    """
+    Stream Doc objects from DocBin.
+    """
+    docbin = DocBin().from_disk(path)
+    for doc in docbin.get_docs(vocab):
+        yield doc
+
+
+def _stream_jsonl(path: Path, field: str) -> Iterable[str]:
+    """
+    Stream "text" field from JSONL. If the field "text" is
+    not found it raises error.
+    """
+    for entry in srsly.read_jsonl(path):
+        if field not in entry:
+            msg.fail(f"{path} does not contain the required '{field}' field.", exits=1)
+        else:
+            yield entry[field]
+
+
+def _stream_texts(paths: Iterable[Path]) -> Iterable[str]:
+    """
+    Yields strings from text files in paths.
+    """
+    for path in paths:
+        with open(path, "r") as fin:
+            text = fin.read()
+            yield text
+
+
+@app.command("apply")
+def apply_cli(
+    # fmt: off
+    model: str = Arg(..., help="Model name or path"),
+    data_path: Path = Arg(..., help=path_help, exists=True),
+    output_file: Path = Arg(..., help=out_help, dir_okay=False),
+    code_path: Optional[Path] = Opt(None, "--code", "-c", help=code_help),
+    text_key: str = Opt(
+        "text", "--text-key", "-tk", help="Key containing text string for JSONL"
+    ),
+    force_overwrite: bool = Opt(
+        False, "--force", "-F", help="Force overwriting the output file"
+    ),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU."),
+    batch_size: int = Opt(1, "--batch-size", "-b", help="Batch size."),
+    n_process: int = Opt(1, "--n-process", "-n", help="number of processors to use."),
+):
+    """
+    Apply a trained pipeline to documents to get predictions.
+    Expects a loadable spaCy pipeline and path to the data, which
+    can be a directory or a file.
+    The data files can be provided in multiple formats:
+        1. .spacy files
+        2. .jsonl files with a specified "field" to read the text from.
+        3. Files with any other extension are assumed to be containing
+           a single document.
+    DOCS: https://spacy.io/api/cli#apply
+    """
+    data_path = ensure_path(data_path)
+    output_file = ensure_path(output_file)
+    code_path = ensure_path(code_path)
+    if output_file.exists() and not force_overwrite:
+        msg.fail(force_msg, exits=1)
+    if not data_path.exists():
+        msg.fail(f"Couldn't find data path: {data_path}", exits=1)
+    import_code(code_path)
+    setup_gpu(use_gpu)
+    apply(data_path, output_file, model, text_key, batch_size, n_process)
+
+
+def apply(
+    data_path: Path,
+    output_file: Path,
+    model: str,
+    json_field: str,
+    batch_size: int,
+    n_process: int,
+):
+    docbin = DocBin(store_user_data=True)
+    paths = walk_directory(data_path)
+    if len(paths) == 0:
+        docbin.to_disk(output_file)
+        msg.warn(
+            f"Did not find data to process, {data_path} seems to be an empty directory."
+        )
+        return
+    nlp = load_model(model)
+    msg.good(f"Loaded model {model}")
+    vocab = nlp.vocab
+    streams: List[DocOrStrStream] = []
+    text_files = []
+    for path in paths:
+        if path.suffix == ".spacy":
+            streams.append(_stream_docbin(path, vocab))
+        elif path.suffix == ".jsonl":
+            streams.append(_stream_jsonl(path, json_field))
+        else:
+            text_files.append(path)
+    if len(text_files) > 0:
+        streams.append(_stream_texts(text_files))
+    datagen = cast(DocOrStrStream, chain(*streams))
+    for doc in tqdm.tqdm(
+        nlp.pipe(datagen, batch_size=batch_size, n_process=n_process), disable=None
+    ):
+        docbin.add(doc)
+    if output_file.suffix == "":
+        output_file = output_file.with_suffix(".spacy")
+    docbin.to_disk(output_file)

spacy/cli/assemble.py

@@ -0,0 +1,80 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+import typer
+from wasabi import msg
+
+from .. import util
+from ..util import get_sourced_components, load_model_from_config
+from ._util import (
+    Arg,
+    Opt,
+    app,
+    import_code,
+    parse_config_overrides,
+    show_validation_error,
+)
+
+
+@app.command(
+    "assemble",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def assemble_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    output_path: Path = Arg(
+        ..., help="Output directory to store assembled pipeline in"
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    verbose: bool = Opt(
+        False,
+        "--verbose",
+        "-V",
+        "-VV",
+        help="Display more information for debugging purposes",
+    ),
+    # fmt: on
+):
+    """
+    Assemble a spaCy pipeline from a config file. The config file includes
+    all settings for initializing the pipeline. To override settings in the
+    config, e.g. settings that point to local paths or that you want to
+    experiment with, you can override them as command line options. The
+    --code argument lets you pass in a Python file that can be used to
+    register custom functions that are referenced in the config.
+
+    DOCS: https://spacy.io/api/cli#assemble
+    """
+    if verbose:
+        util.logger.setLevel(logging.DEBUG)
+    # Make sure all files and paths exists if they are needed
+    if not config_path or (str(config_path) != "-" and not config_path.exists()):
+        msg.fail("Config file not found", config_path, exits=1)
+    overrides = parse_config_overrides(ctx.args)
+    import_code(code_path)
+    with show_validation_error(config_path):
+        config = util.load_config(config_path, overrides=overrides, interpolate=False)
+    msg.divider("Initializing pipeline")
+    nlp = load_model_from_config(config, auto_fill=True)
+    config = config.interpolate()
+    sourced = get_sourced_components(config)
+    # Make sure that listeners are defined before initializing further
+    nlp._link_components()
+    with nlp.select_pipes(disable=[*sourced]):
+        nlp.initialize()
+    msg.good("Initialized pipeline")
+    msg.divider("Serializing to disk")
+    if output_path is not None and not output_path.exists():
+        output_path.mkdir(parents=True)
+        msg.good(f"Created output directory: {output_path}")
+    nlp.to_disk(output_path)

spacy/cli/benchmark_speed.py

@@ -0,0 +1,193 @@
+import random
+import time
+from itertools import islice
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+import numpy
+import typer
+from tqdm import tqdm
+from wasabi import msg
+
+from .. import util
+from ..language import Language
+from ..tokens import Doc
+from ..training import Corpus
+from ._util import Arg, Opt, benchmark_cli, import_code, setup_gpu
+
+
+@benchmark_cli.command(
+    "speed",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def benchmark_speed_cli(
+    # fmt: off
+    ctx: typer.Context,
+    model: str = Arg(..., help="Model name or path"),
+    data_path: Path = Arg(
+        ..., help="Location of binary evaluation data in .spacy format", exists=True
+    ),
+    batch_size: Optional[int] = Opt(
+        None, "--batch-size", "-b", min=1, help="Override the pipeline batch size"
+    ),
+    no_shuffle: bool = Opt(False, "--no-shuffle", help="Do not shuffle benchmark data"),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    n_batches: int = Opt(
+        50,
+        "--batches",
+        help="Minimum number of batches to benchmark",
+        min=30,
+    ),
+    warmup_epochs: int = Opt(
+        3, "--warmup", "-w", min=0, help="Number of iterations over the data for warmup"
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    # fmt: on
+):
+    """
+    Benchmark a pipeline. Expects a loadable spaCy pipeline and benchmark
+    data in the binary .spacy format.
+    """
+    import_code(code_path)
+    setup_gpu(use_gpu=use_gpu, silent=False)
+
+    nlp = util.load_model(model)
+    batch_size = batch_size if batch_size is not None else nlp.batch_size
+    corpus = Corpus(data_path)
+    docs = [eg.predicted for eg in corpus(nlp)]
+
+    if len(docs) == 0:
+        msg.fail("Cannot benchmark speed using an empty corpus.", exits=1)
+
+    print(f"Warming up for {warmup_epochs} epochs...")
+    warmup(nlp, docs, warmup_epochs, batch_size)
+
+    print()
+    print(f"Benchmarking {n_batches} batches...")
+    wps = benchmark(nlp, docs, n_batches, batch_size, not no_shuffle)
+
+    print()
+    print_outliers(wps)
+    print_mean_with_ci(wps)
+
+
+# Lowercased, behaves as a context manager function.
+class time_context:
+    """Register the running time of a context."""
+
+    def __enter__(self):
+        self.start = time.perf_counter()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.elapsed = time.perf_counter() - self.start
+
+
+class Quartiles:
+    """Calculate the q1, q2, q3 quartiles and the inter-quartile range (iqr)
+    of a sample."""
+
+    q1: float
+    q2: float
+    q3: float
+    iqr: float
+
+    def __init__(self, sample: numpy.ndarray) -> None:
+        self.q1 = numpy.quantile(sample, 0.25)
+        self.q2 = numpy.quantile(sample, 0.5)
+        self.q3 = numpy.quantile(sample, 0.75)
+        self.iqr = self.q3 - self.q1
+
+
+def annotate(
+    nlp: Language, docs: List[Doc], batch_size: Optional[int]
+) -> numpy.ndarray:
+    docs = nlp.pipe(tqdm(docs, unit="doc", disable=None), batch_size=batch_size)
+    wps = []
+    while True:
+        with time_context() as elapsed:
+            batch_docs = list(
+                islice(docs, batch_size if batch_size else nlp.batch_size)
+            )
+        if len(batch_docs) == 0:
+            break
+        n_tokens = count_tokens(batch_docs)
+        wps.append(n_tokens / elapsed.elapsed)
+
+    return numpy.array(wps)
+
+
+def benchmark(
+    nlp: Language,
+    docs: List[Doc],
+    n_batches: int,
+    batch_size: int,
+    shuffle: bool,
+) -> numpy.ndarray:
+    if shuffle:
+        bench_docs = [
+            nlp.make_doc(random.choice(docs).text)
+            for _ in range(n_batches * batch_size)
+        ]
+    else:
+        bench_docs = [
+            nlp.make_doc(docs[i % len(docs)].text)
+            for i in range(n_batches * batch_size)
+        ]
+
+    return annotate(nlp, bench_docs, batch_size)
+
+
+def bootstrap(x, statistic=numpy.mean, iterations=10000) -> numpy.ndarray:
+    """Apply a statistic to repeated random samples of an array."""
+    return numpy.fromiter(
+        (
+            statistic(numpy.random.choice(x, len(x), replace=True))
+            for _ in range(iterations)
+        ),
+        numpy.float64,
+    )
+
+
+def count_tokens(docs: Iterable[Doc]) -> int:
+    return sum(len(doc) for doc in docs)
+
+
+def print_mean_with_ci(sample: numpy.ndarray):
+    mean = numpy.mean(sample)
+    bootstrap_means = bootstrap(sample)
+    bootstrap_means.sort()
+
+    # 95% confidence interval
+    low = bootstrap_means[int(len(bootstrap_means) * 0.025)]
+    high = bootstrap_means[int(len(bootstrap_means) * 0.975)]
+
+    print(f"Mean: {mean:.1f} words/s (95% CI: {low - mean:.1f} +{high - mean:.1f})")
+
+
+def print_outliers(sample: numpy.ndarray):
+    quartiles = Quartiles(sample)
+
+    n_outliers = numpy.sum(
+        (sample < (quartiles.q1 - 1.5 * quartiles.iqr))
+        | (sample > (quartiles.q3 + 1.5 * quartiles.iqr))
+    )
+    n_extreme_outliers = numpy.sum(
+        (sample < (quartiles.q1 - 3.0 * quartiles.iqr))
+        | (sample > (quartiles.q3 + 3.0 * quartiles.iqr))
+    )
+    print(
+        f"Outliers: {(100 * n_outliers) / len(sample):.1f}%, extreme outliers: {(100 * n_extreme_outliers) / len(sample)}%"
+    )
+
+
+def warmup(
+    nlp: Language, docs: List[Doc], warmup_epochs: int, batch_size: Optional[int]
+) -> numpy.ndarray:
+    docs = [doc.copy() for doc in docs * warmup_epochs]
+    return annotate(nlp, docs, batch_size)

spacy/cli/convert.py

@@ -0,0 +1,284 @@
+import itertools
+import re
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Iterable, Mapping, Optional, Union
+
+import srsly
+from wasabi import Printer
+
+from ..tokens import Doc, DocBin
+from ..training import docs_to_json
+from ..training.converters import (
+    conll_ner_to_docs,
+    conllu_to_docs,
+    iob_to_docs,
+    json_to_docs,
+)
+from ._util import Arg, Opt, app, walk_directory
+
+# Converters are matched by file extension except for ner/iob, which are
+# matched by file extension and content. To add a converter, add a new
+# entry to this dict with the file extension mapped to the converter function
+# imported from /converters.
+
+CONVERTERS: Mapping[str, Callable[..., Iterable[Doc]]] = {
+    "conllubio": conllu_to_docs,
+    "conllu": conllu_to_docs,
+    "conll": conll_ner_to_docs,
+    "ner": conll_ner_to_docs,
+    "iob": iob_to_docs,
+    "json": json_to_docs,
+}
+
+AUTO = "auto"
+
+
+# File types that can be written to stdout
+FILE_TYPES_STDOUT = ("json",)
+
+
+class FileTypes(str, Enum):
+    json = "json"
+    spacy = "spacy"
+
+
+@app.command("convert")
+def convert_cli(
+    # fmt: off
+    input_path: str = Arg(..., help="Input file or directory", exists=True),
+    output_dir: Path = Arg(
+        "-", help="Output directory. '-' for stdout.", allow_dash=True, exists=True
+    ),
+    file_type: FileTypes = Opt(
+        "spacy", "--file-type", "-t", help="Type of data to produce"
+    ),
+    n_sents: int = Opt(
+        1, "--n-sents", "-n", help="Number of sentences per doc (0 to disable)"
+    ),
+    seg_sents: bool = Opt(
+        False, "--seg-sents", "-s", help="Segment sentences (for -c ner)"
+    ),
+    model: Optional[str] = Opt(
+        None,
+        "--model",
+        "--base",
+        "-b",
+        help="Trained spaCy pipeline for sentence segmentation to use as base (for --seg-sents)",
+    ),
+    morphology: bool = Opt(
+        False, "--morphology", "-m", help="Enable appending morphology to tags"
+    ),
+    merge_subtokens: bool = Opt(
+        False, "--merge-subtokens", "-T", help="Merge CoNLL-U subtokens"
+    ),
+    converter: str = Opt(
+        AUTO, "--converter", "-c", help=f"Converter: {tuple(CONVERTERS.keys())}"
+    ),
+    ner_map: Optional[Path] = Opt(
+        None,
+        "--ner-map",
+        "-nm",
+        help="NER tag mapping (as JSON-encoded dict of entity types)",
+        exists=True,
+    ),
+    lang: Optional[str] = Opt(
+        None, "--lang", "-l", help="Language (if tokenizer required)"
+    ),
+    concatenate: bool = Opt(
+        None, "--concatenate", "-C", help="Concatenate output to a single file"
+    ),
+    # fmt: on
+):
+    """
+    Convert files into json or DocBin format for training. The resulting .spacy
+    file can be used with the train command and other experiment management
+    functions.
+
+    If no output_dir is specified and the output format is JSON, the data
+    is written to stdout, so you can pipe them forward to a JSON file:
+    $ spacy convert some_file.conllu --file-type json > some_file.json
+
+    DOCS: https://spacy.io/api/cli#convert
+    """
+    input_path = Path(input_path)
+    output_dir: Union[str, Path] = "-" if output_dir == Path("-") else output_dir
+    silent = output_dir == "-"
+    msg = Printer(no_print=silent)
+    converter = _get_converter(msg, converter, input_path)
+    verify_cli_args(msg, input_path, output_dir, file_type.value, converter, ner_map)
+    convert(
+        input_path,
+        output_dir,
+        file_type=file_type.value,
+        n_sents=n_sents,
+        seg_sents=seg_sents,
+        model=model,
+        morphology=morphology,
+        merge_subtokens=merge_subtokens,
+        converter=converter,
+        ner_map=ner_map,
+        lang=lang,
+        concatenate=concatenate,
+        silent=silent,
+        msg=msg,
+    )
+
+
+def convert(
+    input_path: Path,
+    output_dir: Union[str, Path],
+    *,
+    file_type: str = "json",
+    n_sents: int = 1,
+    seg_sents: bool = False,
+    model: Optional[str] = None,
+    morphology: bool = False,
+    merge_subtokens: bool = False,
+    converter: str,
+    ner_map: Optional[Path] = None,
+    lang: Optional[str] = None,
+    concatenate: bool = False,
+    silent: bool = True,
+    msg: Optional[Printer] = None,
+) -> None:
+    input_path = Path(input_path)
+    if not msg:
+        msg = Printer(no_print=silent)
+    ner_map = srsly.read_json(ner_map) if ner_map is not None else None
+    doc_files = []
+    for input_loc in walk_directory(input_path, converter):
+        with input_loc.open("r", encoding="utf-8") as infile:
+            input_data = infile.read()
+        # Use converter function to convert data
+        func = CONVERTERS[converter]
+        docs = func(
+            input_data,
+            n_sents=n_sents,
+            seg_sents=seg_sents,
+            append_morphology=morphology,
+            merge_subtokens=merge_subtokens,
+            lang=lang,
+            model=model,
+            no_print=silent,
+            ner_map=ner_map,
+        )
+        doc_files.append((input_loc, docs))
+    if concatenate:
+        all_docs = itertools.chain.from_iterable([docs for _, docs in doc_files])
+        doc_files = [(input_path, all_docs)]
+    for input_loc, docs in doc_files:
+        if file_type == "json":
+            data = [docs_to_json(docs)]
+            len_docs = len(data)
+        else:
+            db = DocBin(docs=docs, store_user_data=True)
+            len_docs = len(db)
+            data = db.to_bytes()  # type: ignore[assignment]
+        if output_dir == "-":
+            _print_docs_to_stdout(data, file_type)
+        else:
+            if input_loc != input_path:
+                subpath = input_loc.relative_to(input_path)
+                output_file = Path(output_dir) / subpath.with_suffix(f".{file_type}")
+            else:
+                output_file = Path(output_dir) / input_loc.parts[-1]
+                output_file = output_file.with_suffix(f".{file_type}")
+            _write_docs_to_file(data, output_file, file_type)
+            msg.good(f"Generated output file ({len_docs} documents): {output_file}")
+
+
+def _print_docs_to_stdout(data: Any, output_type: str) -> None:
+    if output_type == "json":
+        srsly.write_json("-", data)
+    else:
+        sys.stdout.buffer.write(data)
+
+
+def _write_docs_to_file(data: Any, output_file: Path, output_type: str) -> None:
+    if not output_file.parent.exists():
+        output_file.parent.mkdir(parents=True)
+    if output_type == "json":
+        srsly.write_json(output_file, data)
+    else:
+        with output_file.open("wb") as file_:
+            file_.write(data)
+
+
+def autodetect_ner_format(input_data: str) -> Optional[str]:
+    # guess format from the first 20 lines
+    lines = input_data.split("\n")[:20]
+    format_guesses = {"ner": 0, "iob": 0}
+    iob_re = re.compile(r"\S+\|(O|[IB]-\S+)")
+    ner_re = re.compile(r"\S+\s+(O|[IB]-\S+)$")
+    for line in lines:
+        line = line.strip()
+        if iob_re.search(line):
+            format_guesses["iob"] += 1
+        if ner_re.search(line):
+            format_guesses["ner"] += 1
+    if format_guesses["iob"] == 0 and format_guesses["ner"] > 0:
+        return "ner"
+    if format_guesses["ner"] == 0 and format_guesses["iob"] > 0:
+        return "iob"
+    return None
+
+
+def verify_cli_args(
+    msg: Printer,
+    input_path: Path,
+    output_dir: Union[str, Path],
+    file_type: str,
+    converter: str,
+    ner_map: Optional[Path],
+):
+    if file_type not in FILE_TYPES_STDOUT and output_dir == "-":
+        msg.fail(
+            f"Can't write .{file_type} data to stdout. Please specify an output directory.",
+            exits=1,
+        )
+    if not input_path.exists():
+        msg.fail("Input file not found", input_path, exits=1)
+    if output_dir != "-" and not Path(output_dir).exists():
+        msg.fail("Output directory not found", output_dir, exits=1)
+    if ner_map is not None and not Path(ner_map).exists():
+        msg.fail("NER map not found", ner_map, exits=1)
+    if input_path.is_dir():
+        input_locs = walk_directory(input_path, converter)
+        if len(input_locs) == 0:
+            msg.fail("No input files in directory", input_path, exits=1)
+    if converter not in CONVERTERS:
+        msg.fail(f"Can't find converter for {converter}", exits=1)
+
+
+def _get_converter(msg, converter, input_path: Path):
+    if input_path.is_dir():
+        if converter == AUTO:
+            input_locs = walk_directory(input_path, suffix=None)
+            file_types = list(set([loc.suffix[1:] for loc in input_locs]))
+            if len(file_types) >= 2:
+                file_types_str = ",".join(file_types)
+                msg.fail("All input files must be same type", file_types_str, exits=1)
+            input_path = input_locs[0]
+        else:
+            input_path = walk_directory(input_path, suffix=converter)[0]
+    if converter == AUTO:
+        converter = input_path.suffix[1:]
+    if converter == "ner" or converter == "iob":
+        with input_path.open(encoding="utf8") as file_:
+            input_data = file_.read()
+        converter_autodetect = autodetect_ner_format(input_data)
+        if converter_autodetect == "ner":
+            msg.info("Auto-detected token-per-line NER format")
+            converter = converter_autodetect
+        elif converter_autodetect == "iob":
+            msg.info("Auto-detected sentence-per-line NER format")
+            converter = converter_autodetect
+        else:
+            msg.warn(
+                "Can't automatically detect NER format. "
+                "Conversion may not succeed. "
+                "See https://spacy.io/api/cli#convert"
+            )
+    return converter

spacy/cli/debug_config.py

@@ -0,0 +1,131 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import typer
+from thinc.api import Config
+from thinc.config import VARIABLE_RE
+from wasabi import msg, table
+
+from .. import util
+from ..schemas import ConfigSchemaInit, ConfigSchemaTraining
+from ..util import registry
+from ._util import (
+    Arg,
+    Opt,
+    debug_cli,
+    import_code,
+    parse_config_overrides,
+    show_validation_error,
+)
+
+
+@debug_cli.command(
+    "config",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def debug_config_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code-path",
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    show_funcs: bool = Opt(
+        False,
+        "--show-functions",
+        "-F",
+        help="Show an overview of all registered functions used in the config and where they come from (modules, files etc.)",
+    ),
+    show_vars: bool = Opt(
+        False,
+        "--show-variables",
+        "-V",
+        help="Show an overview of all variables referenced in the config and their values. This will also reflect variables overwritten on the CLI.",
+    ),
+    # fmt: on
+):
+    """Debug a config file and show validation errors. The command will
+    create all objects in the tree and validate them. Note that some config
+    validation errors are blocking and will prevent the rest of the config from
+    being resolved. This means that you may not see all validation errors at
+    once and some issues are only shown once previous errors have been fixed.
+    Similar as with the 'train' command, you can override settings from the config
+    as command line options. For instance, --training.batch_size 128 overrides
+    the value of "batch_size" in the block "[training]".
+
+    DOCS: https://spacy.io/api/cli#debug-config
+    """
+    overrides = parse_config_overrides(ctx.args)
+    import_code(code_path)
+    debug_config(
+        config_path, overrides=overrides, show_funcs=show_funcs, show_vars=show_vars
+    )
+
+
+def debug_config(
+    config_path: Path,
+    *,
+    overrides: Dict[str, Any] = {},
+    show_funcs: bool = False,
+    show_vars: bool = False,
+):
+    msg.divider("Config validation")
+    with show_validation_error(config_path):
+        config = util.load_config(config_path, overrides=overrides)
+        nlp = util.load_model_from_config(config)
+        config = nlp.config.interpolate()
+    msg.divider("Config validation for [initialize]")
+    with show_validation_error(config_path):
+        T = registry.resolve(config["initialize"], schema=ConfigSchemaInit)  # type: ignore[arg-type]
+    msg.divider("Config validation for [training]")
+    with show_validation_error(config_path):
+        T = registry.resolve(config["training"], schema=ConfigSchemaTraining)  # type: ignore[arg-type]
+        dot_names = [T["train_corpus"], T["dev_corpus"]]
+        util.resolve_dot_names(config, dot_names)
+    msg.good("Config is valid")
+    if show_vars:
+        variables = get_variables(config)
+        msg.divider(f"Variables ({len(variables)})")
+        head = ("Variable", "Value")
+        msg.table(variables, header=head, divider=True, widths=(41, 34), spacing=2)
+    if show_funcs:
+        funcs = get_registered_funcs(config)
+        msg.divider(f"Registered functions ({len(funcs)})")
+        for func in funcs:
+            func_data = {
+                "Registry": f"@{func['registry']}",
+                "Name": func["name"],
+                "Module": func["module"],
+                "File": f"{func['file']} (line {func['line_no']})",
+            }
+            msg.info(f"[{func['path']}]")
+            print(table(func_data).strip())
+
+
+def get_registered_funcs(config: Config) -> List[Dict[str, Optional[Union[str, int]]]]:
+    result = []
+    for key, value in util.walk_dict(config):
+        if not key[-1].startswith("@"):
+            continue
+        # We have a reference to a registered function
+        reg_name = key[-1][1:]
+        registry = getattr(util.registry, reg_name)
+        path = ".".join(key[:-1])
+        info = registry.find(value)
+        result.append({"name": value, "registry": reg_name, "path": path, **info})
+    return result
+
+
+def get_variables(config: Config) -> Dict[str, Any]:
+    result = {}
+    for variable in sorted(set(VARIABLE_RE.findall(config.to_str()))):
+        path = variable[2:-1].replace(":", ".")
+        value = util.dot_to_object(config, path)
+        result[variable] = repr(value)
+    return result

spacy/cli/debug_diff.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from typing import Optional
+
+import typer
+from wasabi import MarkdownRenderer, Printer, diff_strings
+
+from ..util import load_config
+from ._util import Arg, Opt, debug_cli, show_validation_error
+from .init_config import Optimizations, init_config
+
+
+@debug_cli.command(
+    "diff-config",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def debug_diff_cli(
+    # fmt: off
+    ctx: typer.Context,
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    compare_to: Optional[Path] = Opt(
+        None,
+        help="Path to a config file to diff against, or `None` to compare against default settings",
+        exists=True,
+        allow_dash=True,
+    ),
+    optimize: Optimizations = Opt(
+        Optimizations.efficiency.value,
+        "--optimize",
+        "-o",
+        help="Whether the user config was optimized for efficiency or accuracy. Only relevant when comparing against the default config.",
+    ),
+    gpu: bool = Opt(
+        False,
+        "--gpu",
+        "-G",
+        help="Whether the original config can run on a GPU. Only relevant when comparing against the default config.",
+    ),
+    pretraining: bool = Opt(
+        False,
+        "--pretraining",
+        "--pt",
+        help="Whether to compare on a config with pretraining involved. Only relevant when comparing against the default config.",
+    ),
+    markdown: bool = Opt(
+        False, "--markdown", "-md", help="Generate Markdown for GitHub issues"
+    ),
+    # fmt: on
+):
+    """Show a diff of a config file with respect to spaCy's defaults or another config file. If
+    additional settings were used in the creation of the config file, then you
+    must supply these as extra parameters to the command when comparing to the default settings. The generated diff
+    can also be used when posting to the discussion forum to provide more
+    information for the maintainers.
+
+    The `optimize`, `gpu`, and `pretraining` options are only relevant when
+    comparing against the default configuration (or specifically when `compare_to` is None).
+
+    DOCS: https://spacy.io/api/cli#debug-diff
+    """
+    debug_diff(
+        config_path=config_path,
+        compare_to=compare_to,
+        gpu=gpu,
+        optimize=optimize,
+        pretraining=pretraining,
+        markdown=markdown,
+    )
+
+
+def debug_diff(
+    config_path: Path,
+    compare_to: Optional[Path],
+    gpu: bool,
+    optimize: Optimizations,
+    pretraining: bool,
+    markdown: bool,
+):
+    msg = Printer()
+    with show_validation_error(hint_fill=False):
+        user_config = load_config(config_path)
+        if compare_to:
+            other_config = load_config(compare_to)
+        else:
+            # Recreate a default config based from user's config
+            lang = user_config["nlp"]["lang"]
+            pipeline = list(user_config["nlp"]["pipeline"])
+            msg.info(f"Found user-defined language: '{lang}'")
+            msg.info(f"Found user-defined pipelines: {pipeline}")
+            other_config = init_config(
+                lang=lang,
+                pipeline=pipeline,
+                optimize=optimize.value,
+                gpu=gpu,
+                pretraining=pretraining,
+                silent=True,
+            )
+
+    user = user_config.to_str()
+    other = other_config.to_str()
+
+    if user == other:
+        msg.warn("No diff to show: configs are identical")
+    else:
+        diff_text = diff_strings(other, user, add_symbols=markdown)
+        if markdown:
+            md = MarkdownRenderer()
+            md.add(md.code_block(diff_text, "diff"))
+            print(md.text)
+        else:
+            print(diff_text)

spacy/cli/debug_model.py

@@ -0,0 +1,250 @@
+import itertools
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import typer
+from thinc.api import (
+    Model,
+    data_validation,
+    fix_random_seed,
+    set_dropout_rate,
+    set_gpu_allocator,
+)
+from wasabi import msg
+
+from spacy.training import Example
+from spacy.util import resolve_dot_names
+
+from .. import util
+from ..schemas import ConfigSchemaTraining
+from ..util import registry
+from ._util import (
+    Arg,
+    Opt,
+    debug_cli,
+    parse_config_overrides,
+    setup_gpu,
+    show_validation_error,
+    string_to_list,
+)
+
+
+@debug_cli.command(
+    "model",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def debug_model_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    component: str = Arg(
+        ..., help="Name of the pipeline component of which the model should be analysed"
+    ),
+    layers: str = Opt(
+        "", "--layers", "-l", help="Comma-separated names of layer IDs to print"
+    ),
+    dimensions: bool = Opt(False, "--dimensions", "-DIM", help="Show dimensions"),
+    parameters: bool = Opt(False, "--parameters", "-PAR", help="Show parameters"),
+    gradients: bool = Opt(False, "--gradients", "-GRAD", help="Show gradients"),
+    attributes: bool = Opt(False, "--attributes", "-ATTR", help="Show attributes"),
+    P0: bool = Opt(False, "--print-step0", "-P0", help="Print model before training"),
+    P1: bool = Opt(
+        False, "--print-step1", "-P1", help="Print model after initialization"
+    ),
+    P2: bool = Opt(False, "--print-step2", "-P2", help="Print model after training"),
+    P3: bool = Opt(False, "--print-step3", "-P3", help="Print final predictions"),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    # fmt: on
+):
+    """
+    Analyze a Thinc model implementation. Includes checks for internal structure
+    and activations during training.
+
+    DOCS: https://spacy.io/api/cli#debug-model
+    """
+    setup_gpu(use_gpu)
+    layers = string_to_list(layers, intify=True)
+    print_settings = {
+        "dimensions": dimensions,
+        "parameters": parameters,
+        "gradients": gradients,
+        "attributes": attributes,
+        "layers": layers,
+        "print_before_training": P0,
+        "print_after_init": P1,
+        "print_after_training": P2,
+        "print_prediction": P3,
+    }
+    config_overrides = parse_config_overrides(ctx.args)
+    with show_validation_error(config_path):
+        raw_config = util.load_config(
+            config_path, overrides=config_overrides, interpolate=False
+        )
+    config = raw_config.interpolate()
+    allocator = config["training"]["gpu_allocator"]
+    if use_gpu >= 0 and allocator:
+        set_gpu_allocator(allocator)
+    with show_validation_error(config_path):
+        nlp = util.load_model_from_config(raw_config)
+        config = nlp.config.interpolate()
+        T = registry.resolve(config["training"], schema=ConfigSchemaTraining)  # type: ignore[arg-type]
+    seed = T["seed"]
+    if seed is not None:
+        msg.info(f"Fixing random seed: {seed}")
+        fix_random_seed(seed)
+    pipe = nlp.get_pipe(component)
+
+    debug_model(config, T, nlp, pipe, print_settings=print_settings)
+
+
+def debug_model(
+    config,
+    resolved_train_config,
+    nlp,
+    pipe,
+    *,
+    print_settings: Optional[Dict[str, Any]] = None,
+):
+    if not hasattr(pipe, "model"):
+        msg.fail(
+            f"The component '{pipe}' does not specify an object that holds a Model.",
+            exits=1,
+        )
+    model = pipe.model
+    if not isinstance(model, Model):
+        msg.fail(
+            f"Requires a Thinc Model to be analysed, but found {type(model)} instead.",
+            exits=1,
+        )
+    if print_settings is None:
+        print_settings = {}
+
+    # STEP 0: Printing before training
+    msg.info(f"Analysing model with ID {model.id}")
+    if print_settings.get("print_before_training"):
+        msg.divider(f"STEP 0 - before training")
+        _print_model(model, print_settings)
+
+    # STEP 1: Initializing the model and printing again
+    with data_validation(False):
+        try:
+            dot_names = [resolved_train_config["train_corpus"]]
+            with show_validation_error():
+                (train_corpus,) = resolve_dot_names(config, dot_names)
+                nlp.initialize(lambda: train_corpus(nlp))
+            msg.info("Initialized the model with the training corpus.")
+            examples = list(itertools.islice(train_corpus(nlp), 5))
+        except ValueError:
+            try:
+                _set_output_dim(nO=7, model=model)
+                with show_validation_error():
+                    examples = [Example.from_dict(x, {}) for x in _get_docs()]
+                    nlp.initialize(lambda: examples)
+                msg.info("Initialized the model with dummy data.")
+            except Exception:
+                msg.fail(
+                    "Could not initialize the model: you'll have to provide a valid 'train_corpus' argument in the config file.",
+                    exits=1,
+                )
+
+    if print_settings.get("print_after_init"):
+        msg.divider(f"STEP 1 - after initialization")
+        _print_model(model, print_settings)
+
+    # STEP 2: Updating the model and printing again
+    set_dropout_rate(model, 0.2)
+    # ugly hack to deal with Tok2Vec/Transformer listeners
+    upstream_component = None
+    if model.has_ref("tok2vec") and "tok2vec-listener" in model.get_ref("tok2vec").name:
+        upstream_component = nlp.get_pipe("tok2vec")
+    if (
+        model.has_ref("tok2vec")
+        and "transformer-listener" in model.get_ref("tok2vec").name
+    ):
+        upstream_component = nlp.get_pipe("transformer")
+    for e in range(3):
+        if upstream_component:
+            upstream_component.update(examples)
+        pipe.update(examples)
+    if print_settings.get("print_after_training"):
+        msg.divider(f"STEP 2 - after training")
+        _print_model(model, print_settings)
+
+    # STEP 3: the final prediction
+    prediction = model.predict([ex.predicted for ex in examples])
+    if print_settings.get("print_prediction"):
+        msg.divider(f"STEP 3 - prediction")
+        msg.info(str(prediction))
+
+    msg.good(f"Successfully ended analysis - model looks good.")
+
+
+def _sentences():
+    return [
+        "Apple is looking at buying U.K. startup for $1 billion",
+        "Autonomous cars shift insurance liability toward manufacturers",
+        "San Francisco considers banning sidewalk delivery robots",
+        "London is a big city in the United Kingdom.",
+    ]
+
+
+def _get_docs(lang: str = "en"):
+    nlp = util.get_lang_class(lang)()
+    return list(nlp.pipe(_sentences()))
+
+
+def _set_output_dim(model, nO):
+    # simulating dim inference by directly setting the nO argument of the model
+    if model.has_dim("nO") is None:
+        model.set_dim("nO", nO)
+    if model.has_ref("output_layer"):
+        if model.get_ref("output_layer").has_dim("nO") is None:
+            model.get_ref("output_layer").set_dim("nO", nO)
+
+
+def _print_model(model, print_settings):
+    layers = print_settings.get("layers", "")
+    parameters = print_settings.get("parameters", False)
+    dimensions = print_settings.get("dimensions", False)
+    gradients = print_settings.get("gradients", False)
+    attributes = print_settings.get("attributes", False)
+
+    for i, node in enumerate(model.walk()):
+        if not layers or i in layers:
+            msg.info(f"Layer {i}: model ID {node.id}: '{node.name}'")
+
+            if dimensions:
+                for name in node.dim_names:
+                    msg.info(f" - dim {name}: {node.maybe_get_dim(name)}")
+            if parameters:
+                for name in node.param_names:
+                    if node.has_param(name):
+                        print_value = _print_matrix(node.get_param(name))
+                        msg.info(f" - param {name}: {print_value}")
+                    else:
+                        msg.info(f" - param {name}: {node.has_param(name)}")
+            if gradients:
+                for name in node.param_names:
+                    if node.has_grad(name):
+                        print_value = _print_matrix(node.get_grad(name))
+                        msg.info(f" - grad {name}: {print_value}")
+                    else:
+                        msg.info(f" - grad {name}: {node.has_grad(name)}")
+            if attributes:
+                attrs = node.attrs
+                for name, value in attrs.items():
+                    msg.info(f" - attr {name}: {value}")
+
+
+def _print_matrix(value):
+    if value is None or isinstance(value, bool):
+        return value
+    result = str(value.shape) + " - sample: "
+    sample_matrix = value
+    for d in range(value.ndim - 1):
+        sample_matrix = sample_matrix[0]
+    sample_matrix = sample_matrix[0:5]
+    result = result + str(sample_matrix)
+    return result

spacy/cli/download.py

@@ -0,0 +1,203 @@
+import importlib.util
+import shutil
+import sys
+from typing import Optional, Sequence
+from urllib.parse import urljoin
+
+import requests
+import typer
+from wasabi import msg
+
+from .. import about
+from ..errors import OLD_MODEL_SHORTCUTS
+from ..util import (
+    get_minor_version,
+    is_in_interactive,
+    is_in_jupyter,
+    is_package,
+    is_prerelease_version,
+    run_command,
+)
+from ._util import SDIST_SUFFIX, WHEEL_SUFFIX, Arg, Opt, app
+
+
+@app.command(
+    "download",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def download_cli(
+    # fmt: off
+    ctx: typer.Context,
+    model: str = Arg(..., help="Name of pipeline package to download"),
+    direct: bool = Opt(
+        False, "--direct", "-d", "-D", help="Force direct download of name + version"
+    ),
+    sdist: bool = Opt(
+        False,
+        "--sdist",
+        "-S",
+        help="Download sdist (.tar.gz) archive instead of pre-built binary wheel",
+    ),
+    url: str = Opt(None, "--url", "-U", help="Download from given url"),
+    # fmt: on
+):
+    """
+    Download compatible trained pipeline from the default download path using
+    pip. If --direct flag is set, the command expects the full package name with
+    version. For direct downloads, the compatibility check will be skipped. All
+    additional arguments provided to this command will be passed to `pip install`
+    on package installation.
+
+    DOCS: https://spacy.io/api/cli#download
+    AVAILABLE PACKAGES: https://spacy.io/models
+    """
+    download(model, direct, sdist, url, *ctx.args)
+
+
+def download(
+    model: str,
+    direct: bool = False,
+    sdist: bool = False,
+    custom_url: Optional[str] = None,
+    *pip_args,
+) -> None:
+    if (
+        not (is_package("spacy") or is_package("spacy-nightly"))
+        and "--no-deps" not in pip_args
+    ):
+        msg.warn(
+            "Skipping pipeline package dependencies and setting `--no-deps`. "
+            "You don't seem to have the spaCy package itself installed "
+            "(maybe because you've built from source?), so installing the "
+            "package dependencies would cause spaCy to be downloaded, which "
+            "probably isn't what you want. If the pipeline package has other "
+            "dependencies, you'll have to install them manually."
+        )
+        pip_args = pip_args + ("--no-deps",)
+    if direct:
+        # Reject model names with '/', in order to prevent shenanigans.
+        if "/" in model:
+            msg.fail(
+                title="Model download rejected",
+                text=f"Cannot download model '{model}'. Models are expected to be file names, not URLs or fragments",
+                exits=True,
+            )
+        components = model.split("-")
+        model_name = "".join(components[:-1])
+        version = components[-1]
+    else:
+        model_name = model
+        if model in OLD_MODEL_SHORTCUTS:
+            msg.warn(
+                f"As of spaCy v3.0, shortcuts like '{model}' are deprecated. Please "
+                f"use the full pipeline package name '{OLD_MODEL_SHORTCUTS[model]}' instead."
+            )
+            model_name = OLD_MODEL_SHORTCUTS[model]
+        compatibility = get_compatibility()
+        version = get_version(model_name, compatibility)
+
+    filename = get_model_filename(model_name, version, sdist)
+
+    download_model(filename, pip_args, custom_url)
+    msg.good(
+        "Download and installation successful",
+        f"You can now load the package via spacy.load('{model_name}')",
+    )
+    if is_in_jupyter():
+        reload_deps_msg = (
+            "If you are in a Jupyter or Colab notebook, you may need to "
+            "restart Python in order to load all the package's dependencies. "
+            "You can do this by selecting the 'Restart kernel' or 'Restart "
+            "runtime' option."
+        )
+        msg.warn(
+            "Restart to reload dependencies",
+            reload_deps_msg,
+        )
+    elif is_in_interactive():
+        reload_deps_msg = (
+            "If you are in an interactive Python session, you may need to "
+            "exit and restart Python to load all the package's dependencies. "
+            "You can exit with Ctrl-D (or Ctrl-Z and Enter on Windows)."
+        )
+        msg.warn(
+            "Restart to reload dependencies",
+            reload_deps_msg,
+        )
+
+
+def get_model_filename(model_name: str, version: str, sdist: bool = False) -> str:
+    dl_tpl = "{m}-{v}/{m}-{v}{s}"
+    suffix = SDIST_SUFFIX if sdist else WHEEL_SUFFIX
+    filename = dl_tpl.format(m=model_name, v=version, s=suffix)
+    return filename
+
+
+def get_compatibility() -> dict:
+    if is_prerelease_version(about.__version__):
+        version: Optional[str] = about.__version__
+    else:
+        version = get_minor_version(about.__version__)
+    r = requests.get(about.__compatibility__)
+    if r.status_code != 200:
+        msg.fail(
+            f"Server error ({r.status_code})",
+            f"Couldn't fetch compatibility table. Please find a package for your spaCy "
+            f"installation (v{about.__version__}), and download it manually. "
+            f"For more details, see the documentation: "
+            f"https://spacy.io/usage/models",
+            exits=1,
+        )
+    comp_table = r.json()
+    comp = comp_table["spacy"]
+    if version not in comp:
+        msg.fail(f"No compatible packages found for v{version} of spaCy", exits=1)
+    return comp[version]
+
+
+def get_version(model: str, comp: dict) -> str:
+    if model not in comp:
+        msg.fail(
+            f"No compatible package found for '{model}' (spaCy v{about.__version__})",
+            exits=1,
+        )
+    return comp[model][0]
+
+
+def get_latest_version(model: str) -> str:
+    comp = get_compatibility()
+    return get_version(model, comp)
+
+
+def download_model(
+    filename: str,
+    user_pip_args: Optional[Sequence[str]] = None,
+    custom_url: Optional[str] = None,
+) -> None:
+    # Construct the download URL carefully. We need to make sure we don't
+    # allow relative paths or other shenanigans to trick us into download
+    # from outside our own repo.
+    base_url = custom_url if custom_url else about.__download_url__
+    # urljoin requires that the path ends with /, or the last path part will be dropped
+    if not base_url.endswith("/"):
+        base_url = about.__download_url__ + "/"
+    download_url = urljoin(base_url, filename)
+    if not download_url.startswith(about.__download_url__):
+        raise ValueError(f"Download from {filename} rejected. Was it a relative path?")
+    pip_args = list(user_pip_args) if user_pip_args is not None else []
+    cmd = _get_pip_install_cmd() + pip_args + [download_url]
+    run_command(cmd)
+
+
+def _get_pip_install_cmd() -> list:
+    if importlib.util.find_spec("pip") is not None:
+        return [sys.executable, "-m", "pip", "install"]
+    elif shutil.which("uv"):
+        return ["uv", "pip", "install"]
+    else:
+        msg.fail(
+            "No package installer found",
+            "spaCy requires either pip or uv to download models. "
+            "Please install one of them and try again.",
+            exits=1,
+        )

spacy/cli/evaluate.py

@@ -0,0 +1,277 @@
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import srsly
+from thinc.api import fix_random_seed
+from wasabi import Printer
+
+from .. import displacy, util
+from ..tokens import Doc
+from ..training import Corpus
+from ._util import Arg, Opt, app, benchmark_cli, import_code, setup_gpu
+
+
+@benchmark_cli.command(
+    "accuracy",
+)
+@app.command("evaluate")
+def evaluate_cli(
+    # fmt: off
+    model: str = Arg(..., help="Model name or path"),
+    data_path: Path = Arg(
+        ..., help="Location of binary evaluation data in .spacy format", exists=True
+    ),
+    output: Optional[Path] = Opt(
+        None, "--output", "-o", help="Output JSON file for metrics", dir_okay=False
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    gold_preproc: bool = Opt(
+        False, "--gold-preproc", "-G", help="Use gold preprocessing"
+    ),
+    displacy_path: Optional[Path] = Opt(
+        None,
+        "--displacy-path",
+        "-dp",
+        help="Directory to output rendered parses as HTML",
+        exists=True,
+        file_okay=False,
+    ),
+    displacy_limit: int = Opt(
+        25, "--displacy-limit", "-dl", help="Limit of parses to render as HTML"
+    ),
+    per_component: bool = Opt(
+        False,
+        "--per-component",
+        "-P",
+        help="Return scores per component, only applicable when an output JSON file is specified.",
+    ),
+    spans_key: str = Opt(
+        "sc", "--spans-key", "-sk", help="Spans key to use when evaluating Doc.spans"
+    ),
+    # fmt: on
+):
+    """
+    Evaluate a trained pipeline. Expects a loadable spaCy pipeline and evaluation
+    data in the binary .spacy format. The --gold-preproc option sets up the
+    evaluation examples with gold-standard sentences and tokens for the
+    predictions. Gold preprocessing helps the annotations align to the
+    tokenization, and may result in sequences of more consistent length. However,
+    it may reduce runtime accuracy due to train/test skew. To render a sample of
+    dependency parses in a HTML file, set as output directory as the
+    displacy_path argument.
+
+    DOCS: https://spacy.io/api/cli#benchmark-accuracy
+    """
+    import_code(code_path)
+    evaluate(
+        model,
+        data_path,
+        output=output,
+        use_gpu=use_gpu,
+        gold_preproc=gold_preproc,
+        displacy_path=displacy_path,
+        displacy_limit=displacy_limit,
+        per_component=per_component,
+        silent=False,
+        spans_key=spans_key,
+    )
+
+
+def evaluate(
+    model: str,
+    data_path: Path,
+    output: Optional[Path] = None,
+    use_gpu: int = -1,
+    gold_preproc: bool = False,
+    displacy_path: Optional[Path] = None,
+    displacy_limit: int = 25,
+    silent: bool = True,
+    spans_key: str = "sc",
+    per_component: bool = False,
+) -> Dict[str, Any]:
+    msg = Printer(no_print=silent, pretty=not silent)
+    fix_random_seed()
+    setup_gpu(use_gpu, silent=silent)
+    data_path = util.ensure_path(data_path)
+    output_path = util.ensure_path(output)
+    displacy_path = util.ensure_path(displacy_path)
+    if not data_path.exists():
+        msg.fail("Evaluation data not found", data_path, exits=1)
+    if displacy_path and not displacy_path.exists():
+        msg.fail("Visualization output directory not found", displacy_path, exits=1)
+    corpus = Corpus(data_path, gold_preproc=gold_preproc)
+    nlp = util.load_model(model)
+    dev_dataset = list(corpus(nlp))
+    scores = nlp.evaluate(dev_dataset, per_component=per_component)
+    if per_component:
+        data = scores
+        if output is None:
+            msg.warn(
+                "The per-component option is enabled but there is no output JSON file provided to save the scores to."
+            )
+        else:
+            msg.info("Per-component scores will be saved to output JSON file.")
+    else:
+        metrics = {
+            "TOK": "token_acc",
+            "TAG": "tag_acc",
+            "POS": "pos_acc",
+            "MORPH": "morph_acc",
+            "LEMMA": "lemma_acc",
+            "UAS": "dep_uas",
+            "LAS": "dep_las",
+            "NER P": "ents_p",
+            "NER R": "ents_r",
+            "NER F": "ents_f",
+            "TEXTCAT": "cats_score",
+            "SENT P": "sents_p",
+            "SENT R": "sents_r",
+            "SENT F": "sents_f",
+            "SPAN P": f"spans_{spans_key}_p",
+            "SPAN R": f"spans_{spans_key}_r",
+            "SPAN F": f"spans_{spans_key}_f",
+            "SPEED": "speed",
+        }
+        results = {}
+        data = {}
+        for metric, key in metrics.items():
+            if key in scores:
+                if key == "cats_score":
+                    metric = metric + " (" + scores.get("cats_score_desc", "unk") + ")"
+                if isinstance(scores[key], (int, float)):
+                    if key == "speed":
+                        results[metric] = f"{scores[key]:.0f}"
+                    else:
+                        results[metric] = f"{scores[key] * 100:.2f}"
+                else:
+                    results[metric] = "-"
+                data[re.sub(r"[\s/]", "_", key.lower())] = scores[key]
+
+        msg.table(results, title="Results")
+        data = handle_scores_per_type(scores, data, spans_key=spans_key, silent=silent)
+
+    if displacy_path:
+        factory_names = [nlp.get_pipe_meta(pipe).factory for pipe in nlp.pipe_names]
+        docs = list(nlp.pipe(ex.reference.text for ex in dev_dataset[:displacy_limit]))
+        render_deps = "parser" in factory_names
+        render_ents = "ner" in factory_names
+        render_spans = "spancat" in factory_names
+
+        render_parses(
+            docs,
+            displacy_path,
+            model_name=model,
+            limit=displacy_limit,
+            deps=render_deps,
+            ents=render_ents,
+            spans=render_spans,
+        )
+        msg.good(f"Generated {displacy_limit} parses as HTML", displacy_path)
+
+    if output_path is not None:
+        srsly.write_json(output_path, data)
+        msg.good(f"Saved results to {output_path}")
+    return data
+
+
+def handle_scores_per_type(
+    scores: Dict[str, Any],
+    data: Dict[str, Any] = {},
+    *,
+    spans_key: str = "sc",
+    silent: bool = False,
+) -> Dict[str, Any]:
+    msg = Printer(no_print=silent, pretty=not silent)
+    if "morph_per_feat" in scores:
+        if scores["morph_per_feat"]:
+            print_prf_per_type(msg, scores["morph_per_feat"], "MORPH", "feat")
+            data["morph_per_feat"] = scores["morph_per_feat"]
+    if "dep_las_per_type" in scores:
+        if scores["dep_las_per_type"]:
+            print_prf_per_type(msg, scores["dep_las_per_type"], "LAS", "type")
+            data["dep_las_per_type"] = scores["dep_las_per_type"]
+    if "ents_per_type" in scores:
+        if scores["ents_per_type"]:
+            print_prf_per_type(msg, scores["ents_per_type"], "NER", "type")
+            data["ents_per_type"] = scores["ents_per_type"]
+    if f"spans_{spans_key}_per_type" in scores:
+        if scores[f"spans_{spans_key}_per_type"]:
+            print_prf_per_type(
+                msg, scores[f"spans_{spans_key}_per_type"], "SPANS", "type"
+            )
+            data[f"spans_{spans_key}_per_type"] = scores[f"spans_{spans_key}_per_type"]
+    if "cats_f_per_type" in scores:
+        if scores["cats_f_per_type"]:
+            print_prf_per_type(msg, scores["cats_f_per_type"], "Textcat F", "label")
+            data["cats_f_per_type"] = scores["cats_f_per_type"]
+    if "cats_auc_per_type" in scores:
+        if scores["cats_auc_per_type"]:
+            print_textcats_auc_per_cat(msg, scores["cats_auc_per_type"])
+            data["cats_auc_per_type"] = scores["cats_auc_per_type"]
+    return scores
+
+
+def render_parses(
+    docs: List[Doc],
+    output_path: Path,
+    model_name: str = "",
+    limit: int = 250,
+    deps: bool = True,
+    ents: bool = True,
+    spans: bool = True,
+):
+    docs[0].user_data["title"] = model_name
+    if ents:
+        html = displacy.render(docs[:limit], style="ent", page=True)
+        with (output_path / "entities.html").open("w", encoding="utf8") as file_:
+            file_.write(html)
+    if deps:
+        html = displacy.render(
+            docs[:limit], style="dep", page=True, options={"compact": True}
+        )
+        with (output_path / "parses.html").open("w", encoding="utf8") as file_:
+            file_.write(html)
+
+    if spans:
+        html = displacy.render(docs[:limit], style="span", page=True)
+        with (output_path / "spans.html").open("w", encoding="utf8") as file_:
+            file_.write(html)
+
+
+def print_prf_per_type(
+    msg: Printer, scores: Dict[str, Dict[str, float]], name: str, type: str
+) -> None:
+    data = []
+    for key, value in scores.items():
+        row = [key]
+        for k in ("p", "r", "f"):
+            v = value[k]
+            row.append(f"{v * 100:.2f}" if isinstance(v, (int, float)) else v)
+        data.append(row)
+    msg.table(
+        data,
+        header=("", "P", "R", "F"),
+        aligns=("l", "r", "r", "r"),
+        title=f"{name} (per {type})",
+    )
+
+
+def print_textcats_auc_per_cat(
+    msg: Printer, scores: Dict[str, Dict[str, float]]
+) -> None:
+    msg.table(
+        [
+            (k, f"{v:.2f}" if isinstance(v, (float, int)) else v)
+            for k, v in scores.items()
+        ],
+        header=("", "ROC AUC"),
+        aligns=("l", "r"),
+        title="Textcat ROC AUC (per label)",
+    )

spacy/cli/find_function.py

@@ -0,0 +1,71 @@
+from typing import Optional, Tuple
+
+from catalogue import RegistryError
+from wasabi import msg
+
+from ..util import registry
+from ._util import Arg, Opt, app
+
+
+@app.command("find-function")
+def find_function_cli(
+    # fmt: off
+    func_name: str = Arg(..., help="Name of the registered function."),
+    registry_name: Optional[str] = Opt(
+        None, "--registry", "-r", help="Name of the catalogue registry."
+    ),
+    # fmt: on
+):
+    """
+    Find the module, path and line number to the file the registered
+    function is defined in, if available.
+
+    func_name (str): Name of the registered function.
+    registry_name (Optional[str]): Name of the catalogue registry.
+
+    DOCS: https://spacy.io/api/cli#find-function
+    """
+    if not registry_name:
+        registry_names = registry.get_registry_names()
+        for name in registry_names:
+            if registry.has(name, func_name):
+                registry_name = name
+                break
+
+    if not registry_name:
+        msg.fail(
+            f"Couldn't find registered function: '{func_name}'",
+            exits=1,
+        )
+
+    assert registry_name is not None
+    find_function(func_name, registry_name)
+
+
+def find_function(func_name: str, registry_name: str) -> Tuple[str, int]:
+    registry_desc = None
+    try:
+        registry_desc = registry.find(registry_name, func_name)
+    except RegistryError as e:
+        msg.fail(
+            f"Couldn't find registered function: '{func_name}' in registry '{registry_name}'",
+        )
+        msg.fail(f"{e}", exits=1)
+    assert registry_desc is not None
+
+    registry_path = None
+    line_no = None
+    if registry_desc["file"]:
+        registry_path = registry_desc["file"]
+        line_no = registry_desc["line_no"]
+
+    if not registry_path or not line_no:
+        msg.fail(
+            f"Couldn't find path to registered function: '{func_name}' in registry '{registry_name}'",
+            exits=1,
+        )
+    assert registry_path is not None
+    assert line_no is not None
+
+    msg.good(f"Found registered function '{func_name}' at {registry_path}:{line_no}")
+    return str(registry_path), int(line_no)

spacy/cli/find_threshold.py

@@ -0,0 +1,261 @@
+import functools
+import logging
+import operator
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy
+import wasabi.tables
+
+from .. import util
+from ..errors import Errors
+from ..pipeline import MultiLabel_TextCategorizer, TextCategorizer
+from ..training import Corpus
+from ._util import Arg, Opt, app, import_code, setup_gpu
+
+_DEFAULTS = {
+    "n_trials": 11,
+    "use_gpu": -1,
+    "gold_preproc": False,
+}
+
+
+@app.command(
+    "find-threshold",
+    context_settings={"allow_extra_args": False, "ignore_unknown_options": True},
+)
+def find_threshold_cli(
+    # fmt: off
+    model: str = Arg(..., help="Model name or path"),
+    data_path: Path = Arg(
+        ..., help="Location of binary evaluation data in .spacy format", exists=True
+    ),
+    pipe_name: str = Arg(..., help="Name of pipe to examine thresholds for"),
+    threshold_key: str = Arg(
+        ..., help="Key of threshold attribute in component's configuration"
+    ),
+    scores_key: str = Arg(..., help="Metric to optimize"),
+    n_trials: int = Opt(
+        _DEFAULTS["n_trials"],
+        "--n_trials",
+        "-n",
+        help="Number of trials to determine optimal thresholds",
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    use_gpu: int = Opt(
+        _DEFAULTS["use_gpu"], "--gpu-id", "-g", help="GPU ID or -1 for CPU"
+    ),
+    gold_preproc: bool = Opt(
+        _DEFAULTS["gold_preproc"], "--gold-preproc", "-G", help="Use gold preprocessing"
+    ),
+    verbose: bool = Opt(
+        False,
+        "--verbose",
+        "-V",
+        "-VV",
+        help="Display more information for debugging purposes",
+    ),
+    # fmt: on
+):
+    """
+    Runs prediction trials for a trained model with varying thresholds to maximize
+    the specified metric. The search space for the threshold is traversed linearly
+    from 0 to 1 in `n_trials` steps. Results are displayed in a table on `stdout`
+    (the corresponding API call to `spacy.cli.find_threshold.find_threshold()`
+    returns all results).
+
+    This is applicable only for components whose predictions are influenced by
+    thresholds - e.g. `textcat_multilabel` and `spancat`, but not `textcat`. Note
+    that the full path to the corresponding threshold attribute in the config has to
+    be provided.
+
+    DOCS: https://spacy.io/api/cli#find-threshold
+    """
+    if verbose:
+        util.logger.setLevel(logging.DEBUG)
+    import_code(code_path)
+    find_threshold(
+        model=model,
+        data_path=data_path,
+        pipe_name=pipe_name,
+        threshold_key=threshold_key,
+        scores_key=scores_key,
+        n_trials=n_trials,
+        use_gpu=use_gpu,
+        gold_preproc=gold_preproc,
+        silent=False,
+    )
+
+
+def find_threshold(
+    model: str,
+    data_path: Path,
+    pipe_name: str,
+    threshold_key: str,
+    scores_key: str,
+    *,
+    n_trials: int = _DEFAULTS["n_trials"],  # type: ignore
+    use_gpu: int = _DEFAULTS["use_gpu"],  # type: ignore
+    gold_preproc: bool = _DEFAULTS["gold_preproc"],  # type: ignore
+    silent: bool = True,
+) -> Tuple[float, float, Dict[float, float]]:
+    """
+    Runs prediction trials for models with varying thresholds to maximize the specified metric.
+    model (Union[str, Path]): Pipeline to evaluate. Can be a package or a path to a data directory.
+    data_path (Path): Path to file with DocBin with docs to use for threshold search.
+    pipe_name (str): Name of pipe to examine thresholds for.
+    threshold_key (str): Key of threshold attribute in component's configuration.
+    scores_key (str): Name of score to metric to optimize.
+    n_trials (int): Number of trials to determine optimal thresholds.
+    use_gpu (int): GPU ID or -1 for CPU.
+    gold_preproc (bool): Whether to use gold preprocessing. Gold preprocessing helps the annotations align to the
+        tokenization, and may result in sequences of more consistent length. However, it may reduce runtime accuracy due
+        to train/test skew.
+    silent (bool): Whether to print non-error-related output to stdout.
+    RETURNS (Tuple[float, float, Dict[float, float]]): Best found threshold, the corresponding score, scores for all
+        evaluated thresholds.
+    """
+
+    setup_gpu(use_gpu, silent=silent)
+    data_path = util.ensure_path(data_path)
+    if not data_path.exists():
+        wasabi.msg.fail("Evaluation data not found", data_path, exits=1)
+    nlp = util.load_model(model)
+
+    if pipe_name not in nlp.component_names:
+        raise AttributeError(
+            Errors.E001.format(name=pipe_name, opts=nlp.component_names)
+        )
+    pipe = nlp.get_pipe(pipe_name)
+    if not hasattr(pipe, "scorer"):
+        raise AttributeError(Errors.E1045)
+
+    if type(pipe) == TextCategorizer:
+        wasabi.msg.warn(
+            "The `textcat` component doesn't use a threshold as it's not applicable to the concept of "
+            "exclusive classes. All thresholds will yield the same results."
+        )
+
+    if not silent:
+        wasabi.msg.info(
+            title=f"Optimizing for {scores_key} for component '{pipe_name}' with {n_trials} "
+            f"trials."
+        )
+
+    # Load evaluation corpus.
+    corpus = Corpus(data_path, gold_preproc=gold_preproc)
+    dev_dataset = list(corpus(nlp))
+    config_keys = threshold_key.split(".")
+
+    def set_nested_item(
+        config: Dict[str, Any], keys: List[str], value: float
+    ) -> Dict[str, Any]:
+        """Set item in nested dictionary. Adapted from https://stackoverflow.com/a/54138200.
+        config (Dict[str, Any]): Configuration dictionary.
+        keys (List[Any]): Path to value to set.
+        value (float): Value to set.
+        RETURNS (Dict[str, Any]): Updated dictionary.
+        """
+        functools.reduce(operator.getitem, keys[:-1], config)[keys[-1]] = value
+        return config
+
+    def filter_config(
+        config: Dict[str, Any], keys: List[str], full_key: str
+    ) -> Dict[str, Any]:
+        """Filters provided config dictionary so that only the specified keys path remains.
+        config (Dict[str, Any]): Configuration dictionary.
+        keys (List[Any]): Path to value to set.
+        full_key (str): Full user-specified key.
+        RETURNS (Dict[str, Any]): Filtered dictionary.
+        """
+        if keys[0] not in config:
+            wasabi.msg.fail(
+                title=f"Failed to look up `{full_key}` in config: sub-key {[keys[0]]} not found.",
+                text=f"Make sure you specified {[keys[0]]} correctly. The following sub-keys are available instead: "
+                f"{list(config.keys())}",
+                exits=1,
+            )
+        return {
+            keys[0]: (
+                filter_config(config[keys[0]], keys[1:], full_key)
+                if len(keys) > 1
+                else config[keys[0]]
+            )
+        }
+
+    # Evaluate with varying threshold values.
+    scores: Dict[float, float] = {}
+    config_keys_full = ["components", pipe_name, *config_keys]
+    table_col_widths = (10, 10)
+    thresholds = numpy.linspace(0, 1, n_trials)
+    print(wasabi.tables.row(["Threshold", f"{scores_key}"], widths=table_col_widths))
+    for threshold in thresholds:
+        # Reload pipeline with overrides specifying the new threshold.
+        nlp = util.load_model(
+            model,
+            config=set_nested_item(
+                filter_config(
+                    nlp.config, config_keys_full, ".".join(config_keys_full)
+                ).copy(),
+                config_keys_full,
+                threshold,
+            ),
+        )
+        if hasattr(pipe, "cfg"):
+            nlp.get_pipe(pipe_name).cfg = set_nested_item(  # type: ignore[attr-defined]
+                pipe.cfg,
+                config_keys,
+                threshold,  # type: ignore[attr-defined]
+            )
+
+        eval_scores = nlp.evaluate(dev_dataset)
+        if scores_key not in eval_scores:
+            wasabi.msg.fail(
+                title=f"Failed to look up score `{scores_key}` in evaluation results.",
+                text=f"Make sure you specified the correct value for `scores_key`. The following scores are "
+                f"available: {list(eval_scores.keys())}",
+                exits=1,
+            )
+        scores[threshold] = eval_scores[scores_key]
+
+        if not isinstance(scores[threshold], (float, int)):
+            wasabi.msg.fail(
+                f"Returned score for key '{scores_key}' is not numeric. Threshold optimization only works for numeric "
+                f"scores.",
+                exits=1,
+            )
+        print(
+            wasabi.row(
+                [round(threshold, 3), round(scores[threshold], 3)],
+                widths=table_col_widths,
+            )
+        )
+
+    best_threshold = max(scores.keys(), key=(lambda key: scores[key]))
+
+    # If all scores are identical, emit warning.
+    if len(set(scores.values())) == 1:
+        wasabi.msg.warn(
+            title="All scores are identical. Verify that all settings are correct.",
+            text=(
+                ""
+                if (
+                    not isinstance(pipe, MultiLabel_TextCategorizer)
+                    or scores_key in ("cats_macro_f", "cats_micro_f")
+                )
+                else "Use `cats_macro_f` or `cats_micro_f` when optimizing the threshold for `textcat_multilabel`."
+            ),
+        )
+
+    else:
+        if not silent:
+            print(
+                f"\nBest threshold: {round(best_threshold, ndigits=4)} with {scores_key} value of {scores[best_threshold]}."
+            )
+
+    return best_threshold, scores[best_threshold], scores

spacy/cli/info.py

@@ -0,0 +1,204 @@
+import json
+import platform
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import srsly
+from wasabi import MarkdownRenderer, Printer
+
+from .. import about, util
+from ..compat import importlib_metadata
+from ._util import Arg, Opt, app, string_to_list
+from .download import get_latest_version, get_model_filename
+
+
+@app.command("info")
+def info_cli(
+    # fmt: off
+    model: Optional[str] = Arg(None, help="Optional loadable spaCy pipeline"),
+    markdown: bool = Opt(
+        False, "--markdown", "-md", help="Generate Markdown for GitHub issues"
+    ),
+    silent: bool = Opt(
+        False, "--silent", "-s", "-S", help="Don't print anything (just return)"
+    ),
+    exclude: str = Opt(
+        "labels",
+        "--exclude",
+        "-e",
+        help="Comma-separated keys to exclude from the print-out",
+    ),
+    url: bool = Opt(
+        False,
+        "--url",
+        "-u",
+        help="Print the URL to download the most recent compatible version of the pipeline",
+    ),
+    # fmt: on
+):
+    """
+    Print info about spaCy installation. If a pipeline is specified as an argument,
+    print its meta information. Flag --markdown prints details in Markdown for easy
+    copy-pasting to GitHub issues.
+
+    Flag --url prints only the download URL of the most recent compatible
+    version of the pipeline.
+
+    DOCS: https://spacy.io/api/cli#info
+    """
+    exclude = string_to_list(exclude)
+    info(
+        model,
+        markdown=markdown,
+        silent=silent,
+        exclude=exclude,
+        url=url,
+    )
+
+
+def info(
+    model: Optional[str] = None,
+    *,
+    markdown: bool = False,
+    silent: bool = True,
+    exclude: Optional[List[str]] = None,
+    url: bool = False,
+) -> Union[str, dict]:
+    msg = Printer(no_print=silent, pretty=not silent)
+    if not exclude:
+        exclude = []
+    if url:
+        if model is not None:
+            title = f"Download info for pipeline '{model}'"
+            data = info_model_url(model)
+            print(data["download_url"])
+            return data
+        else:
+            msg.fail("--url option requires a pipeline name", exits=1)
+    elif model:
+        title = f"Info about pipeline '{model}'"
+        data = info_model(model, silent=silent)
+    else:
+        title = "Info about spaCy"
+        data = info_spacy()
+    raw_data = {k.lower().replace(" ", "_"): v for k, v in data.items()}
+    if "Pipelines" in data and isinstance(data["Pipelines"], dict):
+        data["Pipelines"] = ", ".join(
+            f"{n} ({v})" for n, v in data["Pipelines"].items()
+        )
+    markdown_data = get_markdown(data, title=title, exclude=exclude)
+    if markdown:
+        if not silent:
+            print(markdown_data)
+        return markdown_data
+    if not silent:
+        table_data = {k: v for k, v in data.items() if k not in exclude}
+        msg.table(table_data, title=title)
+    return raw_data
+
+
+def info_spacy() -> Dict[str, Any]:
+    """Generate info about the current spaCy intallation.
+
+    RETURNS (dict): The spaCy info.
+    """
+    all_models = {}
+    for pkg_name in util.get_installed_models():
+        package = pkg_name.replace("-", "_")
+        all_models[package] = util.get_package_version(pkg_name)
+    return {
+        "spaCy version": about.__version__,
+        "Location": str(Path(__file__).parent.parent),
+        "Platform": platform.platform(),
+        "Python version": platform.python_version(),
+        "Pipelines": all_models,
+    }
+
+
+def info_model(model: str, *, silent: bool = True) -> Dict[str, Any]:
+    """Generate info about a specific model.
+
+    model (str): Model name of path.
+    silent (bool): Don't print anything, just return.
+    RETURNS (dict): The model meta.
+    """
+    msg = Printer(no_print=silent, pretty=not silent)
+    if util.is_package(model):
+        model_path = util.get_package_path(model)
+    else:
+        model_path = Path(model)
+    meta_path = model_path / "meta.json"
+    if not meta_path.is_file():
+        msg.fail("Can't find pipeline meta.json", meta_path, exits=1)
+    meta = srsly.read_json(meta_path)
+    if model_path.resolve() != model_path:
+        meta["source"] = str(model_path.resolve())
+    else:
+        meta["source"] = str(model_path)
+    download_url = info_installed_model_url(model)
+    if download_url:
+        meta["download_url"] = download_url
+    return {
+        k: v for k, v in meta.items() if k not in ("accuracy", "performance", "speed")
+    }
+
+
+def info_installed_model_url(model: str) -> Optional[str]:
+    """Given a pipeline name, get the download URL if available, otherwise
+    return None.
+
+    This is only available for pipelines installed as modules that have
+    dist-info available.
+    """
+    try:
+        dist = importlib_metadata.distribution(model)
+        text = dist.read_text("direct_url.json")
+        if isinstance(text, str):
+            data = json.loads(text)
+            return data["url"]
+    except Exception:
+        pass
+    return None
+
+
+def info_model_url(model: str) -> Dict[str, Any]:
+    """Return the download URL for the latest version of a pipeline."""
+    version = get_latest_version(model)
+
+    filename = get_model_filename(model, version)
+    download_url = about.__download_url__ + "/" + filename
+    release_tpl = "https://github.com/explosion/spacy-models/releases/tag/{m}-{v}"
+    release_url = release_tpl.format(m=model, v=version)
+    return {"download_url": download_url, "release_url": release_url}
+
+
+def get_markdown(
+    data: Dict[str, Any],
+    title: Optional[str] = None,
+    exclude: Optional[List[str]] = None,
+) -> str:
+    """Get data in GitHub-flavoured Markdown format for issues etc.
+
+    data (Dict[str, Any]): Label/value pairs.
+    title (str): Optional title, will be rendered as headline 2.
+    exclude (List[str]): Names of keys to exclude.
+    RETURNS (str): The Markdown string.
+    """
+    md = MarkdownRenderer()
+    if title:
+        md.add(md.title(2, title))
+    items = []
+    for key, value in data.items():
+        if exclude and key in exclude:
+            continue
+        if isinstance(value, str):
+            try:
+                existing_path = Path(value).exists()
+            except Exception:
+                # invalid Path, like a URL string
+                existing_path = False
+            if existing_path:
+                continue
+        items.append(f"{md.bold(f'{key}:')} {value}")
+    md.add(md.list(items))
+    return f"\n{md.text}\n"

spacy/cli/init_config.py

@@ -0,0 +1,303 @@
+import re
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import srsly
+from jinja2 import Template
+from thinc.api import Config
+from wasabi import Printer, diff_strings
+
+from .. import util
+from ..language import DEFAULT_CONFIG_PRETRAIN_PATH
+from ..schemas import RecommendationSchema
+from ..util import SimpleFrozenList
+from ._util import (
+    COMMAND,
+    Arg,
+    Opt,
+    import_code,
+    init_cli,
+    show_validation_error,
+    string_to_list,
+)
+
+ROOT = Path(__file__).parent / "templates"
+TEMPLATE_PATH = ROOT / "quickstart_training.jinja"
+RECOMMENDATIONS = srsly.read_yaml(ROOT / "quickstart_training_recommendations.yml")
+
+
+class Optimizations(str, Enum):
+    efficiency = "efficiency"
+    accuracy = "accuracy"
+
+
+class InitValues:
+    """
+    Default values for initialization. Dedicated class to allow synchronized default values for init_config_cli() and
+    init_config(), i.e. initialization calls via CLI respectively Python.
+    """
+
+    lang = "en"
+    pipeline = SimpleFrozenList(["tagger", "parser", "ner"])
+    optimize = Optimizations.efficiency
+    gpu = False
+    pretraining = False
+    force_overwrite = False
+
+
+@init_cli.command("config")
+def init_config_cli(
+    # fmt: off
+    output_file: Path = Arg(
+        ...,
+        help="File to save the config to or - for stdout (will only output config and no additional logging info)",
+        allow_dash=True,
+    ),
+    lang: str = Opt(
+        InitValues.lang, "--lang", "-l", help="Two-letter code of the language to use"
+    ),
+    pipeline: str = Opt(
+        ",".join(InitValues.pipeline),
+        "--pipeline",
+        "-p",
+        help="Comma-separated names of trainable pipeline components to include (without 'tok2vec' or 'transformer')",
+    ),
+    optimize: Optimizations = Opt(
+        InitValues.optimize,
+        "--optimize",
+        "-o",
+        help="Whether to optimize for efficiency (faster inference, smaller model, lower memory consumption) or higher accuracy (potentially larger and slower model). This will impact the choice of architecture, pretrained weights and related hyperparameters.",
+    ),
+    gpu: bool = Opt(
+        InitValues.gpu,
+        "--gpu",
+        "-G",
+        help="Whether the model can run on GPU. This will impact the choice of architecture, pretrained weights and related hyperparameters.",
+    ),
+    pretraining: bool = Opt(
+        InitValues.pretraining,
+        "--pretraining",
+        "-pt",
+        help="Include config for pretraining (with 'spacy pretrain')",
+    ),
+    force_overwrite: bool = Opt(
+        InitValues.force_overwrite,
+        "--force",
+        "-F",
+        help="Force overwriting the output file",
+    ),
+    # fmt: on
+):
+    """
+    Generate a starter config file for training. Based on your requirements
+    specified via the CLI arguments, this command generates a config with the
+    optimal settings for your use case. This includes the choice of architecture,
+    pretrained weights and related hyperparameters.
+
+    DOCS: https://spacy.io/api/cli#init-config
+    """
+    pipeline = string_to_list(pipeline)
+    is_stdout = str(output_file) == "-"
+    if not is_stdout and output_file.exists() and not force_overwrite:
+        msg = Printer()
+        msg.fail(
+            "The provided output file already exists. To force overwriting the config file, set the --force or -F flag.",
+            exits=1,
+        )
+    config = init_config(
+        lang=lang,
+        pipeline=pipeline,
+        optimize=optimize.value,
+        gpu=gpu,
+        pretraining=pretraining,
+        silent=is_stdout,
+    )
+    save_config(config, output_file, is_stdout=is_stdout)
+
+
+@init_cli.command("fill-config")
+def init_fill_config_cli(
+    # fmt: off
+    base_path: Path = Arg(
+        ..., help="Path to base config to fill", exists=True, dir_okay=False
+    ),
+    output_file: Path = Arg(
+        "-", help="Path to output .cfg file (or - for stdout)", allow_dash=True
+    ),
+    pretraining: bool = Opt(
+        False,
+        "--pretraining",
+        "-pt",
+        help="Include config for pretraining (with 'spacy pretrain')",
+    ),
+    diff: bool = Opt(
+        False, "--diff", "-D", help="Print a visual diff highlighting the changes"
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code-path",
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    # fmt: on
+):
+    """
+    Fill partial config file with default values. Will add all missing settings
+    from the default config and will create all objects, check the registered
+    functions for their default values and update the base config. This command
+    can be used with a config generated via the training quickstart widget:
+    https://spacy.io/usage/training#quickstart
+
+    DOCS: https://spacy.io/api/cli#init-fill-config
+    """
+    import_code(code_path)
+    fill_config(output_file, base_path, pretraining=pretraining, diff=diff)
+
+
+def fill_config(
+    output_file: Path,
+    base_path: Path,
+    *,
+    pretraining: bool = False,
+    diff: bool = False,
+    silent: bool = False,
+) -> Tuple[Config, Config]:
+    is_stdout = str(output_file) == "-"
+    no_print = is_stdout or silent
+    msg = Printer(no_print=no_print)
+    with show_validation_error(hint_fill=False):
+        config = util.load_config(base_path)
+        nlp = util.load_model_from_config(config, auto_fill=True, validate=False)
+    # Load a second time with validation to be extra sure that the produced
+    # config result is a valid config
+    nlp = util.load_model_from_config(nlp.config)
+    filled = nlp.config
+    # If we have sourced components in the base config, those will have been
+    # replaced with their actual config after loading, so we have to re-add them
+    sourced = util.get_sourced_components(config)
+    filled["components"].update(sourced)
+    if pretraining:
+        validate_config_for_pretrain(filled, msg)
+        pretrain_config = util.load_config(DEFAULT_CONFIG_PRETRAIN_PATH)
+        filled = pretrain_config.merge(filled)
+    before = config.to_str()
+    after = filled.to_str()
+    if before == after:
+        msg.warn("Nothing to auto-fill: base config is already complete")
+    else:
+        msg.good("Auto-filled config with all values")
+    if diff and not no_print:
+        if before == after:
+            msg.warn("No diff to show: nothing was auto-filled")
+        else:
+            msg.divider("START CONFIG DIFF")
+            print("")
+            print(diff_strings(before, after))
+            msg.divider("END CONFIG DIFF")
+            print("")
+    save_config(filled, output_file, is_stdout=is_stdout, silent=silent)
+    return config, filled
+
+
+def init_config(
+    *,
+    lang: str = InitValues.lang,
+    pipeline: List[str] = InitValues.pipeline,
+    optimize: str = InitValues.optimize,
+    gpu: bool = InitValues.gpu,
+    pretraining: bool = InitValues.pretraining,
+    silent: bool = True,
+) -> Config:
+    msg = Printer(no_print=silent)
+    with TEMPLATE_PATH.open("r") as f:
+        template = Template(f.read())
+    # Filter out duplicates since tok2vec and transformer are added by template
+    pipeline = [pipe for pipe in pipeline if pipe not in ("tok2vec", "transformer")]
+    defaults = RECOMMENDATIONS["__default__"]
+    reco = RecommendationSchema(**RECOMMENDATIONS.get(lang, defaults)).model_dump()
+    variables = {
+        "lang": lang,
+        "components": pipeline,
+        "optimize": optimize,
+        "hardware": "gpu" if gpu else "cpu",
+        "transformer_data": reco["transformer"],
+        "word_vectors": reco["word_vectors"],
+        "has_letters": reco["has_letters"],
+    }
+    if variables["transformer_data"] and not has_spacy_transformers():
+        msg.warn(
+            "To generate a more effective transformer-based config (GPU-only), "
+            "install the spacy-transformers package and re-run this command. "
+            "The config generated now does not use transformers."
+        )
+        variables["transformer_data"] = None
+    base_template = template.render(variables).strip()
+    # Giving up on getting the newlines right in jinja for now
+    base_template = re.sub(r"\n\n\n+", "\n\n", base_template)
+    # Access variables declared in templates
+    template_vars = template.make_module(variables)
+    use_case = {
+        "Language": lang,
+        "Pipeline": ", ".join(pipeline),
+        "Optimize for": optimize,
+        "Hardware": variables["hardware"].upper(),
+        "Transformer": (
+            template_vars.transformer.get("name")  # type: ignore[attr-defined]
+            if template_vars.use_transformer  # type: ignore[attr-defined]
+            else None
+        ),
+    }
+    msg.info("Generated config template specific for your use case")
+    for label, value in use_case.items():
+        msg.text(f"- {label}: {value}")
+    with show_validation_error(hint_fill=False):
+        config = util.load_config_from_str(base_template)
+        nlp = util.load_model_from_config(config, auto_fill=True)
+        config = nlp.config
+        if pretraining:
+            validate_config_for_pretrain(config, msg)
+            pretrain_config = util.load_config(DEFAULT_CONFIG_PRETRAIN_PATH)
+            config = pretrain_config.merge(config)
+    msg.good("Auto-filled config with all values")
+    return config
+
+
+def save_config(
+    config: Config, output_file: Path, is_stdout: bool = False, silent: bool = False
+) -> None:
+    no_print = is_stdout or silent
+    msg = Printer(no_print=no_print)
+    if is_stdout:
+        print(config.to_str())
+    else:
+        if not output_file.parent.exists():
+            output_file.parent.mkdir(parents=True)
+        config.to_disk(output_file, interpolate=False)
+        msg.good("Saved config", output_file)
+        msg.text("You can now add your data and train your pipeline:")
+        variables = ["--paths.train ./train.spacy", "--paths.dev ./dev.spacy"]
+        if not no_print:
+            print(f"{COMMAND} train {output_file.parts[-1]} {' '.join(variables)}")
+
+
+def has_spacy_transformers() -> bool:
+    try:
+        import spacy_transformers  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def validate_config_for_pretrain(config: Config, msg: Printer) -> None:
+    if "tok2vec" not in config["nlp"]["pipeline"]:
+        msg.warn(
+            "No tok2vec component found in the pipeline. If your tok2vec "
+            "component has a different name, you may need to adjust the "
+            "tok2vec_model reference in the [pretraining] block. If you don't "
+            "have a tok2vec component, make sure to add it to your [components] "
+            "and the pipeline specified in the [nlp] block, so you can pretrain "
+            "weights for it."
+        )

spacy/cli/init_pipeline.py

@@ -0,0 +1,197 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+import srsly
+import typer
+from wasabi import msg
+
+from .. import util
+from ..language import Language
+from ..training.initialize import convert_vectors, init_nlp
+from ._util import (
+    Arg,
+    Opt,
+    import_code,
+    init_cli,
+    parse_config_overrides,
+    setup_gpu,
+    show_validation_error,
+)
+
+
+@init_cli.command("vectors")
+def init_vectors_cli(
+    # fmt: off
+    lang: str = Arg(..., help="The language of the nlp object to create"),
+    vectors_loc: Path = Arg(..., help="Vectors file in Word2Vec format", exists=True),
+    output_dir: Path = Arg(..., help="Pipeline output directory"),
+    prune: int = Opt(
+        -1, "--prune", "-p", help="Optional number of vectors to prune to"
+    ),
+    truncate: int = Opt(
+        0,
+        "--truncate",
+        "-t",
+        help="Optional number of vectors to truncate to when reading in vectors file",
+    ),
+    mode: str = Opt("default", "--mode", "-m", help="Vectors mode: default or floret"),
+    name: Optional[str] = Opt(
+        None,
+        "--name",
+        "-n",
+        help="Optional name for the word vectors, e.g. en_core_web_lg.vectors",
+    ),
+    verbose: bool = Opt(
+        False,
+        "--verbose",
+        "-V",
+        "-VV",
+        help="Display more information for debugging purposes",
+    ),
+    jsonl_loc: Optional[Path] = Opt(
+        None,
+        "--lexemes-jsonl",
+        "-j",
+        help="Location of JSONL-formatted attributes file",
+        hidden=True,
+    ),
+    attr: str = Opt(
+        "ORTH",
+        "--attr",
+        "-a",
+        help="Optional token attribute to use for vectors, e.g. LOWER or NORM",
+    ),
+    # fmt: on
+):
+    """Convert word vectors for use with spaCy. Will export an nlp object that
+    you can use in the [initialize] block of your config to initialize
+    a model with vectors.
+    """
+    if verbose:
+        util.logger.setLevel(logging.DEBUG)
+    msg.info(f"Creating blank nlp object for language '{lang}'")
+    nlp = util.get_lang_class(lang)()
+    if jsonl_loc is not None:
+        update_lexemes(nlp, jsonl_loc)
+    convert_vectors(
+        nlp,
+        vectors_loc,
+        truncate=truncate,
+        prune=prune,
+        name=name,
+        mode=mode,
+        attr=attr,
+    )
+    msg.good(f"Successfully converted {len(nlp.vocab.vectors)} vectors")
+    nlp.to_disk(output_dir)
+    msg.good(
+        "Saved nlp object with vectors to output directory. You can now use the "
+        "path to it in your config as the 'vectors' setting in [initialize].",
+        output_dir.resolve(),
+    )
+
+
+def update_lexemes(nlp: Language, jsonl_loc: Path) -> None:
+    # Mostly used for backwards-compatibility and may be removed in the future
+    lex_attrs = srsly.read_jsonl(jsonl_loc)
+    for attrs in lex_attrs:
+        if "settings" in attrs:
+            continue
+        lexeme = nlp.vocab[attrs["orth"]]
+        lexeme.set_attrs(**attrs)
+
+
+@init_cli.command(
+    "nlp",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+    hidden=True,
+)
+def init_pipeline_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    output_path: Path = Arg(..., help="Output directory for the prepared data"),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    verbose: bool = Opt(
+        False,
+        "--verbose",
+        "-V",
+        "-VV",
+        help="Display more information for debugging purposes",
+    ),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    # fmt: on
+):
+    if verbose:
+        util.logger.setLevel(logging.DEBUG)
+    overrides = parse_config_overrides(ctx.args)
+    import_code(code_path)
+    setup_gpu(use_gpu)
+    with show_validation_error(config_path):
+        config = util.load_config(config_path, overrides=overrides)
+    with show_validation_error(hint_fill=False):
+        nlp = init_nlp(config, use_gpu=use_gpu)
+    nlp.to_disk(output_path)
+    msg.good(f"Saved initialized pipeline to {output_path}")
+
+
+@init_cli.command(
+    "labels",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def init_labels_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    output_path: Path = Arg(..., help="Output directory for the labels"),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    verbose: bool = Opt(
+        False,
+        "--verbose",
+        "-V",
+        "-VV",
+        help="Display more information for debugging purposes",
+    ),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    # fmt: on
+):
+    """Generate JSON files for the labels in the data. This helps speed up the
+    training process, since spaCy won't have to preprocess the data to
+    extract the labels."""
+    if verbose:
+        util.logger.setLevel(logging.DEBUG)
+    if not output_path.exists():
+        output_path.mkdir(parents=True)
+    overrides = parse_config_overrides(ctx.args)
+    import_code(code_path)
+    setup_gpu(use_gpu)
+    with show_validation_error(config_path):
+        config = util.load_config(config_path, overrides=overrides)
+    with show_validation_error(hint_fill=False):
+        nlp = init_nlp(config, use_gpu=use_gpu)
+    _init_labels(nlp, output_path)
+
+
+def _init_labels(nlp, output_path):
+    for name, component in nlp.pipeline:
+        if getattr(component, "label_data", None) is not None:
+            output_file = output_path / f"{name}.json"
+            srsly.write_json(output_file, component.label_data)
+            msg.good(f"Saving label data for component '{name}' to {output_file}")
+        else:
+            msg.info(f"No label data found for component '{name}'")

spacy/cli/package.py

@@ -0,0 +1,654 @@
+import os
+import re
+import shutil
+import subprocess
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+
+import srsly
+from catalogue import RegistryError
+from thinc.api import Config
+from wasabi import MarkdownRenderer, Printer, get_raw_input
+
+from .. import about, util
+from ..compat import importlib_metadata
+from ..schemas import ModelMetaSchema, validate
+from ._util import SDIST_SUFFIX, WHEEL_SUFFIX, Arg, Opt, app, string_to_list
+
+
+@app.command("package")
+def package_cli(
+    # fmt: off
+    input_dir: Path = Arg(
+        ..., help="Directory with pipeline data", exists=True, file_okay=False
+    ),
+    output_dir: Path = Arg(
+        ..., help="Output parent directory", exists=True, file_okay=False
+    ),
+    code_paths: str = Opt(
+        "",
+        "--code",
+        "-c",
+        help="Comma-separated paths to Python file with additional code (registered functions) to be included in the package",
+    ),
+    meta_path: Optional[Path] = Opt(
+        None,
+        "--meta-path",
+        "--meta",
+        "-m",
+        help="Path to meta.json",
+        exists=True,
+        dir_okay=False,
+    ),
+    create_meta: bool = Opt(
+        False, "--create-meta", "-C", help="Create meta.json, even if one exists"
+    ),
+    name: Optional[str] = Opt(
+        None, "--name", "-n", help="Package name to override meta"
+    ),
+    version: Optional[str] = Opt(
+        None, "--version", "-v", help="Package version to override meta"
+    ),
+    build: str = Opt(
+        "sdist",
+        "--build",
+        "-b",
+        help="Comma-separated formats to build: sdist and/or wheel, or none.",
+    ),
+    force: bool = Opt(
+        False,
+        "--force",
+        "-f",
+        "-F",
+        help="Force overwriting existing data in output directory",
+    ),
+    require_parent: bool = Opt(
+        True,
+        "--require-parent/--no-require-parent",
+        "-R",
+        "-R",
+        help="Include the parent package (e.g. spacy) in the requirements",
+    ),
+    # fmt: on
+):
+    """
+    Generate an installable Python package for a pipeline. Includes binary data,
+    meta and required installation files. A new directory will be created in the
+    specified output directory, and the data will be copied over. If
+    --create-meta is set and a meta.json already exists in the output directory,
+    the existing values will be used as the defaults in the command-line prompt.
+    After packaging, "python -m build --sdist" is run in the package directory,
+    which will create a .tar.gz archive that can be installed via "pip install".
+
+    If additional code files are provided (e.g. Python files containing custom
+    registered functions like pipeline components), they are copied into the
+    package and imported in the __init__.py.
+
+    DOCS: https://spacy.io/api/cli#package
+    """
+    create_sdist, create_wheel = get_build_formats(string_to_list(build))
+    code_paths = [Path(p.strip()) for p in string_to_list(code_paths)]
+    package(
+        input_dir,
+        output_dir,
+        meta_path=meta_path,
+        code_paths=code_paths,
+        name=name,
+        version=version,
+        create_meta=create_meta,
+        create_sdist=create_sdist,
+        create_wheel=create_wheel,
+        force=force,
+        require_parent=require_parent,
+        silent=False,
+    )
+
+
+def package(
+    input_dir: Path,
+    output_dir: Path,
+    meta_path: Optional[Path] = None,
+    code_paths: List[Path] = [],
+    name: Optional[str] = None,
+    version: Optional[str] = None,
+    create_meta: bool = False,
+    create_sdist: bool = True,
+    create_wheel: bool = False,
+    require_parent: bool = False,
+    force: bool = False,
+    silent: bool = True,
+) -> None:
+    msg = Printer(no_print=silent, pretty=not silent)
+    input_path = util.ensure_path(input_dir)
+    output_path = util.ensure_path(output_dir)
+    meta_path = util.ensure_path(meta_path)
+    if create_wheel and not has_wheel() and not has_build():
+        err = (
+            "Generating wheels requires 'build' or 'wheel' (deprecated) to be installed"
+        )
+        msg.fail(err, "pip install build", exits=1)
+    if not has_build():
+        msg.warn(
+            "Generating packages without the 'build' package is deprecated and "
+            "will not be supported in the future. To install 'build': pip "
+            "install build"
+        )
+    if not input_path or not input_path.exists():
+        msg.fail("Can't locate pipeline data", input_path, exits=1)
+    if not output_path or not output_path.exists():
+        msg.fail("Output directory not found", output_path, exits=1)
+    if create_sdist or create_wheel:
+        opts = ["sdist" if create_sdist else "", "wheel" if create_wheel else ""]
+        msg.info(f"Building package artifacts: {', '.join(opt for opt in opts if opt)}")
+    for code_path in code_paths:
+        if not code_path.exists():
+            msg.fail("Can't find code file", code_path, exits=1)
+        # Import the code here so it's available when model is loaded (via
+        # get_meta helper). Also verifies that everything works
+        util.import_file(code_path.stem, code_path)
+    if code_paths:
+        msg.good(f"Including {len(code_paths)} Python module(s) with custom code")
+    if meta_path and not meta_path.exists():
+        msg.fail("Can't find pipeline meta.json", meta_path, exits=1)
+    meta_path = meta_path or input_dir / "meta.json"
+    if not meta_path.exists() or not meta_path.is_file():
+        msg.fail("Can't load pipeline meta.json", meta_path, exits=1)
+    meta = srsly.read_json(meta_path)
+    meta = get_meta(input_dir, meta, require_parent=require_parent)
+    if meta["requirements"]:
+        msg.good(
+            f"Including {len(meta['requirements'])} package requirement(s) from "
+            f"meta and config",
+            ", ".join(meta["requirements"]),
+        )
+    if name is not None:
+        if not name.isidentifier():
+            msg.fail(
+                f"Model name ('{name}') is not a valid module name. "
+                "This is required so it can be imported as a module.",
+                "We recommend names that use ASCII A-Z, a-z, _ (underscore), "
+                "and 0-9. "
+                "For specific details see: https://docs.python.org/3/reference/lexical_analysis.html#identifiers",
+                exits=1,
+            )
+        if not _is_permitted_package_name(name):
+            msg.fail(
+                f"Model name ('{name}') is not a permitted package name. "
+                "This is required to correctly load the model with spacy.load.",
+                "We recommend names that use ASCII A-Z, a-z, _ (underscore), "
+                "and 0-9. "
+                "For specific details see: https://www.python.org/dev/peps/pep-0426/#name",
+                exits=1,
+            )
+        meta["name"] = name
+    if version is not None:
+        meta["version"] = version
+    if not create_meta:  # only print if user doesn't want to overwrite
+        msg.good("Loaded meta.json from file", meta_path)
+    else:
+        meta = generate_meta(meta, msg)
+    errors = validate(ModelMetaSchema, meta)
+    if errors:
+        msg.fail("Invalid pipeline meta.json")
+        print("\n".join(errors))
+        sys.exit(1)
+    model_name = meta["name"]
+    if not model_name.startswith(meta["lang"] + "_"):
+        model_name = f"{meta['lang']}_{model_name}"
+    model_name_v = model_name + "-" + meta["version"]
+    main_path = output_dir / model_name_v
+    package_path = main_path / model_name
+    if package_path.exists():
+        if force:
+            shutil.rmtree(str(package_path))
+        else:
+            msg.fail(
+                "Package directory already exists",
+                "Please delete the directory and try again, or use the "
+                "`--force` flag to overwrite existing directories.",
+                exits=1,
+            )
+    Path.mkdir(package_path, parents=True)
+    shutil.copytree(str(input_dir), str(package_path / model_name_v))
+    for file_name in FILENAMES_DOCS:
+        file_path = package_path / model_name_v / file_name
+        if file_path.exists():
+            shutil.copy(str(file_path), str(main_path))
+    readme_path = main_path / "README.md"
+    if not readme_path.exists():
+        readme = generate_readme(meta)
+        create_file(readme_path, readme)
+        create_file(package_path / model_name_v / "README.md", readme)
+        msg.good("Generated README.md from meta.json")
+    else:
+        msg.info("Using existing README.md from pipeline directory")
+    imports = []
+    for code_path in code_paths:
+        imports.append(code_path.stem)
+        shutil.copy(str(code_path), str(package_path))
+    create_file(main_path / "meta.json", srsly.json_dumps(meta, indent=2))
+
+    create_file(main_path / "setup.py", TEMPLATE_SETUP)
+    create_file(main_path / "MANIFEST.in", TEMPLATE_MANIFEST)
+    init_py = TEMPLATE_INIT.format(
+        imports="\n".join(f"from . import {m}" for m in imports)
+    )
+    create_file(package_path / "__init__.py", init_py)
+    msg.good(f"Successfully created package directory '{model_name_v}'", main_path)
+    if create_sdist:
+        with util.working_dir(main_path):
+            # run directly, since util.run_command is not designed to continue
+            # after a command fails
+            ret = subprocess.run(
+                [sys.executable, "-m", "build", ".", "--sdist"],
+                env=os.environ.copy(),
+            )
+            if ret.returncode != 0:
+                msg.warn(
+                    "Creating sdist with 'python -m build' failed. Falling "
+                    "back to deprecated use of 'python setup.py sdist'"
+                )
+                util.run_command([sys.executable, "setup.py", "sdist"], capture=False)
+        zip_file = main_path / "dist" / f"{model_name_v}{SDIST_SUFFIX}"
+        msg.good(f"Successfully created zipped Python package", zip_file)
+    if create_wheel:
+        with util.working_dir(main_path):
+            # run directly, since util.run_command is not designed to continue
+            # after a command fails
+            ret = subprocess.run(
+                [sys.executable, "-m", "build", ".", "--wheel"],
+                env=os.environ.copy(),
+            )
+            if ret.returncode != 0:
+                msg.warn(
+                    "Creating wheel with 'python -m build' failed. Falling "
+                    "back to deprecated use of 'wheel' with "
+                    "'python setup.py bdist_wheel'"
+                )
+                util.run_command(
+                    [sys.executable, "setup.py", "bdist_wheel"], capture=False
+                )
+        wheel_name_squashed = re.sub("_+", "_", model_name_v)
+        wheel = main_path / "dist" / f"{wheel_name_squashed}{WHEEL_SUFFIX}"
+        msg.good(f"Successfully created binary wheel", wheel)
+    if "__" in model_name:
+        msg.warn(
+            f"Model name ('{model_name}') contains a run of underscores. "
+            "Runs of underscores are not significant in installed package names.",
+        )
+
+
+def has_wheel() -> bool:
+    try:
+        import wheel  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def has_build() -> bool:
+    # it's very likely that there is a local directory named build/ (especially
+    # in an editable install), so an import check is not sufficient; instead
+    # check that there is a package version
+    try:
+        importlib_metadata.version("build")
+        return True
+    except importlib_metadata.PackageNotFoundError:  # type: ignore[attr-defined]
+        return False
+
+
+def get_third_party_dependencies(
+    config: Config, exclude: List[str] = util.SimpleFrozenList()
+) -> List[str]:
+    """If the config includes references to registered functions that are
+    provided by third-party packages (spacy-transformers, other libraries), we
+    want to include them in meta["requirements"] so that the package specifies
+    them as dependencies and the user won't have to do it manually.
+
+    We do this by:
+    - traversing the config to check for registered function (@ keys)
+    - looking up the functions and getting their module
+    - looking up the module version and generating an appropriate version range
+
+    config (Config): The pipeline config.
+    exclude (list): List of packages to exclude (e.g. that already exist in meta).
+    RETURNS (list): The versioned requirements.
+    """
+    own_packages = ("spacy", "spacy-legacy", "spacy-nightly", "thinc", "srsly")
+    distributions = util.packages_distributions()
+    funcs = defaultdict(set)
+    # We only want to look at runtime-relevant sections, not [training] or [initialize]
+    for section in ("nlp", "components"):
+        for path, value in util.walk_dict(config[section]):
+            if path[-1].startswith("@"):  # collect all function references by registry
+                funcs[path[-1][1:]].add(value)
+    for component in config.get("components", {}).values():
+        if "factory" in component:
+            funcs["factories"].add(component["factory"])
+    modules = set()
+    lang = config["nlp"]["lang"]
+    for reg_name, func_names in funcs.items():
+        for func_name in func_names:
+            # Try the lang-specific version and fall back
+            try:
+                func_info = util.registry.find(reg_name, lang + "." + func_name)
+            except RegistryError:
+                try:
+                    func_info = util.registry.find(reg_name, func_name)
+                except RegistryError as regerr:
+                    # lang-specific version being absent is not actually an issue
+                    raise regerr from None
+            module_name = func_info.get("module")  # type: ignore[attr-defined]
+            if module_name:  # the code is part of a module, not a --code file
+                modules.add(func_info["module"].split(".")[0])  # type: ignore[union-attr]
+    dependencies = []
+    for module_name in modules:
+        if module_name == about.__title__:
+            continue
+        if module_name in distributions:
+            dist = distributions.get(module_name)
+            if dist:
+                pkg = dist[0]
+                if pkg in own_packages or pkg in exclude:
+                    continue
+                version = util.get_package_version(pkg)
+                version_range = util.get_minor_version_range(version)  # type: ignore[arg-type]
+                dependencies.append(f"{pkg}{version_range}")
+    return dependencies
+
+
+def get_build_formats(formats: List[str]) -> Tuple[bool, bool]:
+    supported = ["sdist", "wheel", "none"]
+    for form in formats:
+        if form not in supported:
+            msg = Printer()
+            err = f"Unknown build format: {form}. Supported: {', '.join(supported)}"
+            msg.fail(err, exits=1)
+    if not formats or "none" in formats:
+        return (False, False)
+    return ("sdist" in formats, "wheel" in formats)
+
+
+def create_file(file_path: Path, contents: str) -> None:
+    file_path.touch()
+    file_path.open("w", encoding="utf-8").write(contents)
+
+
+def get_meta(
+    model_path: Union[str, Path],
+    existing_meta: Dict[str, Any],
+    require_parent: bool = False,
+) -> Dict[str, Any]:
+    meta: Dict[str, Any] = {
+        "lang": "en",
+        "name": "pipeline",
+        "version": "0.0.0",
+        "description": "",
+        "author": "",
+        "email": "",
+        "url": "",
+        "license": "MIT",
+    }
+    nlp = util.load_model_from_path(Path(model_path))
+    meta.update(nlp.meta)
+    meta["spacy_version"] = util.get_minor_version_range(about.__version__)
+    meta.update(existing_meta)
+    meta["vectors"] = {
+        "width": nlp.vocab.vectors_length,
+        "vectors": len(nlp.vocab.vectors),
+        "keys": nlp.vocab.vectors.n_keys,
+        "name": nlp.vocab.vectors.name,
+    }
+    if about.__title__ != "spacy":
+        meta["parent_package"] = about.__title__
+    meta.setdefault("requirements", [])
+    # Update the requirements with all third-party packages in the config
+    existing_reqs = [util.split_requirement(req)[0] for req in meta["requirements"]]
+    reqs = get_third_party_dependencies(nlp.config, exclude=existing_reqs)
+    meta["requirements"].extend(reqs)
+    if require_parent and about.__title__ not in meta["requirements"]:
+        meta["requirements"].append(about.__title__ + meta["spacy_version"])
+    return meta
+
+
+def generate_meta(existing_meta: Dict[str, Any], msg: Printer) -> Dict[str, Any]:
+    meta = existing_meta or {}
+    settings = [
+        ("lang", "Pipeline language", meta.get("lang", "en")),
+        ("name", "Pipeline name", meta.get("name", "pipeline")),
+        ("version", "Package version", meta.get("version", "0.0.0")),
+        ("description", "Package description", meta.get("description", None)),
+        ("author", "Author", meta.get("author", None)),
+        ("email", "Author email", meta.get("email", None)),
+        ("url", "Author website", meta.get("url", None)),
+        ("license", "License", meta.get("license", "MIT")),
+    ]
+    msg.divider("Generating meta.json")
+    msg.text(
+        "Enter the package settings for your pipeline. The following information "
+        "will be read from your pipeline data: pipeline, vectors."
+    )
+    for setting, desc, default in settings:
+        response = get_raw_input(desc, default)
+        meta[setting] = default if response == "" and default else response
+    return meta
+
+
+def generate_readme(meta: Dict[str, Any]) -> str:
+    """
+    Generate a Markdown-formatted README text from a model meta.json. Used
+    within the GitHub release notes and as content for README.md file added
+    to model packages.
+    """
+    md = MarkdownRenderer()
+    lang = meta["lang"]
+    name = f"{lang}_{meta['name']}"
+    version = meta["version"]
+    pipeline = ", ".join([md.code(p) for p in meta.get("pipeline", [])])
+    components = ", ".join([md.code(p) for p in meta.get("components", [])])
+    vecs = meta.get("vectors", {})
+    vectors = f"{vecs.get('keys', 0)} keys, {vecs.get('vectors', 0)} unique vectors ({vecs.get('width', 0)} dimensions)"
+    author = meta.get("author") or "n/a"
+    notes = meta.get("notes", "")
+    license_name = meta.get("license")
+    sources = _format_sources(meta.get("sources"))
+    description = meta.get("description")
+    label_scheme = _format_label_scheme(cast(Dict[str, Any], meta.get("labels")))
+    accuracy = _format_accuracy(cast(Dict[str, Any], meta.get("performance")))
+    table_data = [
+        (md.bold("Name"), md.code(name)),
+        (md.bold("Version"), md.code(version)),
+        (md.bold("spaCy"), md.code(meta["spacy_version"])),
+        (md.bold("Default Pipeline"), pipeline),
+        (md.bold("Components"), components),
+        (md.bold("Vectors"), vectors),
+        (md.bold("Sources"), sources or "n/a"),
+        (md.bold("License"), md.code(license_name) if license_name else "n/a"),
+        (md.bold("Author"), md.link(author, meta["url"]) if "url" in meta else author),
+    ]
+    # Put together Markdown body
+    if description:
+        md.add(description)
+    md.add(md.table(table_data, ["Feature", "Description"]))
+    if label_scheme:
+        md.add(md.title(3, "Label Scheme"))
+        md.add(label_scheme)
+    if accuracy:
+        md.add(md.title(3, "Accuracy"))
+        md.add(accuracy)
+    if notes:
+        md.add(notes)
+    return md.text
+
+
+def _format_sources(data: Any) -> str:
+    if not data or not isinstance(data, list):
+        return "n/a"
+    sources = []
+    for source in data:
+        if not isinstance(source, dict):
+            source = {"name": source}
+        name = source.get("name")
+        if not name:
+            continue
+        url = source.get("url")
+        author = source.get("author")
+        result = name if not url else "[{}]({})".format(name, url)
+        if author:
+            result += " ({})".format(author)
+        sources.append(result)
+    return "<br>".join(sources)
+
+
+def _format_accuracy(data: Dict[str, Any], exclude: List[str] = ["speed"]) -> str:
+    if not data:
+        return ""
+    md = MarkdownRenderer()
+    scalars = [(k, v) for k, v in data.items() if isinstance(v, (int, float))]
+    scores = [
+        (md.code(acc.upper()), f"{score * 100:.2f}")
+        for acc, score in scalars
+        if acc not in exclude
+    ]
+    md.add(md.table(scores, ["Type", "Score"]))
+    return md.text
+
+
+def _format_label_scheme(data: Dict[str, Any]) -> str:
+    if not data:
+        return ""
+    md = MarkdownRenderer()
+    n_labels = 0
+    n_pipes = 0
+    label_data = []
+    for pipe, labels in data.items():
+        if not labels:
+            continue
+        col1 = md.bold(md.code(pipe))
+        col2 = ", ".join([md.code(str(label).replace("|", "\\|")) for label in labels])  # noqa: W605
+        label_data.append((col1, col2))
+        n_labels += len(labels)
+        n_pipes += 1
+    if not label_data:
+        return ""
+    label_info = f"View label scheme ({n_labels} labels for {n_pipes} components)"
+    md.add("<details>")
+    md.add(f"<summary>{label_info}</summary>")
+    md.add(md.table(label_data, ["Component", "Labels"]))
+    md.add("</details>")
+    return md.text
+
+
+def _is_permitted_package_name(package_name: str) -> bool:
+    # regex from: https://www.python.org/dev/peps/pep-0426/#name
+    permitted_match = re.search(
+        r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", package_name, re.IGNORECASE
+    )
+    return permitted_match is not None
+
+
+TEMPLATE_SETUP = """
+#!/usr/bin/env python
+import io
+import json
+from os import path, walk
+from shutil import copy
+from setuptools import setup
+
+
+def load_meta(fp):
+    with io.open(fp, encoding='utf8') as f:
+        return json.load(f)
+
+
+def load_readme(fp):
+    if path.exists(fp):
+        with io.open(fp, encoding='utf8') as f:
+            return f.read()
+    return ""
+
+
+def list_files(data_dir):
+    output = []
+    for root, _, filenames in walk(data_dir):
+        for filename in filenames:
+            if not filename.startswith('.'):
+                output.append(path.join(root, filename))
+    output = [path.relpath(p, path.dirname(data_dir)) for p in output]
+    output.append('meta.json')
+    return output
+
+
+def list_requirements(meta):
+    # Up to version 3.7, we included the parent package
+    # in requirements by default. This behaviour is removed
+    # in 3.8, with a setting to include the parent package in
+    # the requirements list in the meta if desired.
+    requirements = []
+    if 'setup_requires' in meta:
+        requirements += meta['setup_requires']
+    if 'requirements' in meta:
+        requirements += meta['requirements']
+    return requirements
+
+
+def setup_package():
+    root = path.abspath(path.dirname(__file__))
+    meta_path = path.join(root, 'meta.json')
+    meta = load_meta(meta_path)
+    readme_path = path.join(root, 'README.md')
+    readme = load_readme(readme_path)
+    model_name = str(meta['lang'] + '_' + meta['name'])
+    model_dir = path.join(model_name, model_name + '-' + meta['version'])
+
+    copy(meta_path, path.join(model_name))
+    copy(meta_path, model_dir)
+
+    setup(
+        name=model_name,
+        description=meta.get('description'),
+        long_description=readme,
+        author=meta.get('author'),
+        author_email=meta.get('email'),
+        url=meta.get('url'),
+        version=meta['version'],
+        license=meta.get('license'),
+        packages=[model_name],
+        package_data={model_name: list_files(model_dir)},
+        install_requires=list_requirements(meta),
+        zip_safe=False,
+        entry_points={'spacy_models': ['{m} = {m}'.format(m=model_name)]}
+    )
+
+
+if __name__ == '__main__':
+    setup_package()
+""".lstrip()
+
+
+TEMPLATE_MANIFEST = """
+include meta.json
+include LICENSE
+include LICENSES_SOURCES
+include README.md
+""".strip()
+
+
+TEMPLATE_INIT = """
+from pathlib import Path
+from spacy.util import load_model_from_init_py, get_model_meta
+
+{imports}
+
+__version__ = get_model_meta(Path(__file__).parent)['version']
+
+
+def load(**overrides):
+    return load_model_from_init_py(__file__, **overrides)
+""".lstrip()
+
+
+FILENAMES_DOCS = ["LICENSE", "LICENSES_SOURCES", "README.md"]

spacy/cli/pretrain.py

@@ -0,0 +1,144 @@
+import re
+from pathlib import Path
+from typing import Optional
+
+import typer
+from wasabi import msg
+
+from ..training.pretrain import pretrain
+from ..util import load_config
+from ._util import (
+    Arg,
+    Opt,
+    app,
+    import_code,
+    parse_config_overrides,
+    setup_gpu,
+    show_validation_error,
+)
+
+
+@app.command(
+    "pretrain",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def pretrain_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, dir_okay=False, allow_dash=True
+    ),
+    output_dir: Path = Arg(..., help="Directory to write weights to on each epoch"),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    resume_path: Optional[Path] = Opt(
+        None,
+        "--resume-path",
+        "-r",
+        help="Path to pretrained weights from which to resume pretraining",
+    ),
+    epoch_resume: Optional[int] = Opt(
+        None,
+        "--epoch-resume",
+        "-er",
+        help="The epoch to resume counting from when using --resume-path. Prevents unintended overwriting of existing weight files.",
+    ),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    skip_last: bool = Opt(
+        False, "--skip-last", "-L", help="Skip saving model-last.bin"
+    ),
+    # fmt: on
+):
+    """
+    Pre-train the 'token-to-vector' (tok2vec) layer of pipeline components,
+    using an approximate language-modelling objective. Two objective types
+    are available, vector-based and character-based.
+
+    In the vector-based objective, we load word vectors that have been trained
+    using a word2vec-style distributional similarity algorithm, and train a
+    component like a CNN, BiLSTM, etc to predict vectors which match the
+    pretrained ones. The weights are saved to a directory after each epoch. You
+    can then pass a path to one of these pretrained weights files to the
+    'spacy train' command.
+
+    This technique may be especially helpful if you have little labelled data.
+    However, it's still quite experimental, so your mileage may vary.
+
+    To load the weights back in during 'spacy train', you need to ensure
+    all settings are the same between pretraining and training. Ideally,
+    this is done by using the same config file for both commands.
+
+    DOCS: https://spacy.io/api/cli#pretrain
+    """
+    config_overrides = parse_config_overrides(ctx.args)
+    import_code(code_path)
+    verify_cli_args(config_path, output_dir, resume_path, epoch_resume)
+    setup_gpu(use_gpu)
+    msg.info(f"Loading config from: {config_path}")
+
+    with show_validation_error(config_path):
+        raw_config = load_config(
+            config_path, overrides=config_overrides, interpolate=False
+        )
+    config = raw_config.interpolate()
+    if not config.get("pretraining"):
+        # TODO: What's the solution here? How do we handle optional blocks?
+        msg.fail("The [pretraining] block in your config is empty", exits=1)
+    if not output_dir.exists():
+        output_dir.mkdir(parents=True)
+        msg.good(f"Created output directory: {output_dir}")
+    # Save non-interpolated config
+    raw_config.to_disk(output_dir / "config.cfg")
+    msg.good("Saved config file in the output directory")
+
+    pretrain(
+        config,
+        output_dir,
+        resume_path=resume_path,
+        epoch_resume=epoch_resume,
+        use_gpu=use_gpu,
+        silent=False,
+        skip_last=skip_last,
+    )
+    msg.good("Successfully finished pretrain")
+
+
+def verify_cli_args(config_path, output_dir, resume_path, epoch_resume):
+    if not config_path or (str(config_path) != "-" and not config_path.exists()):
+        msg.fail("Config file not found", config_path, exits=1)
+    if output_dir.exists() and [p for p in output_dir.iterdir()]:
+        if resume_path:
+            msg.warn(
+                "Output directory is not empty.",
+                "If you're resuming a run in this directory, the old weights "
+                "for the consecutive epochs will be overwritten with the new ones.",
+            )
+        else:
+            msg.warn(
+                "Output directory is not empty. ",
+                "It is better to use an empty directory or refer to a new output path, "
+                "then the new directory will be created for you.",
+            )
+    if resume_path is not None:
+        if resume_path.is_dir():
+            # This is necessary because Windows gives a Permission Denied when we
+            # try to open the directory later, which is confusing. See #7878
+            msg.fail(
+                "--resume-path should be a weights file, but {resume_path} is a directory.",
+                exits=True,
+            )
+        model_name = re.search(r"model\d+\.bin", str(resume_path))
+        if not model_name and not epoch_resume:
+            msg.fail(
+                "You have to use the --epoch-resume setting when using a renamed weight file for --resume-path",
+                exits=True,
+            )
+        elif not model_name and epoch_resume < 0:
+            msg.fail(
+                f"The argument --epoch-resume has to be greater or equal to 0. {epoch_resume} is invalid",
+                exits=True,
+            )

spacy/cli/profile.py

@@ -0,0 +1,99 @@
+import cProfile
+import itertools
+import pstats
+import sys
+from pathlib import Path
+from typing import Iterator, Optional, Sequence, Union
+
+import srsly
+import tqdm
+import typer
+from wasabi import Printer, msg
+
+from ..language import Language
+from ..util import load_model
+from ._util import NAME, Arg, Opt, app, debug_cli
+
+
+@debug_cli.command("profile")
+@app.command("profile", hidden=True)
+def profile_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read current calling context
+    model: str = Arg(..., help="Trained pipeline to load"),
+    inputs: Optional[Path] = Arg(
+        None,
+        help="Location of input file. '-' for stdin.",
+        exists=True,
+        allow_dash=True,
+    ),
+    n_texts: int = Opt(
+        10000, "--n-texts", "-n", help="Maximum number of texts to use if available"
+    ),
+    # fmt: on
+):
+    """
+    Profile which functions take the most time in a spaCy pipeline.
+    Input should be formatted as one JSON object per line with a key "text".
+    It can either be provided as a JSONL file, or be read from sys.sytdin.
+    If no input file is specified, the IMDB dataset is loaded via Thinc.
+
+    DOCS: https://spacy.io/api/cli#debug-profile
+    """
+    if ctx.parent.command.name == NAME:  # type: ignore[union-attr]    # called as top-level command
+        msg.warn(
+            "The profile command is now available via the 'debug profile' "
+            "subcommand. You can run python -m spacy debug --help for an "
+            "overview of the other available debugging commands."
+        )
+    profile(model, inputs=inputs, n_texts=n_texts)
+
+
+def profile(model: str, inputs: Optional[Path] = None, n_texts: int = 10000) -> None:
+    if inputs is not None:
+        texts = _read_inputs(inputs, msg)
+        texts = list(itertools.islice(texts, n_texts))
+    if inputs is None:
+        try:
+            import ml_datasets
+        except ImportError:
+            msg.fail(
+                "This command, when run without an input file, "
+                "requires the ml_datasets library to be installed: "
+                "pip install ml_datasets",
+                exits=1,
+            )
+
+        with msg.loading("Loading IMDB dataset via ml_datasets..."):
+            imdb_train, _ = ml_datasets.imdb(train_limit=n_texts, dev_limit=0)
+            texts, _ = zip(*imdb_train)
+        msg.info(f"Loaded IMDB dataset and using {n_texts} examples")
+    with msg.loading(f"Loading pipeline '{model}'..."):
+        nlp = load_model(model)
+    msg.good(f"Loaded pipeline '{model}'")
+    cProfile.runctx("parse_texts(nlp, texts)", globals(), locals(), "Profile.prof")
+    s = pstats.Stats("Profile.prof")
+    msg.divider("Profile stats")
+    s.strip_dirs().sort_stats("time").print_stats()
+
+
+def parse_texts(nlp: Language, texts: Sequence[str]) -> None:
+    for doc in nlp.pipe(tqdm.tqdm(texts, disable=None), batch_size=16):
+        pass
+
+
+def _read_inputs(loc: Union[Path, str], msg: Printer) -> Iterator[str]:
+    if loc == "-":
+        msg.info("Reading input from sys.stdin")
+        file_ = sys.stdin
+        file_ = (line.encode("utf8") for line in file_)
+    else:
+        input_path = Path(loc)
+        if not input_path.exists() or not input_path.is_file():
+            msg.fail("Not a valid input data file", loc, exits=1)
+        msg.info(f"Using data from {input_path.parts[-1]}")
+        file_ = input_path.open()  # type: ignore[assignment]
+    for line in file_:
+        data = srsly.json_loads(line)
+        text = data["text"]
+        yield text

spacy/cli/project/assets.py

@@ -0,0 +1 @@
+from weasel.cli.assets import *

spacy/cli/project/clone.py

@@ -0,0 +1 @@
+from weasel.cli.clone import *

spacy/cli/project/document.py

@@ -0,0 +1 @@
+from weasel.cli.document import *

spacy/cli/project/dvc.py

@@ -0,0 +1 @@
+from weasel.cli.dvc import *

spacy/cli/project/pull.py

@@ -0,0 +1 @@
+from weasel.cli.pull import *

spacy/cli/project/push.py

@@ -0,0 +1 @@
+from weasel.cli.push import *

spacy/cli/project/remote_storage.py

@@ -0,0 +1 @@
+from weasel.cli.remote_storage import *

spacy/cli/project/run.py

@@ -0,0 +1 @@
+from weasel.cli.run import *

spacy/cli/templates/quickstart_training.jinja

@@ -0,0 +1,651 @@
+{# This is a template for training configs used for the quickstart widget in
+the docs and the init config command. It encodes various best practices and
+can help generate the best possible configuration, given a user's requirements. #}
+{%- set use_transformer = hardware != "cpu" and transformer_data -%}
+{%- set transformer = transformer_data[optimize] if use_transformer else {} -%}
+{%- set listener_components = ["tagger", "morphologizer", "parser", "ner", "textcat", "textcat_multilabel", "entity_linker", "span_finder", "spancat", "spancat_singlelabel", "trainable_lemmatizer"] -%}
+[paths]
+train = null
+dev = null
+{% if use_transformer or optimize == "efficiency" or not word_vectors -%}
+vectors = null
+{% else -%}
+vectors = "{{ word_vectors }}"
+{% endif -%}
+
+[system]
+{% if use_transformer -%}
+gpu_allocator = "pytorch"
+{% else -%}
+gpu_allocator = null
+{% endif %}
+
+[nlp]
+lang = "{{ lang }}"
+{%- set has_textcat = ("textcat" in components or "textcat_multilabel" in components) -%}
+{%- set with_accuracy = optimize == "accuracy" -%}
+{# The BOW textcat doesn't need a source of features, so it can omit the
+tok2vec/transformer. #}
+{%- set with_accuracy_or_transformer = (use_transformer or with_accuracy) -%}
+{%- set textcat_needs_features = has_textcat and with_accuracy_or_transformer -%}
+{%- if ("tagger" in components or "morphologizer" in components or "parser" in components or "ner" in components or "span_finder" in components or "spancat" in components or "spancat_singlelabel" in components or "trainable_lemmatizer" in components or "entity_linker" in components or textcat_needs_features) -%}
+{%- set full_pipeline = ["transformer" if use_transformer else "tok2vec"] + components -%}
+{%- else -%}
+{%- set full_pipeline = components -%}
+{%- endif %}
+pipeline = {{ full_pipeline|pprint()|replace("'", '"')|safe }}
+batch_size = {{ 128 if hardware == "gpu" else 1000 }}
+
+[components]
+
+{# TRANSFORMER PIPELINE #}
+{%- if use_transformer -%}
+[components.transformer]
+factory = "transformer"
+
+[components.transformer.model]
+@architectures = "spacy-transformers.TransformerModel.v3"
+name = "{{ transformer["name"] }}"
+tokenizer_config = {"use_fast": true}
+
+[components.transformer.model.get_spans]
+@span_getters = "spacy-transformers.strided_spans.v1"
+window = 128
+stride = 96
+
+{% if "morphologizer" in components %}
+[components.morphologizer]
+factory = "morphologizer"
+
+[components.morphologizer.model]
+@architectures = "spacy.Tagger.v2"
+nO = null
+
+[components.morphologizer.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.morphologizer.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{%- endif %}
+
+{% if "tagger" in components %}
+[components.tagger]
+factory = "tagger"
+
+[components.tagger.model]
+@architectures = "spacy.Tagger.v2"
+nO = null
+
+[components.tagger.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.tagger.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{%- endif %}
+
+{% if "parser" in components -%}
+[components.parser]
+factory = "parser"
+
+[components.parser.model]
+@architectures = "spacy.TransitionBasedParser.v2"
+state_type = "parser"
+extra_state_tokens = false
+hidden_width = 128
+maxout_pieces = 3
+use_upper = false
+nO = null
+
+[components.parser.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.parser.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{%- endif %}
+
+{% if "ner" in components -%}
+[components.ner]
+factory = "ner"
+
+[components.ner.model]
+@architectures = "spacy.TransitionBasedParser.v2"
+state_type = "ner"
+extra_state_tokens = false
+hidden_width = 64
+maxout_pieces = 2
+use_upper = false
+nO = null
+
+[components.ner.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.ner.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{% endif -%}
+
+{% if "span_finder" in components -%}
+[components.span_finder]
+factory = "span_finder"
+max_length = 25
+min_length = null
+scorer = {"@scorers":"spacy.span_finder_scorer.v1"}
+spans_key = "sc"
+threshold = 0.5
+
+[components.span_finder.model]
+@architectures = "spacy.SpanFinder.v1"
+
+[components.span_finder.model.scorer]
+@layers = "spacy.LinearLogistic.v1"
+nO = 2
+
+[components.span_finder.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.span_finder.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{% endif -%}
+
+{% if "spancat" in components -%}
+[components.spancat]
+factory = "spancat"
+max_positive = null
+scorer = {"@scorers":"spacy.spancat_scorer.v1"}
+spans_key = "sc"
+threshold = 0.5
+
+[components.spancat.model]
+@architectures = "spacy.SpanCategorizer.v1"
+
+[components.spancat.model.reducer]
+@layers = "spacy.mean_max_reducer.v1"
+hidden_size = 128
+
+[components.spancat.model.scorer]
+@layers = "spacy.LinearLogistic.v1"
+nO = null
+nI = null
+
+[components.spancat.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.spancat.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+
+[components.spancat.suggester]
+@misc = "spacy.ngram_suggester.v1"
+sizes = [1,2,3]
+{% endif -%}
+
+{% if "spancat_singlelabel" in components %}
+[components.spancat_singlelabel]
+factory = "spancat_singlelabel"
+negative_weight = 1.0
+allow_overlap = true
+scorer = {"@scorers":"spacy.spancat_scorer.v1"}
+spans_key = "sc"
+
+[components.spancat_singlelabel.model]
+@architectures = "spacy.SpanCategorizer.v1"
+
+[components.spancat_singlelabel.model.reducer]
+@layers = "spacy.mean_max_reducer.v1"
+hidden_size = 128
+
+[components.spancat_singlelabel.model.scorer]
+@layers = "Softmax.v2"
+
+[components.spancat_singlelabel.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.spancat_singlelabel.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+
+[components.spancat_singlelabel.suggester]
+@misc = "spacy.ngram_suggester.v1"
+sizes = [1,2,3]
+{% endif %}
+
+{% if "trainable_lemmatizer" in components -%}
+[components.trainable_lemmatizer]
+factory = "trainable_lemmatizer"
+backoff = "orth"
+min_tree_freq = 3
+overwrite = false
+scorer = {"@scorers":"spacy.lemmatizer_scorer.v1"}
+top_k = 1
+
+[components.trainable_lemmatizer.model]
+@architectures = "spacy.Tagger.v2"
+nO = null
+normalize = false
+
+[components.trainable_lemmatizer.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.trainable_lemmatizer.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{% endif -%}
+
+{% if "entity_linker" in components -%}
+[components.entity_linker]
+factory = "entity_linker"
+get_candidates = {"@misc":"spacy.CandidateGenerator.v1"}
+incl_context = true
+incl_prior = true
+
+[components.entity_linker.model]
+@architectures = "spacy.EntityLinker.v2"
+nO = null
+
+[components.entity_linker.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.entity_linker.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{% endif -%}
+
+{% if "textcat" in components %}
+[components.textcat]
+factory = "textcat"
+
+{% if optimize == "accuracy" %}
+[components.textcat.model]
+@architectures = "spacy.TextCatEnsemble.v2"
+nO = null
+
+[components.textcat.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.textcat.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+
+[components.textcat.model.linear_model]
+@architectures = "spacy.TextCatBOW.v3"
+exclusive_classes = true
+length = 262144
+ngram_size = 1
+no_output_layer = false
+
+{% else -%}
+[components.textcat.model]
+@architectures = "spacy.TextCatCNN.v2"
+exclusive_classes = true
+nO = null
+
+[components.textcat.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.textcat.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{%- endif %}
+{%- endif %}
+
+{% if "textcat_multilabel" in components %}
+[components.textcat_multilabel]
+factory = "textcat_multilabel"
+
+{% if optimize == "accuracy" %}
+[components.textcat_multilabel.model]
+@architectures = "spacy.TextCatEnsemble.v2"
+nO = null
+
+[components.textcat_multilabel.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.textcat_multilabel.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+
+[components.textcat_multilabel.model.linear_model]
+@architectures = "spacy.TextCatBOW.v3"
+exclusive_classes = false
+length = 262144
+ngram_size = 1
+no_output_layer = false
+
+{% else -%}
+[components.textcat_multilabel.model]
+@architectures = "spacy.TextCatCNN.v2"
+exclusive_classes = false
+nO = null
+
+[components.textcat_multilabel.model.tok2vec]
+@architectures = "spacy-transformers.TransformerListener.v1"
+grad_factor = 1.0
+
+[components.textcat_multilabel.model.tok2vec.pooling]
+@layers = "reduce_mean.v1"
+{%- endif %}
+{%- endif %}
+
+{# NON-TRANSFORMER PIPELINE #}
+{% else -%}
+{% if "tok2vec" in full_pipeline -%}
+[components.tok2vec]
+factory = "tok2vec"
+
+[components.tok2vec.model]
+@architectures = "spacy.Tok2Vec.v2"
+
+[components.tok2vec.model.embed]
+@architectures = "spacy.MultiHashEmbed.v2"
+width = ${components.tok2vec.model.encode.width}
+attrs = ["NORM", "PREFIX", "SUFFIX", "SHAPE"]
+rows = [5000, 1000, 2500, 2500]
+include_static_vectors = {{ "true" if optimize == "accuracy" else "false" }}
+
+[components.tok2vec.model.encode]
+@architectures = "spacy.MaxoutWindowEncoder.v2"
+width = {{ 96 if optimize == "efficiency" else 256 }}
+depth = {{ 4 if optimize == "efficiency" else 8 }}
+window_size = 1
+maxout_pieces = 3
+{% endif -%}
+
+{% if "morphologizer" in components %}
+[components.morphologizer]
+factory = "morphologizer"
+label_smoothing = 0.05
+
+[components.morphologizer.model]
+@architectures = "spacy.Tagger.v2"
+nO = null
+
+[components.morphologizer.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{%- endif %}
+
+{% if "tagger" in components %}
+[components.tagger]
+factory = "tagger"
+label_smoothing = 0.05
+
+[components.tagger.model]
+@architectures = "spacy.Tagger.v2"
+nO = null
+
+[components.tagger.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{%- endif %}
+
+{% if "parser" in components -%}
+[components.parser]
+factory = "parser"
+
+[components.parser.model]
+@architectures = "spacy.TransitionBasedParser.v2"
+state_type = "parser"
+extra_state_tokens = false
+hidden_width = 128
+maxout_pieces = 3
+use_upper = true
+nO = null
+
+[components.parser.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{%- endif %}
+
+{% if "ner" in components %}
+[components.ner]
+factory = "ner"
+
+[components.ner.model]
+@architectures = "spacy.TransitionBasedParser.v2"
+state_type = "ner"
+extra_state_tokens = false
+hidden_width = 64
+maxout_pieces = 2
+use_upper = true
+nO = null
+
+[components.ner.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{% endif %}
+
+{% if "span_finder" in components %}
+[components.span_finder]
+factory = "span_finder"
+max_length = 25
+min_length = null
+scorer = {"@scorers":"spacy.span_finder_scorer.v1"}
+spans_key = "sc"
+threshold = 0.5
+
+[components.span_finder.model]
+@architectures = "spacy.SpanFinder.v1"
+
+[components.span_finder.model.scorer]
+@layers = "spacy.LinearLogistic.v1"
+nO = 2
+
+[components.span_finder.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{% endif %}
+
+{% if "spancat" in components %}
+[components.spancat]
+factory = "spancat"
+max_positive = null
+scorer = {"@scorers":"spacy.spancat_scorer.v1"}
+spans_key = "sc"
+threshold = 0.5
+
+[components.spancat.model]
+@architectures = "spacy.SpanCategorizer.v1"
+
+[components.spancat.model.reducer]
+@layers = "spacy.mean_max_reducer.v1"
+hidden_size = 128
+
+[components.spancat.model.scorer]
+@layers = "spacy.LinearLogistic.v1"
+nO = null
+nI = null
+
+[components.spancat.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+
+[components.spancat.suggester]
+@misc = "spacy.ngram_suggester.v1"
+sizes = [1,2,3]
+{% endif %}
+
+{% if "spancat_singlelabel" in components %}
+[components.spancat_singlelabel]
+factory = "spancat_singlelabel"
+negative_weight = 1.0
+allow_overlap = true
+scorer = {"@scorers":"spacy.spancat_scorer.v1"}
+spans_key = "sc"
+
+[components.spancat_singlelabel.model]
+@architectures = "spacy.SpanCategorizer.v1"
+
+[components.spancat_singlelabel.model.reducer]
+@layers = "spacy.mean_max_reducer.v1"
+hidden_size = 128
+
+[components.spancat_singlelabel.model.scorer]
+@layers = "Softmax.v2"
+
+[components.spancat_singlelabel.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+
+[components.spancat_singlelabel.suggester]
+@misc = "spacy.ngram_suggester.v1"
+sizes = [1,2,3]
+{% endif %}
+
+{% if "trainable_lemmatizer" in components -%}
+[components.trainable_lemmatizer]
+factory = "trainable_lemmatizer"
+backoff = "orth"
+min_tree_freq = 3
+overwrite = false
+scorer = {"@scorers":"spacy.lemmatizer_scorer.v1"}
+top_k = 1
+
+[components.trainable_lemmatizer.model]
+@architectures = "spacy.Tagger.v2"
+nO = null
+normalize = false
+
+[components.trainable_lemmatizer.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{% endif -%}
+
+{% if "entity_linker" in components -%}
+[components.entity_linker]
+factory = "entity_linker"
+get_candidates = {"@misc":"spacy.CandidateGenerator.v1"}
+incl_context = true
+incl_prior = true
+
+[components.entity_linker.model]
+@architectures = "spacy.EntityLinker.v2"
+nO = null
+
+[components.entity_linker.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+{% endif %}
+
+{% if "textcat" in components %}
+[components.textcat]
+factory = "textcat"
+
+{% if optimize == "accuracy" %}
+[components.textcat.model]
+@architectures = "spacy.TextCatEnsemble.v2"
+nO = null
+
+[components.textcat.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+
+[components.textcat.model.linear_model]
+@architectures = "spacy.TextCatBOW.v3"
+exclusive_classes = true
+length = 262144
+ngram_size = 1
+no_output_layer = false
+
+{% else -%}
+[components.textcat.model]
+@architectures = "spacy.TextCatBOW.v3"
+exclusive_classes = true
+ngram_size = 1
+no_output_layer = false
+{%- endif %}
+{%- endif %}
+
+{% if "textcat_multilabel" in components %}
+[components.textcat_multilabel]
+factory = "textcat_multilabel"
+
+{% if optimize == "accuracy" %}
+[components.textcat_multilabel.model]
+@architectures = "spacy.TextCatEnsemble.v2"
+nO = null
+
+[components.textcat_multilabel.model.tok2vec]
+@architectures = "spacy.Tok2VecListener.v1"
+width = ${components.tok2vec.model.encode.width}
+
+[components.textcat_multilabel.model.linear_model]
+@architectures = "spacy.TextCatBOW.v3"
+exclusive_classes = false
+length = 262144
+ngram_size = 1
+no_output_layer = false
+
+{% else -%}
+[components.textcat_multilabel.model]
+@architectures = "spacy.TextCatBOW.v3"
+exclusive_classes = false
+length = 262144
+ngram_size = 1
+no_output_layer = false
+{%- endif %}
+{%- endif %}
+{% endif %}
+
+{% for pipe in components %}
+{% if pipe not in listener_components %}
+{# Other components defined by the user: we just assume they're factories #}
+[components.{{ pipe }}]
+factory = "{{ pipe }}"
+{% endif %}
+{% endfor %}
+
+[corpora]
+
+[corpora.train]
+@readers = "spacy.Corpus.v1"
+path = ${paths.train}
+max_length = 0
+
+[corpora.dev]
+@readers = "spacy.Corpus.v1"
+path = ${paths.dev}
+max_length = 0
+
+[training]
+{% if use_transformer -%}
+accumulate_gradient = {{ transformer["size_factor"] }}
+{% endif -%}
+dev_corpus = "corpora.dev"
+train_corpus = "corpora.train"
+
+[training.optimizer]
+@optimizers = "Adam.v1"
+
+{% if use_transformer -%}
+[training.optimizer.learn_rate]
+@schedules = "warmup_linear.v1"
+warmup_steps = 250
+total_steps = 20000
+initial_rate = 5e-5
+{% endif %}
+
+{% if use_transformer %}
+[training.batcher]
+@batchers = "spacy.batch_by_padded.v1"
+discard_oversize = true
+size = 2000
+buffer = 256
+{%- else %}
+[training.batcher]
+@batchers = "spacy.batch_by_words.v1"
+discard_oversize = false
+tolerance = 0.2
+
+[training.batcher.size]
+@schedules = "compounding.v1"
+start = 100
+stop = 1000
+compound = 1.001
+{% endif %}
+
+[initialize]
+vectors = ${paths.vectors}

spacy/cli/templates/quickstart_training_recommendations.yml

@@ -0,0 +1,282 @@
+# Recommended settings and available resources for each language, if available.
+# Not all languages have recommended word vectors or transformers and for some,
+# the recommended transformer for efficiency and accuracy may be the same.
+__default__:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: bert-base-multilingual-uncased
+      size_factor: 3
+    accuracy:
+      name: bert-base-multilingual-uncased
+      size_factor: 3
+ar:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: asafaya/bert-base-arabic
+      size_factor: 3
+    accuracy:
+      name: asafaya/bert-base-arabic
+      size_factor: 3
+bg:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: iarfmoose/roberta-base-bulgarian
+      size_factor: 3
+    accuracy:
+      name: iarfmoose/roberta-base-bulgarian
+      size_factor: 3
+bn:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: sagorsarker/bangla-bert-base
+      size_factor: 3
+    accuracy:
+      name: sagorsarker/bangla-bert-base
+      size_factor: 3
+ca:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: projecte-aina/roberta-base-ca-v2
+      size_factor: 3
+    accuracy:
+      name: projecte-aina/roberta-base-ca-v2
+      size_factor: 3
+da:
+  word_vectors: da_core_news_lg
+  transformer:
+    efficiency:
+      name: Maltehb/danish-bert-botxo
+      size_factor: 3
+    accuracy:
+      name: Maltehb/danish-bert-botxo
+      size_factor: 3
+de:
+  word_vectors: de_core_news_lg
+  transformer:
+    efficiency:
+      name: bert-base-german-cased
+      size_factor: 3
+    accuracy:
+      name: bert-base-german-cased
+      size_factor: 3
+el:
+  word_vectors: el_core_news_lg
+  transformer:
+    efficiency:
+      name: nlpaueb/bert-base-greek-uncased-v1
+      size_factor: 3
+    accuracy:
+      name: nlpaueb/bert-base-greek-uncased-v1
+      size_factor: 3
+en:
+  word_vectors: en_core_web_lg
+  transformer:
+    efficiency:
+      name: roberta-base
+      size_factor: 3
+    accuracy:
+      name: roberta-base
+      size_factor: 3
+es:
+  word_vectors: es_core_news_lg
+  transformer:
+    efficiency:
+      name: dccuchile/bert-base-spanish-wwm-cased
+      size_factor: 3
+    accuracy:
+      name: dccuchile/bert-base-spanish-wwm-cased
+      size_factor: 3
+eu:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: mrm8488/RoBasquERTa
+      size_factor: 3
+    accuracy:
+      name: mrm8488/RoBasquERTa
+      size_factor: 3
+fi:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: TurkuNLP/bert-base-finnish-cased-v1
+      size_factor: 3
+    accuracy:
+      name: TurkuNLP/bert-base-finnish-cased-v1
+      size_factor: 3
+fr:
+  word_vectors: fr_core_news_lg
+  transformer:
+    efficiency:
+      name: camembert-base
+      size_factor: 3
+    accuracy:
+      name: camembert-base
+      size_factor: 3
+hi:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: ai4bharat/indic-bert
+      size_factor: 3
+    accuracy:
+      name: ai4bharat/indic-bert
+      size_factor: 3
+id:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: indolem/indobert-base-uncased
+      size_factor: 3
+    accuracy:
+      name: indolem/indobert-base-uncased
+      size_factor: 3
+it:
+  word_vectors: it_core_news_lg
+  transformer: null
+ja:
+  word_vectors: ja_core_news_lg
+  transformer: null
+lt:
+  word_vectors: lt_core_news_lg
+  transformer: null
+mk:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: anon-submission-mk/bert-base-macedonian-cased
+      size_factor: 3
+    accuracy:
+      name: anon-submission-mk/bert-base-macedonian-cased
+      size_factor: 3
+nb:
+  word_vectors: nb_core_news_lg
+  transformer:
+    efficiency:
+      name: NbAiLab/nb-bert-base
+      size_factor: 3
+    accuracy:
+      name: NbAiLab/nb-bert-base
+      size_factor: 3
+nl:
+  word_vectors: nl_core_news_lg
+  transformer:
+    efficiency:
+      name: GroNLP/bert-base-dutch-cased
+      size_factor: 3
+    accuracy:
+      name: GroNLP/bert-base-dutch-cased
+      size_factor: 3
+pl:
+  word_vectors: pl_core_news_lg
+  transformer:
+    efficiency:
+      name: dkleczek/bert-base-polish-cased-v1
+      size_factor: 3
+    accuracy:
+      name: dkleczek/bert-base-polish-cased-v1
+      size_factor: 3
+pt:
+  word_vectors: pt_core_news_lg
+  transformer:
+    efficiency:
+      name: neuralmind/bert-base-portuguese-cased
+      size_factor: 3
+    accuracy:
+      name: neuralmind/bert-base-portuguese-cased
+      size_factor: 3
+ro:
+  word_vectors: ro_core_news_lg
+  transformer:
+    efficiency:
+      name: dumitrescustefan/bert-base-romanian-cased-v1
+      size_factor: 3
+    accuracy:
+      name: dumitrescustefan/bert-base-romanian-cased-v1
+      size_factor: 3
+si:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: setu4993/LaBSE
+      size_factor: 3
+    accuracy:
+      name: setu4993/LaBSE
+      size_factor: 3
+sv:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: KB/bert-base-swedish-cased
+      size_factor: 3
+    accuracy:
+      name: KB/bert-base-swedish-cased
+      size_factor: 3
+ta:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: ai4bharat/indic-bert
+      size_factor: 3
+    accuracy:
+      name: ai4bharat/indic-bert
+      size_factor: 3
+te:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: kuppuluri/telugu_bertu
+      size_factor: 3
+    accuracy:
+      name: kuppuluri/telugu_bertu
+      size_factor: 3
+th:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: monsoon-nlp/bert-base-thai
+      size_factor: 3
+    accuracy:
+      name: monsoon-nlp/bert-base-thai
+      size_factor: 3
+tr:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: dbmdz/bert-base-turkish-cased
+      size_factor: 3
+    accuracy:
+      name: dbmdz/bert-base-turkish-cased
+      size_factor: 3
+uk:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: youscan/ukr-roberta-base
+      size_factor: 3
+    accuracy:
+      name: youscan/ukr-roberta-base
+      size_factor: 3
+ur:
+  word_vectors: null
+  transformer:
+    efficiency:
+      name: urduhack/roberta-urdu-small
+      size_factor: 3
+    accuracy:
+      name: urduhack/roberta-urdu-small
+      size_factor: 3
+zh:
+  word_vectors: zh_core_web_lg
+  transformer:
+    efficiency:
+      name: bert-base-chinese
+      size_factor: 3
+    accuracy:
+      name: bert-base-chinese
+      size_factor: 3

spacy/cli/train.py

@@ -0,0 +1,103 @@
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+import typer
+from wasabi import msg
+
+from .. import util
+from ..training.initialize import init_nlp
+from ..training.loop import train as train_nlp
+from ._util import (
+    Arg,
+    Opt,
+    app,
+    import_code,
+    parse_config_overrides,
+    setup_gpu,
+    show_validation_error,
+)
+
+
+@app.command(
+    "train", context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)
+def train_cli(
+    # fmt: off
+    ctx: typer.Context,  # This is only used to read additional arguments
+    config_path: Path = Arg(
+        ..., help="Path to config file", exists=True, allow_dash=True
+    ),
+    output_path: Optional[Path] = Opt(
+        None,
+        "--output",
+        "--output-path",
+        "-o",
+        help="Output directory to store trained pipeline in",
+    ),
+    code_path: Optional[Path] = Opt(
+        None,
+        "--code",
+        "-c",
+        help="Path to Python file with additional code (registered functions) to be imported",
+    ),
+    verbose: bool = Opt(
+        False,
+        "--verbose",
+        "-V",
+        "-VV",
+        help="Display more information for debugging purposes",
+    ),
+    use_gpu: int = Opt(-1, "--gpu-id", "-g", help="GPU ID or -1 for CPU"),
+    # fmt: on
+):
+    """
+    Train or update a spaCy pipeline. Requires data in spaCy's binary format. To
+    convert data from other formats, use the `spacy convert` command. The
+    config file includes all settings and hyperparameters used during training.
+    To override settings in the config, e.g. settings that point to local
+    paths or that you want to experiment with, you can override them as
+    command line options. For instance, --training.batch_size 128 overrides
+    the value of "batch_size" in the block "[training]". The --code argument
+    lets you pass in a Python file that's imported before training. It can be
+    used to register custom functions and architectures that can then be
+    referenced in the config.
+
+    DOCS: https://spacy.io/api/cli#train
+    """
+    if verbose:
+        util.logger.setLevel(logging.DEBUG)
+    overrides = parse_config_overrides(ctx.args)
+    import_code(code_path)
+    train(config_path, output_path, use_gpu=use_gpu, overrides=overrides)
+
+
+def train(
+    config_path: Union[str, Path],
+    output_path: Optional[Union[str, Path]] = None,
+    *,
+    use_gpu: int = -1,
+    overrides: Dict[str, Any] = util.SimpleFrozenDict(),
+):
+    config_path = util.ensure_path(config_path)
+    output_path = util.ensure_path(output_path)
+    # Make sure all files and paths exists if they are needed
+    if not config_path or (str(config_path) != "-" and not config_path.exists()):
+        msg.fail("Config file not found", config_path, exits=1)
+    if not output_path:
+        msg.info("No output directory provided")
+    else:
+        if not output_path.exists():
+            output_path.mkdir(parents=True)
+            msg.good(f"Created output directory: {output_path}")
+        msg.info(f"Saving to output directory: {output_path}")
+    setup_gpu(use_gpu)
+    with show_validation_error(config_path):
+        config = util.load_config(config_path, overrides=overrides, interpolate=False)
+    msg.divider("Initializing pipeline")
+    with show_validation_error(config_path, hint_fill=False):
+        nlp = init_nlp(config, use_gpu=use_gpu)
+    msg.good("Initialized pipeline")
+    msg.divider("Training pipeline")
+    train_nlp(nlp, output_path, use_gpu=use_gpu, stdout=sys.stdout, stderr=sys.stderr)

spacy/cli/validate.py

@@ -0,0 +1,123 @@
+import sys
+import warnings
+from pathlib import Path
+from typing import Tuple
+
+import requests
+from wasabi import Printer, msg
+
+from .. import about
+from ..util import (
+    get_installed_models,
+    get_minor_version,
+    get_model_meta,
+    get_package_path,
+    get_package_version,
+    is_compatible_version,
+)
+from ._util import app
+
+
+@app.command("validate")
+def validate_cli():
+    """
+    Validate the currently installed pipeline packages and spaCy version. Checks
+    if the installed packages are compatible and shows upgrade instructions if
+    available. Should be run after `pip install -U spacy`.
+
+    DOCS: https://spacy.io/api/cli#validate
+    """
+    validate()
+
+
+def validate() -> None:
+    model_pkgs, compat = get_model_pkgs()
+    spacy_version = get_minor_version(about.__version__)
+    current_compat = compat.get(spacy_version, {})
+    if not current_compat:
+        msg.warn(f"No compatible packages found for v{spacy_version} of spaCy")
+    incompat_models = {d["name"] for _, d in model_pkgs.items() if not d["compat"]}
+    na_models = [m for m in incompat_models if m not in current_compat]
+    update_models = [m for m in incompat_models if m in current_compat]
+    spacy_dir = Path(__file__).parent.parent
+
+    msg.divider(f"Installed pipeline packages (spaCy v{about.__version__})")
+    msg.info(f"spaCy installation: {spacy_dir}")
+
+    if model_pkgs:
+        header = ("NAME", "SPACY", "VERSION", "")
+        rows = []
+        for name, data in model_pkgs.items():
+            if data["compat"]:
+                comp = msg.text("", color="green", icon="good", no_print=True)
+                version = msg.text(data["version"], color="green", no_print=True)
+            else:
+                version = msg.text(data["version"], color="yellow", no_print=True)
+                comp = f"--> {current_compat.get(data['name'], ['n/a'])[0]}"
+            rows.append((data["name"], data["spacy"], version, comp))
+        msg.table(rows, header=header)
+    else:
+        msg.text("No pipeline packages found in your current environment.", exits=0)
+    if update_models:
+        msg.divider("Install updates")
+        msg.text("Use the following commands to update the packages:")
+        cmd = "python -m spacy download {}"
+        print("\n".join([cmd.format(pkg) for pkg in update_models]) + "\n")
+    if na_models:
+        msg.info(
+            f"The following packages are custom spaCy pipelines or not "
+            f"available for spaCy v{about.__version__}:",
+            ", ".join(na_models),
+        )
+    if incompat_models:
+        sys.exit(1)
+
+
+def get_model_pkgs(silent: bool = False) -> Tuple[dict, dict]:
+    msg = Printer(no_print=silent, pretty=not silent)
+    with msg.loading("Loading compatibility table..."):
+        r = requests.get(about.__compatibility__)
+        if r.status_code != 200:
+            msg.fail(
+                f"Server error ({r.status_code})",
+                "Couldn't fetch compatibility table.",
+                exits=1,
+            )
+    msg.good("Loaded compatibility table")
+    compat = r.json()["spacy"]
+    all_models = set()
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message="\\[W09[45]")
+        installed_models = get_installed_models()
+    for spacy_v, models in dict(compat).items():
+        all_models.update(models.keys())
+        for model, model_vs in models.items():
+            compat[spacy_v][model] = [reformat_version(v) for v in model_vs]
+    pkgs = {}
+    for pkg_name in installed_models:
+        package = pkg_name.replace("-", "_")
+        version = get_package_version(pkg_name)
+        if package in compat:
+            is_compat = version in compat[package]
+            spacy_version = about.__version__
+        else:
+            model_path = get_package_path(package)
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", message="\\[W09[45]")
+                model_meta = get_model_meta(model_path)
+            spacy_version = model_meta.get("spacy_version", "n/a")
+            is_compat = is_compatible_version(about.__version__, spacy_version)  # type: ignore[assignment]
+        pkgs[pkg_name] = {
+            "name": package,
+            "version": version,
+            "spacy": spacy_version,
+            "compat": is_compat,
+        }
+    return pkgs, compat
+
+
+def reformat_version(version: str) -> str:
+    """Hack to reformat old versions ending on '-alpha' to match pip format."""
+    if version.endswith("-alpha"):
+        return version.replace("-alpha", "a0")
+    return version.replace("-alpha", "a")