Adding upstream version 3.8.0.upstream/3.8.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

93 files changed, 3994 insertions, 0 deletions

diff --git a/flit_core/LICENSE b/flit_core/LICENSE
new file mode 100644
index 0000000..1bd2e2d
--- /dev/null
+++ b/flit_core/LICENSE
@@ -0,0 +1,29 @@
+Copyright (c) 2015, Thomas Kluyver and contributors
+All rights reserved.
+
+BSD 3-clause license:
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/flit_core/README.rst b/flit_core/README.rst
new file mode 100644
index 0000000..6d9818f
--- /dev/null
+++ b/flit_core/README.rst
@@ -0,0 +1,6 @@
+flit_core
+---------
+
+This provides a PEP 517 build backend for packages using Flit.
+The only public interface is the API specified by PEP 517, at ``flit_core.buildapi``.
+
diff --git a/flit_core/bootstrap_install.py b/flit_core/bootstrap_install.py
new file mode 100644
index 0000000..1fd4c87
--- /dev/null
+++ b/flit_core/bootstrap_install.py
@@ -0,0 +1,57 @@
+"""Install flit_core without using any other tools.
+
+Normally, you would install flit_core with pip like any other Python package.
+This script is meant to help with 'bootstrapping' other packaging
+systems, where you may need flit_core to build other packaging tools.
+
+Use 'python -m flit_core.wheel' to make a wheel, then:
+
+    python bootstrap_install.py flit_core-3.6.0-py3-none-any.whl
+
+To install for something other than the Python running the script, pass a
+site-packages or equivalent directory with the --installdir option.
+"""
+import argparse
+import sys
+import sysconfig
+from pathlib import Path
+from zipfile import ZipFile
+
+def extract_wheel(whl_path, dest):
+    print("Installing to", dest)
+    with ZipFile(whl_path) as zf:
+        zf.extractall(dest)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        'wheel',
+        type=Path,
+        help=f'flit_core wheel to install (.whl file)',
+    )
+    purelib = Path(sysconfig.get_path('purelib')).resolve()
+    parser.add_argument(
+        '--installdir',
+        '-i',
+        type=Path,
+        default=purelib,
+        help=f'installdir directory (defaults to {purelib})',
+    )
+    parser.add_argument(
+        '--install-root',
+        type=Path,
+        default=None,
+        help='if given, installdir is considered to be under this'
+    )
+
+    args = parser.parse_args()
+
+    if not args.wheel.name.startswith('flit_core-'):
+        sys.exit("Use this script only for flit_core wheels")
+    if args.install_root:
+        installdir = args.install_root / args.installdir.relative_to("/")
+    else:
+        installdir = args.installdir
+
+    installdir.mkdir(parents=True, exist_ok=True)
+    extract_wheel(args.wheel, installdir)
diff --git a/flit_core/build_dists.py b/flit_core/build_dists.py
new file mode 100644
index 0000000..efbce59
--- /dev/null
+++ b/flit_core/build_dists.py
@@ -0,0 +1,17 @@
+"""Build flit_core to upload to PyPI.
+
+Normally, this should only be used by me when making a release.
+"""
+import os
+
+from flit_core import buildapi
+
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+
+print("Building sdist")
+sdist_fname = buildapi.build_sdist('dist/')
+print(os.path.join('dist', sdist_fname))
+
+print("\nBuilding wheel")
+whl_fname = buildapi.build_wheel('dist/')
+print(os.path.join('dist', whl_fname))
diff --git a/flit_core/flit_core/__init__.py b/flit_core/flit_core/__init__.py
new file mode 100644
index 0000000..d3125ef
--- /dev/null
+++ b/flit_core/flit_core/__init__.py
@@ -0,0 +1,7 @@
+"""Flit's core machinery for building packages.
+
+This package provides a standard PEP 517 API to build packages using Flit.
+All the convenient development features live in the main 'flit' package.
+"""
+
+__version__ = '3.8.0'
diff --git a/flit_core/flit_core/buildapi.py b/flit_core/flit_core/buildapi.py
new file mode 100644
index 0000000..963bf61
--- /dev/null
+++ b/flit_core/flit_core/buildapi.py
@@ -0,0 +1,83 @@
+"""PEP-517 compliant buildsystem API"""
+import logging
+import io
+import os
+import os.path as osp
+from pathlib import Path
+
+from .common import (
+    Module, make_metadata, write_entry_points, dist_info_name,
+    get_docstring_and_version_via_ast,
+)
+from .config import read_flit_config
+from .wheel import make_wheel_in, _write_wheel_file
+from .sdist import SdistBuilder
+
+log = logging.getLogger(__name__)
+
+# PEP 517 specifies that the CWD will always be the source tree
+pyproj_toml = Path('pyproject.toml')
+
+def get_requires_for_build_wheel(config_settings=None):
+    """Returns a list of requirements for building, as strings"""
+    info = read_flit_config(pyproj_toml)
+    # If we can get version & description from pyproject.toml (PEP 621), or
+    # by parsing the module (_via_ast), we don't need any extra
+    # dependencies. If not, we'll need to try importing it, so report any
+    # runtime dependencies as build dependencies.
+    want_summary = 'description' in info.dynamic_metadata
+    want_version = 'version' in info.dynamic_metadata
+
+    module = Module(info.module, Path.cwd())
+    docstring, version = get_docstring_and_version_via_ast(module)
+
+    if (want_summary and not docstring) or (want_version and not version):
+        return info.metadata.get('requires_dist', [])
+    else:
+        return []
+
+# Requirements to build an sdist are the same as for a wheel
+get_requires_for_build_sdist = get_requires_for_build_wheel
+
+# Requirements to build an editable are the same as for a wheel
+get_requires_for_build_editable = get_requires_for_build_wheel
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
+    """Creates {metadata_directory}/foo-1.2.dist-info"""
+    ini_info = read_flit_config(pyproj_toml)
+    module = Module(ini_info.module, Path.cwd())
+    metadata = make_metadata(module, ini_info)
+
+    dist_info = osp.join(metadata_directory,
+                         dist_info_name(metadata.name, metadata.version))
+    os.mkdir(dist_info)
+
+    with io.open(osp.join(dist_info, 'WHEEL'), 'w', encoding='utf-8') as f:
+        _write_wheel_file(f, supports_py2=metadata.supports_py2)
+
+    with io.open(osp.join(dist_info, 'METADATA'), 'w', encoding='utf-8') as f:
+        metadata.write_metadata_file(f)
+
+    if ini_info.entrypoints:
+        with io.open(osp.join(dist_info, 'entry_points.txt'), 'w', encoding='utf-8') as f:
+            write_entry_points(ini_info.entrypoints, f)
+
+    return osp.basename(dist_info)
+
+# Metadata for editable are the same as for a wheel
+prepare_metadata_for_build_editable = prepare_metadata_for_build_wheel
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    """Builds a wheel, places it in wheel_directory"""
+    info = make_wheel_in(pyproj_toml, Path(wheel_directory))
+    return info.file.name
+
+def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
+    """Builds an "editable" wheel, places it in wheel_directory"""
+    info = make_wheel_in(pyproj_toml, Path(wheel_directory), editable=True)
+    return info.file.name
+
+def build_sdist(sdist_directory, config_settings=None):
+    """Builds an sdist, places it in sdist_directory"""
+    path = SdistBuilder.from_ini_path(pyproj_toml).build(Path(sdist_directory))
+    return path.name
diff --git a/flit_core/flit_core/common.py b/flit_core/flit_core/common.py
new file mode 100644
index 0000000..68d91bb
--- /dev/null
+++ b/flit_core/flit_core/common.py
@@ -0,0 +1,449 @@
+import ast
+from contextlib import contextmanager
+import hashlib
+import logging
+import os
+import sys
+
+from pathlib import Path
+import re
+
+log = logging.getLogger(__name__)
+
+from .versionno import normalise_version
+
+class Module(object):
+    """This represents the module/package that we are going to distribute
+    """
+    in_namespace_package = False
+    namespace_package_name = None
+
+    def __init__(self, name, directory=Path()):
+        self.name = name
+
+        # It must exist either as a .py file or a directory, but not both
+        name_as_path = name.replace('.', os.sep)
+        pkg_dir = directory / name_as_path
+        py_file = directory / (name_as_path+'.py')
+        src_pkg_dir = directory / 'src' / name_as_path
+        src_py_file = directory / 'src' / (name_as_path+'.py')
+
+        existing = set()
+        if pkg_dir.is_dir():
+            self.path = pkg_dir
+            self.is_package = True
+            self.prefix = ''
+            existing.add(pkg_dir)
+        if py_file.is_file():
+            self.path = py_file
+            self.is_package = False
+            self.prefix = ''
+            existing.add(py_file)
+        if src_pkg_dir.is_dir():
+            self.path = src_pkg_dir
+            self.is_package = True
+            self.prefix = 'src'
+            existing.add(src_pkg_dir)
+        if src_py_file.is_file():
+            self.path = src_py_file
+            self.is_package = False
+            self.prefix = 'src'
+            existing.add(src_py_file)
+
+        if len(existing) > 1:
+            raise ValueError(
+                "Multiple files or folders could be module {}: {}"
+                .format(name, ", ".join([str(p) for p in sorted(existing)]))
+            )
+        elif not existing:
+            raise ValueError("No file/folder found for module {}".format(name))
+
+        self.source_dir = directory / self.prefix
+
+        if '.' in name:
+            self.namespace_package_name = name.rpartition('.')[0]
+            self.in_namespace_package = True
+
+    @property
+    def file(self):
+        if self.is_package:
+            return self.path / '__init__.py'
+        else:
+            return self.path
+
+    def iter_files(self):
+        """Iterate over the files contained in this module.
+
+        Yields absolute paths - caller may want to make them relative.
+        Excludes any __pycache__ and *.pyc files.
+        """
+        def _include(path):
+            name = os.path.basename(path)
+            if (name == '__pycache__') or name.endswith('.pyc'):
+                return False
+            return True
+
+        if self.is_package:
+            # Ensure we sort all files and directories so the order is stable
+            for dirpath, dirs, files in os.walk(str(self.path)):
+                for file in sorted(files):
+                    full_path = os.path.join(dirpath, file)
+                    if _include(full_path):
+                        yield full_path
+
+                dirs[:] = [d for d in sorted(dirs) if _include(d)]
+
+        else:
+            yield str(self.path)
+
+class ProblemInModule(ValueError): pass
+class NoDocstringError(ProblemInModule): pass
+class NoVersionError(ProblemInModule): pass
+class InvalidVersion(ProblemInModule): pass
+
+class VCSError(Exception):
+    def __init__(self, msg, directory):
+        self.msg = msg
+        self.directory = directory
+
+    def __str__(self):
+        return self.msg + ' ({})'.format(self.directory)
+
+
+@contextmanager
+def _module_load_ctx():
+    """Preserve some global state that modules might change at import time.
+
+    - Handlers on the root logger.
+    """
+    logging_handlers = logging.root.handlers[:]
+    try:
+        yield
+    finally:
+        logging.root.handlers = logging_handlers
+
+def get_docstring_and_version_via_ast(target):
+    """
+    Return a tuple like (docstring, version) for the given module,
+    extracted by parsing its AST.
+    """
+    # read as bytes to enable custom encodings
+    with target.file.open('rb') as f:
+        node = ast.parse(f.read())
+    for child in node.body:
+        # Only use the version from the given module if it's a simple
+        # string assignment to __version__
+        is_version_str = (
+                isinstance(child, ast.Assign)
+                and any(
+                    isinstance(target, ast.Name)
+                    and target.id == "__version__"
+                    for target in child.targets
+                )
+                and isinstance(child.value, ast.Str)
+        )
+        if is_version_str:
+            version = child.value.s
+            break
+    else:
+        version = None
+    return ast.get_docstring(node), version
+
+
+# To ensure we're actually loading the specified file, give it a unique name to
+# avoid any cached import. In normal use we'll only load one module per process,
+# so it should only matter for the tests, but we'll do it anyway.
+_import_i = 0
+
+
+def get_docstring_and_version_via_import(target):
+    """
+    Return a tuple like (docstring, version) for the given module,
+    extracted by importing the module and pulling __doc__ & __version__
+    from it.
+    """
+    global _import_i
+    _import_i += 1
+
+    log.debug("Loading module %s", target.file)
+    from importlib.util import spec_from_file_location, module_from_spec
+    mod_name = 'flit_core.dummy.import%d' % _import_i
+    spec = spec_from_file_location(mod_name, target.file)
+    with _module_load_ctx():
+        m = module_from_spec(spec)
+        # Add the module to sys.modules to allow relative imports to work.
+        # importlib has more code around this to handle the case where two
+        # threads are trying to load the same module at the same time, but Flit
+        # should always be running a single thread, so we won't duplicate that.
+        sys.modules[mod_name] = m
+        try:
+            spec.loader.exec_module(m)
+        finally:
+            sys.modules.pop(mod_name, None)
+
+    docstring = m.__dict__.get('__doc__', None)
+    version = m.__dict__.get('__version__', None)
+    return docstring, version
+
+
+def get_info_from_module(target, for_fields=('version', 'description')):
+    """Load the module/package, get its docstring and __version__
+    """
+    if not for_fields:
+        return {}
+
+    # What core metadata calls Summary, PEP 621 calls description
+    want_summary = 'description' in for_fields
+    want_version = 'version' in for_fields
+
+    log.debug("Loading module %s", target.file)
+
+    # Attempt to extract our docstring & version by parsing our target's
+    # AST, falling back to an import if that fails. This allows us to
+    # build without necessarily requiring that our built package's
+    # requirements are installed.
+    docstring, version = get_docstring_and_version_via_ast(target)
+    if (want_summary and not docstring) or (want_version and not version):
+        docstring, version = get_docstring_and_version_via_import(target)
+
+    res = {}
+
+    if want_summary:
+        if (not docstring) or not docstring.strip():
+            raise NoDocstringError(
+                'Flit cannot package module without docstring, or empty docstring. '
+                'Please add a docstring to your module ({}).'.format(target.file)
+            )
+        res['summary'] = docstring.lstrip().splitlines()[0]
+
+    if want_version:
+        res['version'] = check_version(version)
+
+    return res
+
+def check_version(version):
+    """
+    Check whether a given version string match PEP 440, and do normalisation.
+
+    Raise InvalidVersion/NoVersionError with relevant information if
+    version is invalid.
+
+    Log a warning if the version is not canonical with respect to PEP 440.
+
+    Returns the version in canonical PEP 440 format.
+    """
+    if not version:
+        raise NoVersionError('Cannot package module without a version string. '
+                             'Please define a `__version__ = "x.y.z"` in your module.')
+    if not isinstance(version, str):
+        raise InvalidVersion('__version__ must be a string, not {}.'
+                                .format(type(version)))
+
+    # Import here to avoid circular import
+    version = normalise_version(version)
+
+    return version
+
+
+script_template = """\
+#!{interpreter}
+# -*- coding: utf-8 -*-
+import re
+import sys
+from {module} import {import_name}
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\\.pyw|\\.exe)?$', '', sys.argv[0])
+    sys.exit({func}())
+"""
+
+def parse_entry_point(ep):
+    """Check and parse a 'package.module:func' style entry point specification.
+
+    Returns (modulename, funcname)
+    """
+    if ':' not in ep:
+        raise ValueError("Invalid entry point (no ':'): %r" % ep)
+    mod, func = ep.split(':')
+
+    for piece in func.split('.'):
+        if not piece.isidentifier():
+            raise ValueError("Invalid entry point: %r is not an identifier" % piece)
+    for piece in mod.split('.'):
+        if not piece.isidentifier():
+            raise ValueError("Invalid entry point: %r is not a module path" % piece)
+
+    return mod, func
+
+def write_entry_points(d, fp):
+    """Write entry_points.txt from a two-level dict
+
+    Sorts on keys to ensure results are reproducible.
+    """
+    for group_name in sorted(d):
+        fp.write(u'[{}]\n'.format(group_name))
+        group = d[group_name]
+        for name in sorted(group):
+            val = group[name]
+            fp.write(u'{}={}\n'.format(name, val))
+        fp.write(u'\n')
+
+def hash_file(path, algorithm='sha256'):
+    with open(path, 'rb') as f:
+        h = hashlib.new(algorithm, f.read())
+    return h.hexdigest()
+
+def normalize_file_permissions(st_mode):
+    """Normalize the permission bits in the st_mode field from stat to 644/755
+
+    Popular VCSs only track whether a file is executable or not. The exact
+    permissions can vary on systems with different umasks. Normalising
+    to 644 (non executable) or 755 (executable) makes builds more reproducible.
+    """
+    # Set 644 permissions, leaving higher bits of st_mode unchanged
+    new_mode = (st_mode | 0o644) & ~0o133
+    if st_mode & 0o100:
+        new_mode |= 0o111  # Executable: 644 -> 755
+    return new_mode
+
+class Metadata(object):
+
+    summary = None
+    home_page = None
+    author = None
+    author_email = None
+    maintainer = None
+    maintainer_email = None
+    license = None
+    description = None
+    keywords = None
+    download_url = None
+    requires_python = None
+    description_content_type = None
+
+    platform = ()
+    supported_platform = ()
+    classifiers = ()
+    provides = ()
+    requires = ()
+    obsoletes = ()
+    project_urls = ()
+    provides_dist = ()
+    requires_dist = ()
+    obsoletes_dist = ()
+    requires_external = ()
+    provides_extra = ()
+
+    metadata_version = "2.1"
+
+    def __init__(self, data):
+        data = data.copy()
+        self.name = data.pop('name')
+        self.version = data.pop('version')
+
+        for k, v in data.items():
+            assert hasattr(self, k), "data does not have attribute '{}'".format(k)
+            setattr(self, k, v)
+
+    def _normalise_name(self, n):
+        return n.lower().replace('-', '_')
+
+    def write_metadata_file(self, fp):
+        """Write out metadata in the email headers format"""
+        fields = [
+            'Metadata-Version',
+            'Name',
+            'Version',
+        ]
+        optional_fields = [
+            'Summary',
+            'Home-page',
+            'License',
+            'Keywords',
+            'Author',
+            'Author-email',
+            'Maintainer',
+            'Maintainer-email',
+            'Requires-Python',
+            'Description-Content-Type',
+        ]
+
+        for field in fields:
+            value = getattr(self, self._normalise_name(field))
+            fp.write(u"{}: {}\n".format(field, value))
+
+        for field in optional_fields:
+            value = getattr(self, self._normalise_name(field))
+            if value is not None:
+                # TODO: verify which fields can be multiline
+                # The spec has multiline examples for Author, Maintainer &
+                # License (& Description, but we put that in the body)
+                # Indent following lines with 8 spaces:
+                value = '\n        '.join(value.splitlines())
+                fp.write(u"{}: {}\n".format(field, value))
+
+        for clsfr in self.classifiers:
+            fp.write(u'Classifier: {}\n'.format(clsfr))
+
+        for req in self.requires_dist:
+            fp.write(u'Requires-Dist: {}\n'.format(req))
+
+        for url in self.project_urls:
+            fp.write(u'Project-URL: {}\n'.format(url))
+
+        for extra in self.provides_extra:
+            fp.write(u'Provides-Extra: {}\n'.format(extra))
+
+        if self.description is not None:
+            fp.write(u'\n' + self.description + u'\n')
+
+    @property
+    def supports_py2(self):
+        """Return True if Requires-Python indicates Python 2 support."""
+        for part in (self.requires_python or "").split(","):
+            if re.search(r"^\s*(>=?|~=|===?)?\s*[3-9]", part):
+                return False
+        return True
+
+
+def make_metadata(module, ini_info):
+    md_dict = {'name': module.name, 'provides': [module.name]}
+    md_dict.update(get_info_from_module(module, ini_info.dynamic_metadata))
+    md_dict.update(ini_info.metadata)
+    return Metadata(md_dict)
+
+
+
+def normalize_dist_name(name: str, version: str) -> str:
+    """Normalizes a name and a PEP 440 version
+
+    The resulting string is valid as dist-info folder name
+    and as first part of a wheel filename
+
+    See https://packaging.python.org/specifications/binary-distribution-format/#escaping-and-unicode
+    """
+    normalized_name = re.sub(r'[-_.]+', '_', name, flags=re.UNICODE).lower()
+    assert check_version(version) == version
+    assert '-' not in version, 'Normalized versions can’t have dashes'
+    return '{}-{}'.format(normalized_name, version)
+
+
+def dist_info_name(distribution, version):
+    """Get the correct name of the .dist-info folder"""
+    return normalize_dist_name(distribution, version) + '.dist-info'
+
+
+def walk_data_dir(data_directory):
+    """Iterate over the files in the given data directory.
+
+    Yields paths prefixed with data_directory - caller may want to make them
+    relative to that. Excludes any __pycache__ subdirectories.
+    """
+    if data_directory is None:
+        return
+
+    for dirpath, dirs, files in os.walk(data_directory):
+        for file in sorted(files):
+            full_path = os.path.join(dirpath, file)
+            yield full_path
+
+        dirs[:] = [d for d in sorted(dirs) if d != '__pycache__']
diff --git a/flit_core/flit_core/config.py b/flit_core/flit_core/config.py
new file mode 100644
index 0000000..1292956
--- /dev/null
+++ b/flit_core/flit_core/config.py
@@ -0,0 +1,660 @@
+import difflib
+from email.headerregistry import Address
+import errno
+import logging
+import os
+import os.path as osp
+from pathlib import Path
+import re
+
+try:
+    import tomllib
+except ImportError:
+    try:
+        from .vendor import tomli as tomllib
+    # Some downstream distributors remove the vendored tomli.
+    # When that is removed, import tomli from the regular location.
+    except ImportError:
+        import tomli as tomllib
+
+from .versionno import normalise_version
+
+log = logging.getLogger(__name__)
+
+
+class ConfigError(ValueError):
+    pass
+
+metadata_list_fields = {
+    'classifiers',
+    'requires',
+    'dev-requires'
+}
+
+metadata_allowed_fields = {
+    'module',
+    'author',
+    'author-email',
+    'maintainer',
+    'maintainer-email',
+    'home-page',
+    'license',
+    'keywords',
+    'requires-python',
+    'dist-name',
+    'description-file',
+    'requires-extra',
+} | metadata_list_fields
+
+metadata_required_fields = {
+    'module',
+    'author',
+}
+
+pep621_allowed_fields = {
+    'name',
+    'version',
+    'description',
+    'readme',
+    'requires-python',
+    'license',
+    'authors',
+    'maintainers',
+    'keywords',
+    'classifiers',
+    'urls',
+    'scripts',
+    'gui-scripts',
+    'entry-points',
+    'dependencies',
+    'optional-dependencies',
+    'dynamic',
+}
+
+
+def read_flit_config(path):
+    """Read and check the `pyproject.toml` file with data about the package.
+    """
+    d = tomllib.loads(path.read_text('utf-8'))
+    return prep_toml_config(d, path)
+
+
+class EntryPointsConflict(ConfigError):
+    def __str__(self):
+        return ('Please specify console_scripts entry points, or [scripts] in '
+            'flit config, not both.')
+
+def prep_toml_config(d, path):
+    """Validate config loaded from pyproject.toml and prepare common metadata
+    
+    Returns a LoadedConfig object.
+    """
+    dtool = d.get('tool', {}).get('flit', {})
+
+    if 'project' in d:
+        # Metadata in [project] table (PEP 621)
+        if 'metadata' in dtool:
+            raise ConfigError(
+                "Use [project] table for metadata or [tool.flit.metadata], not both."
+            )
+        if ('scripts' in dtool) or ('entrypoints' in dtool):
+            raise ConfigError(
+                "Don't mix [project] metadata with [tool.flit.scripts] or "
+                "[tool.flit.entrypoints]. Use [project.scripts],"
+                "[project.gui-scripts] or [project.entry-points] as replacements."
+            )
+        loaded_cfg = read_pep621_metadata(d['project'], path)
+
+        module_tbl = dtool.get('module', {})
+        if 'name' in module_tbl:
+            loaded_cfg.module = module_tbl['name']
+    elif 'metadata' in dtool:
+        # Metadata in [tool.flit.metadata] (pre PEP 621 format)
+        if 'module' in dtool:
+            raise ConfigError(
+                "Use [tool.flit.module] table with new-style [project] metadata, "
+                "not [tool.flit.metadata]"
+            )
+        loaded_cfg = _prep_metadata(dtool['metadata'], path)
+        loaded_cfg.dynamic_metadata = ['version', 'description']
+
+        if 'entrypoints' in dtool:
+            loaded_cfg.entrypoints = flatten_entrypoints(dtool['entrypoints'])
+
+        if 'scripts' in dtool:
+            loaded_cfg.add_scripts(dict(dtool['scripts']))
+    else:
+        raise ConfigError(
+            "Neither [project] nor [tool.flit.metadata] found in pyproject.toml"
+        )
+
+    unknown_sections = set(dtool) - {
+        'metadata', 'module', 'scripts', 'entrypoints', 'sdist', 'external-data'
+    }
+    unknown_sections = [s for s in unknown_sections if not s.lower().startswith('x-')]
+    if unknown_sections:
+        raise ConfigError('Unexpected tables in pyproject.toml: ' + ', '.join(
+            '[tool.flit.{}]'.format(s) for s in unknown_sections
+        ))
+
+    if 'sdist' in dtool:
+        unknown_keys = set(dtool['sdist']) - {'include', 'exclude'}
+        if unknown_keys:
+            raise ConfigError(
+                "Unknown keys in [tool.flit.sdist]:" + ", ".join(unknown_keys)
+            )
+
+        loaded_cfg.sdist_include_patterns = _check_glob_patterns(
+            dtool['sdist'].get('include', []), 'include'
+        )
+        exclude = [
+            "**/__pycache__",
+            "**.pyc",
+        ] + dtool['sdist'].get('exclude', [])
+        loaded_cfg.sdist_exclude_patterns = _check_glob_patterns(
+            exclude, 'exclude'
+        )
+
+    data_dir = dtool.get('external-data', {}).get('directory', None)
+    if data_dir is not None:
+        toml_key = "tool.flit.external-data.directory"
+        if not isinstance(data_dir, str):
+            raise ConfigError(f"{toml_key} must be a string")
+
+        normp = osp.normpath(data_dir)
+        if osp.isabs(normp):
+            raise ConfigError(f"{toml_key} cannot be an absolute path")
+        if normp.startswith('..' + os.sep):
+            raise ConfigError(
+                f"{toml_key} cannot point outside the directory containing pyproject.toml"
+            )
+        if normp == '.':
+            raise ConfigError(
+                f"{toml_key} cannot refer to the directory containing pyproject.toml"
+            )
+        loaded_cfg.data_directory = path.parent / data_dir
+        if not loaded_cfg.data_directory.is_dir():
+            raise ConfigError(f"{toml_key} must refer to a directory")
+
+    return loaded_cfg
+
+def flatten_entrypoints(ep):
+    """Flatten nested entrypoints dicts.
+
+    Entry points group names can include dots. But dots in TOML make nested
+    dictionaries:
+
+    [entrypoints.a.b]    # {'entrypoints': {'a': {'b': {}}}}
+
+    The proper way to avoid this is:
+
+    [entrypoints."a.b"]  # {'entrypoints': {'a.b': {}}}
+
+    But since there isn't a need for arbitrarily nested mappings in entrypoints,
+    flit allows you to use the former. This flattens the nested dictionaries
+    from loading pyproject.toml.
+    """
+    def _flatten(d, prefix):
+        d1 = {}
+        for k, v in d.items():
+            if isinstance(v, dict):
+                for flattened in _flatten(v, prefix+'.'+k):
+                    yield flattened
+            else:
+                d1[k] = v
+
+        if d1:
+            yield prefix, d1
+
+    res = {}
+    for k, v in ep.items():
+        res.update(_flatten(v, k))
+    return res
+
+
+def _check_glob_patterns(pats, clude):
+    """Check and normalise glob patterns for sdist include/exclude"""
+    if not isinstance(pats, list):
+        raise ConfigError("sdist {} patterns must be a list".format(clude))
+
+    # Windows filenames can't contain these (nor * or ?, but they are part of
+    # glob patterns) - https://stackoverflow.com/a/31976060/434217
+    bad_chars = re.compile(r'[\000-\037<>:"\\]')
+
+    normed = []
+
+    for p in pats:
+        if bad_chars.search(p):
+            raise ConfigError(
+                '{} pattern {!r} contains bad characters (<>:\"\\ or control characters)'
+                .format(clude, p)
+            )
+
+        normp = osp.normpath(p)
+
+        if osp.isabs(normp):
+            raise ConfigError(
+                '{} pattern {!r} is an absolute path'.format(clude, p)
+            )
+        if normp.startswith('..' + os.sep):
+            raise ConfigError(
+                '{} pattern {!r} points out of the directory containing pyproject.toml'
+                .format(clude, p)
+            )
+        normed.append(normp)
+
+    return normed
+
+
+class LoadedConfig(object):
+    def __init__(self):
+        self.module = None
+        self.metadata = {}
+        self.reqs_by_extra = {}
+        self.entrypoints = {}
+        self.referenced_files = []
+        self.sdist_include_patterns = []
+        self.sdist_exclude_patterns = []
+        self.dynamic_metadata = []
+        self.data_directory = None
+
+    def add_scripts(self, scripts_dict):
+        if scripts_dict:
+            if 'console_scripts' in self.entrypoints:
+                raise EntryPointsConflict
+            else:
+                self.entrypoints['console_scripts'] = scripts_dict
+
+readme_ext_to_content_type = {
+    '.rst': 'text/x-rst',
+    '.md': 'text/markdown',
+    '.txt': 'text/plain',
+}
+
+
+def description_from_file(rel_path: str, proj_dir: Path, guess_mimetype=True):
+    if osp.isabs(rel_path):
+        raise ConfigError("Readme path must be relative")
+
+    desc_path = proj_dir / rel_path
+    try:
+        with desc_path.open('r', encoding='utf-8') as f:
+            raw_desc = f.read()
+    except IOError as e:
+        if e.errno == errno.ENOENT:
+            raise ConfigError(
+                "Description file {} does not exist".format(desc_path)
+            )
+        raise
+
+    if guess_mimetype:
+        ext = desc_path.suffix.lower()
+        try:
+            mimetype = readme_ext_to_content_type[ext]
+        except KeyError:
+            log.warning("Unknown extension %r for description file.", ext)
+            log.warning("  Recognised extensions: %s",
+                        " ".join(readme_ext_to_content_type))
+            mimetype = None
+    else:
+        mimetype = None
+
+    return raw_desc, mimetype
+
+
+def _prep_metadata(md_sect, path):
+    """Process & verify the metadata from a config file
+    
+    - Pull out the module name we're packaging.
+    - Read description-file and check that it's valid rst
+    - Convert dashes in key names to underscores
+      (e.g. home-page in config -> home_page in metadata) 
+    """
+    if not set(md_sect).issuperset(metadata_required_fields):
+        missing = metadata_required_fields - set(md_sect)
+        raise ConfigError("Required fields missing: " + '\n'.join(missing))
+
+    res = LoadedConfig()
+
+    res.module = md_sect.get('module')
+    if not all([m.isidentifier() for m in res.module.split(".")]):
+        raise ConfigError("Module name %r is not a valid identifier" % res.module)
+
+    md_dict = res.metadata
+
+    # Description file
+    if 'description-file' in md_sect:
+        desc_path = md_sect.get('description-file')
+        res.referenced_files.append(desc_path)
+        desc_content, mimetype = description_from_file(desc_path, path.parent)
+        md_dict['description'] =  desc_content
+        md_dict['description_content_type'] = mimetype
+
+    if 'urls' in md_sect:
+        project_urls = md_dict['project_urls'] = []
+        for label, url in sorted(md_sect.pop('urls').items()):
+            project_urls.append("{}, {}".format(label, url))
+
+    for key, value in md_sect.items():
+        if key in {'description-file', 'module'}:
+            continue
+        if key not in metadata_allowed_fields:
+            closest = difflib.get_close_matches(key, metadata_allowed_fields,
+                                                n=1, cutoff=0.7)
+            msg = "Unrecognised metadata key: {!r}".format(key)
+            if closest:
+                msg += " (did you mean {!r}?)".format(closest[0])
+            raise ConfigError(msg)
+
+        k2 = key.replace('-', '_')
+        md_dict[k2] = value
+        if key in metadata_list_fields:
+            if not isinstance(value, list):
+                raise ConfigError('Expected a list for {} field, found {!r}'
+                                    .format(key, value))
+            if not all(isinstance(a, str) for a in value):
+                raise ConfigError('Expected a list of strings for {} field'
+                                    .format(key))
+        elif key == 'requires-extra':
+            if not isinstance(value, dict):
+                raise ConfigError('Expected a dict for requires-extra field, found {!r}'
+                                    .format(value))
+            if not all(isinstance(e, list) for e in value.values()):
+                raise ConfigError('Expected a dict of lists for requires-extra field')
+            for e, reqs in value.items():
+                if not all(isinstance(a, str) for a in reqs):
+                    raise ConfigError('Expected a string list for requires-extra. (extra {})'
+                                        .format(e))
+        else:
+            if not isinstance(value, str):
+                raise ConfigError('Expected a string for {} field, found {!r}'
+                                    .format(key, value))
+
+    # What we call requires in the ini file is technically requires_dist in
+    # the metadata.
+    if 'requires' in md_dict:
+        md_dict['requires_dist'] = md_dict.pop('requires')
+
+    # And what we call dist-name is name in the metadata
+    if 'dist_name' in md_dict:
+        md_dict['name'] = md_dict.pop('dist_name')
+
+    # Move dev-requires into requires-extra
+    reqs_noextra = md_dict.pop('requires_dist', [])
+    res.reqs_by_extra = md_dict.pop('requires_extra', {})
+    dev_requires = md_dict.pop('dev_requires', None)
+    if dev_requires is not None:
+        if 'dev' in res.reqs_by_extra:
+            raise ConfigError(
+                'dev-requires occurs together with its replacement requires-extra.dev.')
+        else:
+            log.warning(
+                '"dev-requires = ..." is obsolete. Use "requires-extra = {"dev" = ...}" instead.')
+            res.reqs_by_extra['dev'] = dev_requires
+
+    # Add requires-extra requirements into requires_dist
+    md_dict['requires_dist'] = \
+        reqs_noextra + list(_expand_requires_extra(res.reqs_by_extra))
+
+    md_dict['provides_extra'] = sorted(res.reqs_by_extra.keys())
+
+    # For internal use, record the main requirements as a '.none' extra.
+    res.reqs_by_extra['.none'] = reqs_noextra
+
+    return res
+
+def _expand_requires_extra(re):
+    for extra, reqs in sorted(re.items()):
+        for req in reqs:
+            if ';' in req:
+                name, envmark = req.split(';', 1)
+                yield '{} ; extra == "{}" and ({})'.format(name, extra, envmark)
+            else:
+                yield '{} ; extra == "{}"'.format(req, extra)
+
+
+def _check_type(d, field_name, cls):
+    if not isinstance(d[field_name], cls):
+        raise ConfigError(
+            "{} field should be {}, not {}".format(field_name, cls, type(d[field_name]))
+        )
+
+def _check_list_of_str(d, field_name):
+    if not isinstance(d[field_name], list) or not all(
+        isinstance(e, str) for e in d[field_name]
+    ):
+        raise ConfigError(
+            "{} field should be a list of strings".format(field_name)
+        )
+
+def read_pep621_metadata(proj, path) -> LoadedConfig:
+    lc = LoadedConfig()
+    md_dict = lc.metadata
+
+    if 'name' not in proj:
+        raise ConfigError('name must be specified in [project] table')
+    _check_type(proj, 'name', str)
+    md_dict['name'] = proj['name']
+    lc.module = md_dict['name'].replace('-', '_')
+
+    unexpected_keys = proj.keys() - pep621_allowed_fields
+    if unexpected_keys:
+        log.warning("Unexpected names under [project]: %s", ', '.join(unexpected_keys))
+
+    if 'version' in proj:
+        _check_type(proj, 'version', str)
+        md_dict['version'] = normalise_version(proj['version'])
+    if 'description' in proj:
+        _check_type(proj, 'description', str)
+        md_dict['summary'] = proj['description']
+    if 'readme' in proj:
+        readme = proj['readme']
+        if isinstance(readme, str):
+            lc.referenced_files.append(readme)
+            desc_content, mimetype = description_from_file(readme, path.parent)
+
+        elif isinstance(readme, dict):
+            unrec_keys = set(readme.keys()) - {'text', 'file', 'content-type'}
+            if unrec_keys:
+                raise ConfigError(
+                    "Unrecognised keys in [project.readme]: {}".format(unrec_keys)
+                )
+            if 'content-type' in readme:
+                mimetype = readme['content-type']
+                mtype_base = mimetype.split(';')[0].strip()  # e.g. text/x-rst
+                if mtype_base not in readme_ext_to_content_type.values():
+                    raise ConfigError(
+                        "Unrecognised readme content-type: {!r}".format(mtype_base)
+                    )
+                # TODO: validate content-type parameters (charset, md variant)?
+            else:
+                raise ConfigError(
+                    "content-type field required in [project.readme] table"
+                )
+            if 'file' in readme:
+                if 'text' in readme:
+                    raise ConfigError(
+                        "[project.readme] should specify file or text, not both"
+                    )
+                lc.referenced_files.append(readme['file'])
+                desc_content, _ = description_from_file(
+                    readme['file'], path.parent, guess_mimetype=False
+                )
+            elif 'text' in readme:
+                desc_content = readme['text']
+            else:
+                raise ConfigError(
+                    "file or text field required in [project.readme] table"
+                )
+        else:
+            raise ConfigError(
+                "project.readme should be a string or a table"
+            )
+
+        md_dict['description'] = desc_content
+        md_dict['description_content_type'] = mimetype
+
+    if 'requires-python' in proj:
+        md_dict['requires_python'] = proj['requires-python']
+
+    if 'license' in proj:
+        _check_type(proj, 'license', dict)
+        license_tbl = proj['license']
+        unrec_keys = set(license_tbl.keys()) - {'text', 'file'}
+        if unrec_keys:
+            raise ConfigError(
+                "Unrecognised keys in [project.license]: {}".format(unrec_keys)
+            )
+
+        # TODO: Do something with license info.
+        # The 'License' field in packaging metadata is a brief description of
+        # a license, not the full text or a file path. PEP 639 will improve on
+        # how licenses are recorded.
+        if 'file' in license_tbl:
+            if 'text' in license_tbl:
+                raise ConfigError(
+                    "[project.license] should specify file or text, not both"
+                )
+            lc.referenced_files.append(license_tbl['file'])
+        elif 'text' in license_tbl:
+            pass
+        else:
+            raise ConfigError(
+                "file or text field required in [project.license] table"
+            )
+
+    if 'authors' in proj:
+        _check_type(proj, 'authors', list)
+        md_dict.update(pep621_people(proj['authors']))
+
+    if 'maintainers' in proj:
+        _check_type(proj, 'maintainers', list)
+        md_dict.update(pep621_people(proj['maintainers'], group_name='maintainer'))
+
+    if 'keywords' in proj:
+        _check_list_of_str(proj, 'keywords')
+        md_dict['keywords'] = ",".join(proj['keywords'])
+
+    if 'classifiers' in proj:
+        _check_list_of_str(proj, 'classifiers')
+        md_dict['classifiers'] = proj['classifiers']
+
+    if 'urls' in proj:
+        _check_type(proj, 'urls', dict)
+        project_urls = md_dict['project_urls'] = []
+        for label, url in sorted(proj['urls'].items()):
+            project_urls.append("{}, {}".format(label, url))
+
+    if 'entry-points' in proj:
+        _check_type(proj, 'entry-points', dict)
+        for grp in proj['entry-points'].values():
+            if not isinstance(grp, dict):
+                raise ConfigError(
+                    "projects.entry-points should only contain sub-tables"
+                )
+            if not all(isinstance(k, str) for k in grp.values()):
+                raise ConfigError(
+                    "[projects.entry-points.*] tables should have string values"
+                )
+        if set(proj['entry-points'].keys()) & {'console_scripts', 'gui_scripts'}:
+            raise ConfigError(
+                "Scripts should be specified in [project.scripts] or "
+                "[project.gui-scripts], not under [project.entry-points]"
+            )
+        lc.entrypoints = proj['entry-points']
+
+    if 'scripts' in proj:
+        _check_type(proj, 'scripts', dict)
+        if not all(isinstance(k, str) for k in proj['scripts'].values()):
+            raise ConfigError(
+                "[projects.scripts] table should have string values"
+            )
+        lc.entrypoints['console_scripts'] = proj['scripts']
+
+    if 'gui-scripts' in proj:
+        _check_type(proj, 'gui-scripts', dict)
+        if not all(isinstance(k, str) for k in proj['gui-scripts'].values()):
+            raise ConfigError(
+                "[projects.gui-scripts] table should have string values"
+            )
+        lc.entrypoints['gui_scripts'] = proj['gui-scripts']
+
+    if 'dependencies' in proj:
+        _check_list_of_str(proj, 'dependencies')
+        reqs_noextra = proj['dependencies']
+    else:
+        reqs_noextra = []
+
+    if 'optional-dependencies' in proj:
+        _check_type(proj, 'optional-dependencies', dict)
+        optdeps = proj['optional-dependencies']
+        if not all(isinstance(e, list) for e in optdeps.values()):
+            raise ConfigError(
+                'Expected a dict of lists in optional-dependencies field'
+            )
+        for e, reqs in optdeps.items():
+            if not all(isinstance(a, str) for a in reqs):
+                raise ConfigError(
+                    'Expected a string list for optional-dependencies ({})'.format(e)
+                )
+
+        lc.reqs_by_extra = optdeps.copy()
+        md_dict['provides_extra'] = sorted(lc.reqs_by_extra.keys())
+
+    md_dict['requires_dist'] = \
+        reqs_noextra + list(_expand_requires_extra(lc.reqs_by_extra))
+
+    # For internal use, record the main requirements as a '.none' extra.
+    if reqs_noextra:
+        lc.reqs_by_extra['.none'] = reqs_noextra
+
+    if 'dynamic' in proj:
+        _check_list_of_str(proj, 'dynamic')
+        dynamic = set(proj['dynamic'])
+        unrec_dynamic = dynamic - {'version', 'description'}
+        if unrec_dynamic:
+            raise ConfigError(
+                "flit only supports dynamic metadata for 'version' & 'description'"
+            )
+        if dynamic.intersection(proj):
+            raise ConfigError(
+                "keys listed in project.dynamic must not be in [project] table"
+            )
+        lc.dynamic_metadata = dynamic
+
+    if ('version' not in proj) and ('version' not in lc.dynamic_metadata):
+        raise ConfigError(
+            "version must be specified under [project] or listed as a dynamic field"
+        )
+    if ('description' not in proj) and ('description' not in lc.dynamic_metadata):
+        raise ConfigError(
+            "description must be specified under [project] or listed as a dynamic field"
+        )
+
+    return lc
+
+def pep621_people(people, group_name='author') -> dict:
+    """Convert authors/maintainers from PEP 621 to core metadata fields"""
+    names, emails = [], []
+    for person in people:
+        if not isinstance(person, dict):
+            raise ConfigError("{} info must be list of dicts".format(group_name))
+        unrec_keys = set(person.keys()) - {'name', 'email'}
+        if unrec_keys:
+            raise ConfigError(
+                "Unrecognised keys in {} info: {}".format(group_name, unrec_keys)
+            )
+        if 'email' in person:
+            email = person['email']
+            if 'name' in person:
+                email = str(Address(person['name'], addr_spec=email))
+            emails.append(email)
+        elif 'name' in person:
+            names.append(person['name'])
+
+    res = {}
+    if names:
+        res[group_name] = ", ".join(names)
+    if emails:
+        res[group_name + '_email'] = ", ".join(emails)
+    return res
diff --git a/flit_core/flit_core/sdist.py b/flit_core/flit_core/sdist.py
new file mode 100644
index 0000000..f41d177
--- /dev/null
+++ b/flit_core/flit_core/sdist.py
@@ -0,0 +1,202 @@
+from collections import defaultdict
+from copy import copy
+from glob import glob
+from gzip import GzipFile
+import io
+import logging
+import os
+import os.path as osp
+from pathlib import Path
+from posixpath import join as pjoin
+import tarfile
+
+from . import common
+
+log = logging.getLogger(__name__)
+
+
+def clean_tarinfo(ti, mtime=None):
+    """Clean metadata from a TarInfo object to make it more reproducible.
+
+    - Set uid & gid to 0
+    - Set uname and gname to ""
+    - Normalise permissions to 644 or 755
+    - Set mtime if not None
+    """
+    ti = copy(ti)
+    ti.uid = 0
+    ti.gid = 0
+    ti.uname = ''
+    ti.gname = ''
+    ti.mode = common.normalize_file_permissions(ti.mode)
+    if mtime is not None:
+        ti.mtime = mtime
+    return ti
+
+
+class FilePatterns:
+    """Manage a set of file inclusion/exclusion patterns relative to basedir"""
+    def __init__(self, patterns, basedir):
+        self.basedir = basedir
+
+        self.dirs = set()
+        self.files = set()
+
+        for pattern in patterns:
+            for path in sorted(glob(osp.join(basedir, pattern), recursive=True)):
+                rel = osp.relpath(path, basedir)
+                if osp.isdir(path):
+                    self.dirs.add(rel)
+                else:
+                    self.files.add(rel)
+
+    def match_file(self, rel_path):
+        if rel_path in self.files:
+            return True
+
+        return any(rel_path.startswith(d + os.sep) for d in self.dirs)
+
+    def match_dir(self, rel_path):
+        if rel_path in self.dirs:
+            return True
+
+        # Check if it's a subdirectory of any directory in the list
+        return any(rel_path.startswith(d + os.sep) for d in self.dirs)
+
+
+class SdistBuilder:
+    """Builds a minimal sdist
+
+    These minimal sdists should work for PEP 517.
+    The class is extended in flit.sdist to make a more 'full fat' sdist,
+    which is what should normally be published to PyPI.
+    """
+    def __init__(self, module, metadata, cfgdir, reqs_by_extra, entrypoints,
+                 extra_files, data_directory, include_patterns=(), exclude_patterns=()):
+        self.module = module
+        self.metadata = metadata
+        self.cfgdir = cfgdir
+        self.reqs_by_extra = reqs_by_extra
+        self.entrypoints = entrypoints
+        self.extra_files = extra_files
+        self.data_directory = data_directory
+        self.includes = FilePatterns(include_patterns, str(cfgdir))
+        self.excludes = FilePatterns(exclude_patterns, str(cfgdir))
+
+    @classmethod
+    def from_ini_path(cls, ini_path: Path):
+        # Local import so bootstrapping doesn't try to load toml
+        from .config import read_flit_config
+        ini_info = read_flit_config(ini_path)
+        srcdir = ini_path.parent
+        module = common.Module(ini_info.module, srcdir)
+        metadata = common.make_metadata(module, ini_info)
+        extra_files = [ini_path.name] + ini_info.referenced_files
+        return cls(
+            module, metadata, srcdir, ini_info.reqs_by_extra,
+            ini_info.entrypoints, extra_files, ini_info.data_directory,
+            ini_info.sdist_include_patterns, ini_info.sdist_exclude_patterns,
+        )
+
+    def prep_entry_points(self):
+        # Reformat entry points from dict-of-dicts to dict-of-lists
+        res = defaultdict(list)
+        for groupname, group in self.entrypoints.items():
+            for name, ep in sorted(group.items()):
+                res[groupname].append('{} = {}'.format(name, ep))
+
+        return dict(res)
+
+    def select_files(self):
+        """Pick which files from the source tree will be included in the sdist
+
+        This is overridden in flit itself to use information from a VCS to
+        include tests, docs, etc. for a 'gold standard' sdist.
+        """
+        cfgdir_s = str(self.cfgdir)
+        return [
+            osp.relpath(p, cfgdir_s) for p in self.module.iter_files()
+        ] + [
+            osp.relpath(p, cfgdir_s) for p in common.walk_data_dir(self.data_directory)
+        ] + self.extra_files
+
+    def apply_includes_excludes(self, files):
+        cfgdir_s = str(self.cfgdir)
+        files = {f for f in files if not self.excludes.match_file(f)}
+
+        for f_rel in self.includes.files:
+            if not self.excludes.match_file(f_rel):
+                files.add(f_rel)
+
+        for rel_d in self.includes.dirs:
+            for dirpath, dirs, dfiles in os.walk(osp.join(cfgdir_s, rel_d)):
+                for file in dfiles:
+                    f_abs = osp.join(dirpath, file)
+                    f_rel = osp.relpath(f_abs, cfgdir_s)
+                    if not self.excludes.match_file(f_rel):
+                        files.add(f_rel)
+
+                # Filter subdirectories before os.walk scans them
+                dirs[:] = [d for d in dirs if not self.excludes.match_dir(
+                    osp.relpath(osp.join(dirpath, d), cfgdir_s)
+                )]
+
+        crucial_files = set(
+            self.extra_files + [str(self.module.file.relative_to(self.cfgdir))]
+        )
+        missing_crucial = crucial_files - files
+        if missing_crucial:
+            raise Exception("Crucial files were excluded from the sdist: {}"
+                            .format(", ".join(missing_crucial)))
+
+        return sorted(files)
+
+    def add_setup_py(self, files_to_add, target_tarfile):
+        """No-op here; overridden in flit to generate setup.py"""
+        pass
+
+    @property
+    def dir_name(self):
+        return '{}-{}'.format(self.metadata.name, self.metadata.version)
+
+    def build(self, target_dir, gen_setup_py=True):
+        os.makedirs(str(target_dir), exist_ok=True)
+        target = target_dir / '{}-{}.tar.gz'.format(
+                self.metadata.name, self.metadata.version
+        )
+        source_date_epoch = os.environ.get('SOURCE_DATE_EPOCH', '')
+        mtime = int(source_date_epoch) if source_date_epoch else None
+        gz = GzipFile(str(target), mode='wb', mtime=mtime)
+        tf = tarfile.TarFile(str(target), mode='w', fileobj=gz,
+                             format=tarfile.PAX_FORMAT)
+
+        try:
+            files_to_add = self.apply_includes_excludes(self.select_files())
+
+            for relpath in files_to_add:
+                path = str(self.cfgdir / relpath)
+                ti = tf.gettarinfo(path, arcname=pjoin(self.dir_name, relpath))
+                ti = clean_tarinfo(ti, mtime)
+
+                if ti.isreg():
+                    with open(path, 'rb') as f:
+                        tf.addfile(ti, f)
+                else:
+                    tf.addfile(ti)  # Symlinks & ?
+
+            if gen_setup_py:
+                self.add_setup_py(files_to_add, tf)
+
+            stream = io.StringIO()
+            self.metadata.write_metadata_file(stream)
+            pkg_info = stream.getvalue().encode()
+            ti = tarfile.TarInfo(pjoin(self.dir_name, 'PKG-INFO'))
+            ti.size = len(pkg_info)
+            tf.addfile(ti, io.BytesIO(pkg_info))
+
+        finally:
+            tf.close()
+            gz.close()
+
+        log.info("Built sdist: %s", target)
+        return target
diff --git a/flit_core/flit_core/tests/__init__.py b/flit_core/flit_core/tests/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/__init__.py
diff --git a/flit_core/flit_core/tests/samples/EG_README.rst b/flit_core/flit_core/tests/samples/EG_README.rst
new file mode 100644
index 0000000..a742974
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/EG_README.rst
@@ -0,0 +1,4 @@
+This is an example long description for tests to load.
+
+This file is `valid reStructuredText
+<http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html>`_.
diff --git a/flit_core/flit_core/tests/samples/bad-description-ext.toml b/flit_core/flit_core/tests/samples/bad-description-ext.toml
new file mode 100644
index 0000000..1062829
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/bad-description-ext.toml
@@ -0,0 +1,9 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "module1.py"  # WRONG
diff --git a/flit_core/flit_core/tests/samples/conflicting_modules/module1.py b/flit_core/flit_core/tests/samples/conflicting_modules/module1.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/conflicting_modules/module1.py
diff --git a/flit_core/flit_core/tests/samples/conflicting_modules/pyproject.toml b/flit_core/flit_core/tests/samples/conflicting_modules/pyproject.toml
new file mode 100644
index 0000000..a38df52
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/conflicting_modules/pyproject.toml
@@ -0,0 +1,8 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
diff --git a/flit_core/flit_core/tests/samples/conflicting_modules/src/module1.py b/flit_core/flit_core/tests/samples/conflicting_modules/src/module1.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/conflicting_modules/src/module1.py
diff --git a/flit_core/flit_core/tests/samples/constructed_version/module1.py b/flit_core/flit_core/tests/samples/constructed_version/module1.py
new file mode 100644
index 0000000..5d9ec93
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/constructed_version/module1.py
@@ -0,0 +1,4 @@
+
+"""This module has a __version__ that requires runtime interpretation"""
+
+__version__ = ".".join(["1", "2", "3"])
diff --git a/flit_core/flit_core/tests/samples/constructed_version/pyproject.toml b/flit_core/flit_core/tests/samples/constructed_version/pyproject.toml
new file mode 100644
index 0000000..812b74f
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/constructed_version/pyproject.toml
@@ -0,0 +1,12 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+requires = [
+    "numpy >=1.16.0",
+]
diff --git a/flit_core/flit_core/tests/samples/extras-dev-conflict.toml b/flit_core/flit_core/tests/samples/extras-dev-conflict.toml
new file mode 100644
index 0000000..0fe249d
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/extras-dev-conflict.toml
@@ -0,0 +1,13 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
+dev-requires = ["apackage"]
+
+[tool.flit.metadata.requires-extra]
+dev = ["anotherpackage"]
diff --git a/flit_core/flit_core/tests/samples/extras.toml b/flit_core/flit_core/tests/samples/extras.toml
new file mode 100644
index 0000000..afdb221
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/extras.toml
@@ -0,0 +1,15 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
+requires = ["toml"]
+
+[tool.flit.metadata.requires-extra]
+test = ["pytest"]
+custom = ["requests"]
diff --git a/flit_core/flit_core/tests/samples/imported_version/package1/__init__.py b/flit_core/flit_core/tests/samples/imported_version/package1/__init__.py
new file mode 100644
index 0000000..49adc42
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/imported_version/package1/__init__.py
@@ -0,0 +1,3 @@
+"""This module has a __version__ that requires a relative import"""
+
+from ._version import __version__
diff --git a/flit_core/flit_core/tests/samples/imported_version/package1/_version.py b/flit_core/flit_core/tests/samples/imported_version/package1/_version.py
new file mode 100644
index 0000000..91201fc
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/imported_version/package1/_version.py
@@ -0,0 +1 @@
+__version__ = '0.5.8'
diff --git a/flit_core/flit_core/tests/samples/imported_version/pyproject.toml b/flit_core/flit_core/tests/samples/imported_version/pyproject.toml
new file mode 100644
index 0000000..b6d44e1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/imported_version/pyproject.toml
@@ -0,0 +1,10 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "package1"
+authors = [
+    {name = "Sir Röbin", email = "robin@camelot.uk"}
+]
+dynamic = ["version", "description"]
diff --git a/flit_core/flit_core/tests/samples/inclusion/LICENSES/README b/flit_core/flit_core/tests/samples/inclusion/LICENSES/README
new file mode 100644
index 0000000..63de856
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/LICENSES/README
@@ -0,0 +1,2 @@
+This directory will match the LICENSE* glob which Flit uses to add license
+files to wheel metadata.
diff --git a/flit_core/flit_core/tests/samples/inclusion/doc/subdir/subsubdir/test.md b/flit_core/flit_core/tests/samples/inclusion/doc/subdir/subsubdir/test.md
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/doc/subdir/subsubdir/test.md
diff --git a/flit_core/flit_core/tests/samples/inclusion/doc/subdir/test.txt b/flit_core/flit_core/tests/samples/inclusion/doc/subdir/test.txt
new file mode 100644
index 0000000..5f852b1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/doc/subdir/test.txt
@@ -0,0 +1 @@
+sdists should include this (see pyproject.toml)
diff --git a/flit_core/flit_core/tests/samples/inclusion/doc/test.rst b/flit_core/flit_core/tests/samples/inclusion/doc/test.rst
new file mode 100644
index 0000000..5f852b1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/doc/test.rst
@@ -0,0 +1 @@
+sdists should include this (see pyproject.toml)
diff --git a/flit_core/flit_core/tests/samples/inclusion/doc/test.txt b/flit_core/flit_core/tests/samples/inclusion/doc/test.txt
new file mode 100644
index 0000000..31dc06a
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/doc/test.txt
@@ -0,0 +1 @@
+sdists should exclude this (see pyproject.toml)
diff --git a/flit_core/flit_core/tests/samples/inclusion/module1.py b/flit_core/flit_core/tests/samples/inclusion/module1.py
new file mode 100644
index 0000000..7e0d3cb
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/module1.py
@@ -0,0 +1,3 @@
+"""For tests"""
+
+__version__ = '0.1'
diff --git a/flit_core/flit_core/tests/samples/inclusion/pyproject.toml b/flit_core/flit_core/tests/samples/inclusion/pyproject.toml
new file mode 100644
index 0000000..c37d44d
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/inclusion/pyproject.toml
@@ -0,0 +1,12 @@
+[build-system]
+requires = ["flit"]
+build-backend = "flit.buildapi"
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+
+[tool.flit.sdist]
+include = ["doc"]
+exclude = ["doc/*.txt", "doc/**/*.md"]
diff --git a/flit_core/flit_core/tests/samples/invalid_version1.py b/flit_core/flit_core/tests/samples/invalid_version1.py
new file mode 100644
index 0000000..dd3268a
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/invalid_version1.py
@@ -0,0 +1,3 @@
+"""Sample module with invalid __version__ string"""
+
+__version__ = "not starting with a number"
\ No newline at end of file
diff --git a/flit_core/flit_core/tests/samples/missing-description-file.toml b/flit_core/flit_core/tests/samples/missing-description-file.toml
new file mode 100644
index 0000000..00fae72
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/missing-description-file.toml
@@ -0,0 +1,9 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "missingdescriptionfile"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/missingdescriptionfile"
+description-file = "definitely-missing.rst"
diff --git a/flit_core/flit_core/tests/samples/misspelled-key.toml b/flit_core/flit_core/tests/samples/misspelled-key.toml
new file mode 100644
index 0000000..cbde9ac
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/misspelled-key.toml
@@ -0,0 +1,10 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "package1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+descryption-file = "my-description.rst"  # Deliberate typo for test
+home-page = "http://github.com/sirrobin/package1"
diff --git a/flit_core/flit_core/tests/samples/module1-pkg.ini b/flit_core/flit_core/tests/samples/module1-pkg.ini
new file mode 100644
index 0000000..9bbfc4e
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/module1-pkg.ini
@@ -0,0 +1,5 @@
+[metadata]
+module=module1
+author=Sir Robin
+author-email=robin@camelot.uk
+home-page=http://github.com/sirrobin/module1
diff --git a/flit_core/flit_core/tests/samples/module1-pkg.toml b/flit_core/flit_core/tests/samples/module1-pkg.toml
new file mode 100644
index 0000000..740ec87
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/module1-pkg.toml
@@ -0,0 +1,12 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
+
+[tool.flit.metadata.urls]
+Documentation = "https://example.com/module1"
diff --git a/flit_core/flit_core/tests/samples/module1.py b/flit_core/flit_core/tests/samples/module1.py
new file mode 100644
index 0000000..87f0370
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/module1.py
@@ -0,0 +1,3 @@
+"""Example module"""
+
+__version__ = '0.1'
diff --git a/flit_core/flit_core/tests/samples/module2.py b/flit_core/flit_core/tests/samples/module2.py
new file mode 100644
index 0000000..0f36679
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/module2.py
@@ -0,0 +1,10 @@
+"""
+Docstring formatted like this.
+"""
+
+a = {}
+# An assignment to a subscript (a['test']) broke introspection
+# https://github.com/pypa/flit/issues/343
+a['test'] = 6
+
+__version__ = '7.0'
diff --git a/flit_core/flit_core/tests/samples/moduleunimportable.py b/flit_core/flit_core/tests/samples/moduleunimportable.py
new file mode 100644
index 0000000..147d26e
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/moduleunimportable.py
@@ -0,0 +1,8 @@
+
+"""
+A sample unimportable module
+"""
+
+raise ImportError()
+
+__version__ = "0.1"
diff --git a/flit_core/flit_core/tests/samples/moduleunimportabledouble.py b/flit_core/flit_core/tests/samples/moduleunimportabledouble.py
new file mode 100644
index 0000000..42d51f3
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/moduleunimportabledouble.py
@@ -0,0 +1,8 @@
+
+"""
+A sample unimportable module with double assignment
+"""
+
+raise ImportError()
+
+VERSION = __version__ = "0.1"
diff --git a/flit_core/flit_core/tests/samples/my-description.rst b/flit_core/flit_core/tests/samples/my-description.rst
new file mode 100644
index 0000000..623cb1d
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/my-description.rst
@@ -0,0 +1 @@
+Sample description for test.
diff --git a/flit_core/flit_core/tests/samples/no_docstring-pkg.toml b/flit_core/flit_core/tests/samples/no_docstring-pkg.toml
new file mode 100644
index 0000000..b68827f
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/no_docstring-pkg.toml
@@ -0,0 +1,12 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "no_docstring"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/no_docstring"
+description-file = "EG_README.rst"
+
+[tool.flit.metadata.urls]
+Documentation = "https://example.com/no_docstring"
diff --git a/flit_core/flit_core/tests/samples/no_docstring.py b/flit_core/flit_core/tests/samples/no_docstring.py
new file mode 100644
index 0000000..29524eb
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/no_docstring.py
@@ -0,0 +1 @@
+__version__ = '7.0'
diff --git a/flit_core/flit_core/tests/samples/normalization/my_python_module.py b/flit_core/flit_core/tests/samples/normalization/my_python_module.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/normalization/my_python_module.py
diff --git a/flit_core/flit_core/tests/samples/normalization/pyproject.toml b/flit_core/flit_core/tests/samples/normalization/pyproject.toml
new file mode 100644
index 0000000..c32e4a1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/normalization/pyproject.toml
@@ -0,0 +1,14 @@
+[build-system]
+requires = ["flit_core >=3.8,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "my-python-module"
+version = "0.0.1"
+description = "Hyphenated package name, infered import name"
+authors = [
+    {name = "Sir Robin", email = "robin@camelot.uk"}
+]
+
+[project.urls]
+homepage = "http://github.com/me/python-module"
diff --git a/flit_core/flit_core/tests/samples/ns1-pkg/EG_README.rst b/flit_core/flit_core/tests/samples/ns1-pkg/EG_README.rst
new file mode 100644
index 0000000..a742974
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/ns1-pkg/EG_README.rst
@@ -0,0 +1,4 @@
+This is an example long description for tests to load.
+
+This file is `valid reStructuredText
+<http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html>`_.
diff --git a/flit_core/flit_core/tests/samples/ns1-pkg/ns1/pkg/__init__.py b/flit_core/flit_core/tests/samples/ns1-pkg/ns1/pkg/__init__.py
new file mode 100644
index 0000000..445afbb
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/ns1-pkg/ns1/pkg/__init__.py
@@ -0,0 +1,8 @@
+"""
+==================
+ns1.pkg
+==================
+"""
+
+__version__ = '0.1'
+
diff --git a/flit_core/flit_core/tests/samples/ns1-pkg/pyproject.toml b/flit_core/flit_core/tests/samples/ns1-pkg/pyproject.toml
new file mode 100644
index 0000000..acbabb1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/ns1-pkg/pyproject.toml
@@ -0,0 +1,10 @@
+[build-system]
+requires = ["flit_core >=3.5,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "ns1.pkg"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
diff --git a/flit_core/flit_core/tests/samples/package1.toml b/flit_core/flit_core/tests/samples/package1.toml
new file mode 100644
index 0000000..ca12080
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1.toml
@@ -0,0 +1,13 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "package1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+description-file = "my-description.rst"
+home-page = "http://github.com/sirrobin/package1"
+
+[scripts]
+pkg_script = "package1:main"
diff --git a/flit_core/flit_core/tests/samples/package1/__init__.py b/flit_core/flit_core/tests/samples/package1/__init__.py
new file mode 100644
index 0000000..07978d8
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1/__init__.py
@@ -0,0 +1,6 @@
+"""A sample package"""
+
+__version__ = '0.1'
+
+def main():
+    print("package1 main")
diff --git a/flit_core/flit_core/tests/samples/package1/data_dir/foo.sh b/flit_core/flit_core/tests/samples/package1/data_dir/foo.sh
new file mode 100644
index 0000000..92abcfb
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1/data_dir/foo.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+echo "Example data file"
diff --git a/flit_core/flit_core/tests/samples/package1/foo.py b/flit_core/flit_core/tests/samples/package1/foo.py
new file mode 100644
index 0000000..1337a53
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1/foo.py
@@ -0,0 +1 @@
+a = 1
diff --git a/flit_core/flit_core/tests/samples/package1/subpkg/__init__.py b/flit_core/flit_core/tests/samples/package1/subpkg/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1/subpkg/__init__.py
diff --git a/flit_core/flit_core/tests/samples/package1/subpkg/sp_data_dir/test.json b/flit_core/flit_core/tests/samples/package1/subpkg/sp_data_dir/test.json
new file mode 100644
index 0000000..f77d03c
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1/subpkg/sp_data_dir/test.json
@@ -0,0 +1 @@
+{"example": true}
diff --git a/flit_core/flit_core/tests/samples/package1/subpkg2/__init__.py b/flit_core/flit_core/tests/samples/package1/subpkg2/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/package1/subpkg2/__init__.py
diff --git a/flit_core/flit_core/tests/samples/pep517/LICENSE b/flit_core/flit_core/tests/samples/pep517/LICENSE
new file mode 100644
index 0000000..7f5c194
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep517/LICENSE
@@ -0,0 +1 @@
+This file should be added to wheels
diff --git a/flit_core/flit_core/tests/samples/pep517/README.rst b/flit_core/flit_core/tests/samples/pep517/README.rst
new file mode 100644
index 0000000..ef7b7c1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep517/README.rst
@@ -0,0 +1 @@
+This contains a nön-ascii character
diff --git a/flit_core/flit_core/tests/samples/pep517/module1.py b/flit_core/flit_core/tests/samples/pep517/module1.py
new file mode 100644
index 0000000..87f0370
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep517/module1.py
@@ -0,0 +1,3 @@
+"""Example module"""
+
+__version__ = '0.1'
diff --git a/flit_core/flit_core/tests/samples/pep517/pyproject.toml b/flit_core/flit_core/tests/samples/pep517/pyproject.toml
new file mode 100644
index 0000000..b6cebac
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep517/pyproject.toml
@@ -0,0 +1,17 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "README.rst"
+requires = [
+    "requests >= 2.18",
+    "docutils",
+]
+
+[tool.flit.entrypoints.flit_test_example]
+foo = "module1:main"
diff --git a/flit_core/flit_core/tests/samples/pep621/LICENSE b/flit_core/flit_core/tests/samples/pep621/LICENSE
new file mode 100644
index 0000000..7f5c194
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621/LICENSE
@@ -0,0 +1 @@
+This file should be added to wheels
diff --git a/flit_core/flit_core/tests/samples/pep621/README.rst b/flit_core/flit_core/tests/samples/pep621/README.rst
new file mode 100644
index 0000000..ef7b7c1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621/README.rst
@@ -0,0 +1 @@
+This contains a nön-ascii character
diff --git a/flit_core/flit_core/tests/samples/pep621/module1a.py b/flit_core/flit_core/tests/samples/pep621/module1a.py
new file mode 100644
index 0000000..87f0370
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621/module1a.py
@@ -0,0 +1,3 @@
+"""Example module"""
+
+__version__ = '0.1'
diff --git a/flit_core/flit_core/tests/samples/pep621/pyproject.toml b/flit_core/flit_core/tests/samples/pep621/pyproject.toml
new file mode 100644
index 0000000..72a85d0
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621/pyproject.toml
@@ -0,0 +1,39 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "module1"
+authors = [
+    {name = "Sir Röbin", email = "robin@camelot.uk"}
+]
+maintainers = [
+    {name = "Sir Galahad"}
+]
+readme = "README.rst"
+license = {file = "LICENSE"}
+requires-python = ">=3.7"
+dependencies = [
+    "requests >= 2.18",
+    "docutils",
+]
+keywords = ["example", "test"]
+dynamic = [
+    "version",
+    "description",
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest",
+  "mock; python_version<'3.6'"
+]
+
+[project.urls]
+homepage = "http://github.com/sirrobin/module1"
+
+[project.entry-points.flit_test_example]
+foo = "module1:main"
+
+[tool.flit.module]
+name = "module1a"
diff --git a/flit_core/flit_core/tests/samples/pep621_nodynamic/README.rst b/flit_core/flit_core/tests/samples/pep621_nodynamic/README.rst
new file mode 100644
index 0000000..ef7b7c1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621_nodynamic/README.rst
@@ -0,0 +1 @@
+This contains a nön-ascii character
diff --git a/flit_core/flit_core/tests/samples/pep621_nodynamic/module1.py b/flit_core/flit_core/tests/samples/pep621_nodynamic/module1.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621_nodynamic/module1.py
diff --git a/flit_core/flit_core/tests/samples/pep621_nodynamic/pyproject.toml b/flit_core/flit_core/tests/samples/pep621_nodynamic/pyproject.toml
new file mode 100644
index 0000000..0b579f3
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/pep621_nodynamic/pyproject.toml
@@ -0,0 +1,28 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "module1"
+version = "0.03"
+description = "Statically specified description"
+authors = [
+    {name = "Sir Robin", email = "robin@camelot.uk"}
+]
+readme = {file = "README.rst", content-type = "text/x-rst"}
+classifiers = [
+    "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+    "requests >= 2.18",
+    "docutils",
+]  # N.B. Using this to check behaviour with dependencies but no optional deps
+
+[project.urls]
+homepage = "http://github.com/sirrobin/module1"
+
+[project.scripts]
+foo = "module1:main"
+
+[project.gui-scripts]
+foo-gui = "module1:main"
diff --git a/flit_core/flit_core/tests/samples/requires-dev.toml b/flit_core/flit_core/tests/samples/requires-dev.toml
new file mode 100644
index 0000000..46e3170
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/requires-dev.toml
@@ -0,0 +1,11 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
+# This should generate a warning tell you to use requires-extra.dev
+dev-requires = ["apackage"]
diff --git a/flit_core/flit_core/tests/samples/requires-envmark.toml b/flit_core/flit_core/tests/samples/requires-envmark.toml
new file mode 100644
index 0000000..e97c5f0
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/requires-envmark.toml
@@ -0,0 +1,12 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+requires = [
+    "requests",
+    "pathlib2; python_version == '2.7'",
+]
diff --git a/flit_core/flit_core/tests/samples/requires-extra-envmark.toml b/flit_core/flit_core/tests/samples/requires-extra-envmark.toml
new file mode 100644
index 0000000..ac49cb0
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/requires-extra-envmark.toml
@@ -0,0 +1,12 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
+
+[tool.flit.metadata.requires-extra]
+test = ["pathlib2; python_version == \"2.7\""]
diff --git a/flit_core/flit_core/tests/samples/requires-requests.toml b/flit_core/flit_core/tests/samples/requires-requests.toml
new file mode 100644
index 0000000..bf26ac5
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/requires-requests.toml
@@ -0,0 +1,10 @@
+[build-system]
+requires = ["flit"]
+
+[tool.flit.metadata]
+module = "module1"
+author = "Sir Robin"
+author-email = "robin@camelot.uk"
+home-page = "http://github.com/sirrobin/module1"
+description-file = "EG_README.rst"
+requires = ["requests"]
diff --git a/flit_core/flit_core/tests/samples/with_data_dir/LICENSE b/flit_core/flit_core/tests/samples/with_data_dir/LICENSE
new file mode 100644
index 0000000..7f5c194
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/with_data_dir/LICENSE
@@ -0,0 +1 @@
+This file should be added to wheels
diff --git a/flit_core/flit_core/tests/samples/with_data_dir/README.rst b/flit_core/flit_core/tests/samples/with_data_dir/README.rst
new file mode 100644
index 0000000..ef7b7c1
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/with_data_dir/README.rst
@@ -0,0 +1 @@
+This contains a nön-ascii character
diff --git a/flit_core/flit_core/tests/samples/with_data_dir/data/share/man/man1/foo.1 b/flit_core/flit_core/tests/samples/with_data_dir/data/share/man/man1/foo.1
new file mode 100644
index 0000000..c12128d
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/with_data_dir/data/share/man/man1/foo.1
@@ -0,0 +1 @@
+Example data file
diff --git a/flit_core/flit_core/tests/samples/with_data_dir/module1.py b/flit_core/flit_core/tests/samples/with_data_dir/module1.py
new file mode 100644
index 0000000..87f0370
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/with_data_dir/module1.py
@@ -0,0 +1,3 @@
+"""Example module"""
+
+__version__ = '0.1'
diff --git a/flit_core/flit_core/tests/samples/with_data_dir/pyproject.toml b/flit_core/flit_core/tests/samples/with_data_dir/pyproject.toml
new file mode 100644
index 0000000..84d165e
--- /dev/null
+++ b/flit_core/flit_core/tests/samples/with_data_dir/pyproject.toml
@@ -0,0 +1,26 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "module1"
+authors = [
+    {name = "Sir Röbin", email = "robin@camelot.uk"}
+]
+readme = "README.rst"
+license = {file = "LICENSE"}
+requires-python = ">=3.7"
+dependencies = [
+    "requests >= 2.18",
+    "docutils",
+]
+dynamic = [
+    "version",
+    "description",
+]
+
+[project.scripts]
+foo = "module1:main"
+
+[tool.flit.external-data]
+directory = "data"
diff --git a/flit_core/flit_core/tests/test_build_thyself.py b/flit_core/flit_core/tests/test_build_thyself.py
new file mode 100644
index 0000000..ad15819
--- /dev/null
+++ b/flit_core/flit_core/tests/test_build_thyself.py
@@ -0,0 +1,57 @@
+"""Tests of flit_core building itself"""
+import os
+import os.path as osp
+import pytest
+import tarfile
+from testpath import assert_isdir, assert_isfile
+import zipfile
+
+from flit_core import buildapi
+
+@pytest.fixture()
+def cwd_project():
+    proj_dir = osp.dirname(osp.dirname(osp.abspath(buildapi.__file__)))
+    if not osp.isfile(osp.join(proj_dir, 'pyproject.toml')):
+        pytest.skip("need flit_core source directory")
+
+    old_cwd = os.getcwd()
+    try:
+        os.chdir(proj_dir)
+        yield
+    finally:
+        os.chdir(old_cwd)
+
+
+def test_prepare_metadata(tmp_path, cwd_project):
+    tmp_path = str(tmp_path)
+    dist_info = buildapi.prepare_metadata_for_build_wheel(tmp_path)
+
+    assert dist_info.endswith('.dist-info')
+    assert dist_info.startswith('flit_core')
+    dist_info = osp.join(tmp_path, dist_info)
+    assert_isdir(dist_info)
+
+    assert_isfile(osp.join(dist_info, 'WHEEL'))
+    assert_isfile(osp.join(dist_info, 'METADATA'))
+
+
+def test_wheel(tmp_path, cwd_project):
+    tmp_path = str(tmp_path)
+    filename = buildapi.build_wheel(tmp_path)
+
+    assert filename.endswith('.whl')
+    assert filename.startswith('flit_core')
+    path = osp.join(tmp_path, filename)
+    assert_isfile(path)
+    assert zipfile.is_zipfile(path)
+
+
+def test_sdist(tmp_path, cwd_project):
+    tmp_path = str(tmp_path)
+    filename = buildapi.build_sdist(tmp_path)
+
+    assert filename.endswith('.tar.gz')
+    assert filename.startswith('flit_core')
+    path = osp.join(tmp_path, filename)
+    assert_isfile(path)
+    assert tarfile.is_tarfile(path)
diff --git a/flit_core/flit_core/tests/test_buildapi.py b/flit_core/flit_core/tests/test_buildapi.py
new file mode 100644
index 0000000..3e621e6
--- /dev/null
+++ b/flit_core/flit_core/tests/test_buildapi.py
@@ -0,0 +1,93 @@
+from contextlib import contextmanager
+import os
+import os.path as osp
+import tarfile
+from testpath import assert_isfile, assert_isdir
+from testpath.tempdir import TemporaryDirectory
+import zipfile
+
+from flit_core import buildapi
+
+samples_dir = osp.join(osp.dirname(__file__), 'samples')
+
+@contextmanager
+def cwd(directory):
+    prev = os.getcwd()
+    os.chdir(directory)
+    try:
+        yield
+    finally:
+        os.chdir(prev)
+
+def test_get_build_requires():
+    # This module can be inspected (for docstring & __version__) without
+    # importing it, so there are no build dependencies.
+    with cwd(osp.join(samples_dir,'pep517')):
+        assert buildapi.get_requires_for_build_wheel() == []
+        assert buildapi.get_requires_for_build_editable() == []
+        assert buildapi.get_requires_for_build_sdist() == []
+
+def test_get_build_requires_pep621_nodynamic():
+    # This module isn't inspected because version & description are specified
+    # as static metadata in pyproject.toml, so there are no build dependencies
+    with cwd(osp.join(samples_dir, 'pep621_nodynamic')):
+        assert buildapi.get_requires_for_build_wheel() == []
+        assert buildapi.get_requires_for_build_editable() == []
+        assert buildapi.get_requires_for_build_sdist() == []
+
+def test_get_build_requires_import():
+    # This one has to be imported, so its runtime dependencies are also
+    # build dependencies.
+    expected = ["numpy >=1.16.0"]
+    with cwd(osp.join(samples_dir, 'constructed_version')):
+        assert buildapi.get_requires_for_build_wheel() == expected
+        assert buildapi.get_requires_for_build_editable() == expected
+        assert buildapi.get_requires_for_build_sdist() == expected
+
+def test_build_wheel():
+    with TemporaryDirectory() as td, cwd(osp.join(samples_dir,'pep517')):
+        filename = buildapi.build_wheel(td)
+        assert filename.endswith('.whl'), filename
+        assert_isfile(osp.join(td, filename))
+        assert zipfile.is_zipfile(osp.join(td, filename))
+        with zipfile.ZipFile(osp.join(td, filename)) as zip:
+            assert "module1.py" in zip.namelist()
+            assert "module1.pth" not in zip.namelist()
+
+def test_build_wheel_pep621():
+    with TemporaryDirectory() as td, cwd(osp.join(samples_dir, 'pep621')):
+        filename = buildapi.build_wheel(td)
+        assert filename.endswith('.whl'), filename
+        assert_isfile(osp.join(td, filename))
+        assert zipfile.is_zipfile(osp.join(td, filename))
+
+def test_build_editable():
+    with TemporaryDirectory() as td, cwd(osp.join(samples_dir,'pep517')):
+        filename = buildapi.build_editable(td)
+        assert filename.endswith('.whl'), filename
+        assert_isfile(osp.join(td, filename))
+        assert zipfile.is_zipfile(osp.join(td, filename))
+        with zipfile.ZipFile(osp.join(td, filename)) as zip:
+            assert "module1.py" not in zip.namelist()
+            assert "module1.pth" in zip.namelist()
+
+def test_build_sdist():
+    with TemporaryDirectory() as td, cwd(osp.join(samples_dir,'pep517')):
+        filename = buildapi.build_sdist(td)
+        assert filename.endswith('.tar.gz'), filename
+        assert_isfile(osp.join(td, filename))
+        assert tarfile.is_tarfile(osp.join(td, filename))
+
+def test_prepare_metadata_for_build_wheel():
+    with TemporaryDirectory() as td, cwd(osp.join(samples_dir,'pep517')):
+        dirname = buildapi.prepare_metadata_for_build_wheel(td)
+        assert dirname.endswith('.dist-info'), dirname
+        assert_isdir(osp.join(td, dirname))
+        assert_isfile(osp.join(td, dirname, 'METADATA'))
+
+def test_prepare_metadata_for_build_editable():
+    with TemporaryDirectory() as td, cwd(osp.join(samples_dir,'pep517')):
+        dirname = buildapi.prepare_metadata_for_build_editable(td)
+        assert dirname.endswith('.dist-info'), dirname
+        assert_isdir(osp.join(td, dirname))
+        assert_isfile(osp.join(td, dirname, 'METADATA'))
diff --git a/flit_core/flit_core/tests/test_common.py b/flit_core/flit_core/tests/test_common.py
new file mode 100644
index 0000000..b6d6290
--- /dev/null
+++ b/flit_core/flit_core/tests/test_common.py
@@ -0,0 +1,158 @@
+import email.parser
+import email.policy
+from io import StringIO
+from pathlib import Path
+import pytest
+from unittest import TestCase
+
+from flit_core import config
+from flit_core.common import (
+    Module, get_info_from_module, InvalidVersion, NoVersionError, check_version,
+    normalize_file_permissions, Metadata, make_metadata,
+)
+
+samples_dir = Path(__file__).parent / 'samples'
+
+class ModuleTests(TestCase):
+    def test_ns_package_importable(self):
+        i = Module('ns1.pkg', samples_dir / 'ns1-pkg')
+        assert i.path == Path(samples_dir, 'ns1-pkg', 'ns1', 'pkg')
+        assert i.file == Path(samples_dir, 'ns1-pkg', 'ns1', 'pkg', '__init__.py')
+        assert i.is_package
+
+        assert i.in_namespace_package
+        assert i.namespace_package_name == 'ns1'
+
+    def test_package_importable(self):
+        i = Module('package1', samples_dir)
+        assert i.path == samples_dir / 'package1'
+        assert i.file == samples_dir / 'package1' / '__init__.py'
+        assert i.is_package
+
+    def test_module_importable(self):
+        i = Module('module1', samples_dir)
+        assert i.path == samples_dir / 'module1.py'
+        assert not i.is_package
+
+    def test_missing_name(self):
+        with self.assertRaises(ValueError):
+            i = Module('doesnt_exist', samples_dir)
+
+    def test_conflicting_modules(self):
+        with pytest.raises(ValueError, match="Multiple"):
+            Module('module1', samples_dir / 'conflicting_modules')
+
+    def test_get_info_from_module(self):
+        info = get_info_from_module(Module('module1', samples_dir))
+        self.assertEqual(info, {'summary': 'Example module',
+                                'version': '0.1'}
+                         )
+
+        info = get_info_from_module(Module('module2', samples_dir))
+        self.assertEqual(info, {'summary': 'Docstring formatted like this.',
+                                'version': '7.0'}
+                         )
+
+        pkg1 = Module('package1', samples_dir)
+        info = get_info_from_module(pkg1)
+        self.assertEqual(info, {'summary': 'A sample package',
+                                'version': '0.1'}
+                         )
+        info = get_info_from_module(pkg1, for_fields=['version'])
+        self.assertEqual(info, {'version': '0.1'})
+        info = get_info_from_module(pkg1, for_fields=['description'])
+        self.assertEqual(info, {'summary': 'A sample package'})
+        info = get_info_from_module(pkg1, for_fields=[])
+        self.assertEqual(info, {})
+
+        info = get_info_from_module(Module('moduleunimportable', samples_dir))
+        self.assertEqual(info, {'summary': 'A sample unimportable module',
+                                'version': '0.1'}
+                         )
+
+        info = get_info_from_module(Module('moduleunimportabledouble', samples_dir))
+        self.assertEqual(info, {'summary': 'A sample unimportable module with double assignment',
+                                'version': '0.1'}
+                         )
+
+        info = get_info_from_module(Module('module1', samples_dir / 'constructed_version'))
+        self.assertEqual(info, {'summary': 'This module has a __version__ that requires runtime interpretation',
+                                'version': '1.2.3'}
+                         )
+
+        info = get_info_from_module(Module('package1', samples_dir / 'imported_version'))
+        self.assertEqual(info, {'summary': 'This module has a __version__ that requires a relative import',
+                                'version': '0.5.8'}
+                         )
+
+        with self.assertRaises(InvalidVersion):
+            get_info_from_module(Module('invalid_version1', samples_dir))
+
+    def test_version_raise(self):
+        with pytest.raises(InvalidVersion):
+            check_version('a.1.0.beta0')
+
+        with pytest.raises(InvalidVersion):
+            check_version('3!')
+
+        with pytest.raises(InvalidVersion):
+            check_version((1, 2))
+
+        with pytest.raises(NoVersionError):
+            check_version(None)
+
+        assert check_version('4.1.0beta1') == '4.1.0b1'
+        assert check_version('v1.2') == '1.2'
+
+def test_normalize_file_permissions():
+    assert normalize_file_permissions(0o100664) == 0o100644 # regular file
+    assert normalize_file_permissions(0o40775) == 0o40755   # directory
+
+@pytest.mark.parametrize(
+    ("requires_python", "expected_result"),
+    [
+        ("", True),
+        (">2.7", True),
+        ("3", False),
+        (">= 3.7", False),
+        ("<4, > 3.2", False),
+        (">3.4", False),
+        (">=2.7, !=3.0.*, !=3.1.*, !=3.2.*", True),
+        ("== 3.9", False),
+        ("~=2.7", True),
+        ("~=3.9", False),
+    ],
+)
+def test_supports_py2(requires_python, expected_result):
+    metadata = object.__new__(Metadata)
+    metadata.requires_python = requires_python
+    result = metadata.supports_py2
+    assert result == expected_result
+
+def test_make_metadata():
+    project_dir = samples_dir / 'pep621_nodynamic'
+    ini_info = config.read_flit_config(project_dir / 'pyproject.toml')
+    module = Module(ini_info.module, project_dir)
+    print(module.file)
+    md = make_metadata(module, ini_info)
+    assert md.version == '0.3'
+    assert md.summary == "Statically specified description"
+
+def test_metadata_multiline(tmp_path):
+    d = {
+        'name': 'foo',
+        'version': '1.0',
+        # Example from: https://packaging.python.org/specifications/core-metadata/#author
+        'author': ('C. Schultz, Universal Features Syndicate\n'
+                   'Los Angeles, CA <cschultz@peanuts.example.com>'),
+    }
+    md = Metadata(d)
+    sio = StringIO()
+    md.write_metadata_file(sio)
+    sio.seek(0)
+
+    msg = email.parser.Parser(policy=email.policy.compat32).parse(sio)
+    assert msg['Name'] == d['name']
+    assert msg['Version'] == d['version']
+    assert [l.lstrip() for l in msg['Author'].splitlines()] == d['author'].splitlines()
+    assert not msg.defects
diff --git a/flit_core/flit_core/tests/test_config.py b/flit_core/flit_core/tests/test_config.py
new file mode 100644
index 0000000..eafb7e9
--- /dev/null
+++ b/flit_core/flit_core/tests/test_config.py
@@ -0,0 +1,165 @@
+import logging
+from pathlib import Path
+import pytest
+
+from flit_core import config
+
+samples_dir = Path(__file__).parent / 'samples'
+
+def test_flatten_entrypoints():
+    r = config.flatten_entrypoints({'a': {'b': {'c': 'd'}, 'e': {'f': {'g': 'h'}}, 'i': 'j'}})
+    assert r == {'a': {'i': 'j'}, 'a.b': {'c': 'd'}, 'a.e.f': {'g': 'h'}}
+
+def test_load_toml():
+    inf = config.read_flit_config(samples_dir / 'module1-pkg.toml')
+    assert inf.module == 'module1'
+    assert inf.metadata['home_page'] == 'http://github.com/sirrobin/module1'
+
+def test_load_toml_ns():
+    inf = config.read_flit_config(samples_dir / 'ns1-pkg' / 'pyproject.toml')
+    assert inf.module == 'ns1.pkg'
+    assert inf.metadata['home_page'] == 'http://github.com/sirrobin/module1'
+
+def test_load_normalization():
+    inf = config.read_flit_config(samples_dir / 'normalization' / 'pyproject.toml')
+    assert inf.module == 'my_python_module'
+    assert inf.metadata['name'] == 'my-python-module'
+
+def test_load_pep621():
+    inf = config.read_flit_config(samples_dir / 'pep621' / 'pyproject.toml')
+    assert inf.module == 'module1a'
+    assert inf.metadata['name'] == 'module1'
+    assert inf.metadata['description_content_type'] == 'text/x-rst'
+    # Remove all whitespace from requirements so we don't check exact format:
+    assert {r.replace(' ', '') for r in inf.metadata['requires_dist']} == {
+        'docutils',
+        'requests>=2.18',
+        'pytest;extra=="test"',  # from [project.optional-dependencies]
+        'mock;extra=="test"and(python_version<\'3.6\')',
+    }
+    assert inf.metadata['author_email'] == "Sir Röbin <robin@camelot.uk>"
+    assert inf.entrypoints['flit_test_example']['foo'] == 'module1:main'
+    assert set(inf.dynamic_metadata) == {'version', 'description'}
+
+def test_load_pep621_nodynamic():
+    inf = config.read_flit_config(samples_dir / 'pep621_nodynamic' / 'pyproject.toml')
+    assert inf.module == 'module1'
+    assert inf.metadata['name'] == 'module1'
+    assert inf.metadata['version'] == '0.3'
+    assert inf.metadata['summary'] == 'Statically specified description'
+    assert set(inf.dynamic_metadata) == set()
+
+    # Filling reqs_by_extra when dependencies were specified but no optional
+    # dependencies was a bug.
+    assert inf.reqs_by_extra == {'.none':  ['requests >= 2.18', 'docutils']}
+
+def test_misspelled_key():
+    with pytest.raises(config.ConfigError) as e_info:
+        config.read_flit_config(samples_dir / 'misspelled-key.toml')
+
+    assert 'description-file' in str(e_info.value)
+
+def test_description_file():
+    info = config.read_flit_config(samples_dir / 'package1.toml')
+    assert info.metadata['description'] == \
+        "Sample description for test.\n"
+    assert info.metadata['description_content_type'] == 'text/x-rst'
+
+def test_missing_description_file():
+    with pytest.raises(config.ConfigError, match=r"Description file .* does not exist"):
+        config.read_flit_config(samples_dir / 'missing-description-file.toml')
+
+def test_bad_description_extension(caplog):
+    info = config.read_flit_config(samples_dir / 'bad-description-ext.toml')
+    assert info.metadata['description_content_type'] is None
+    assert any((r.levelno == logging.WARN and "Unknown extension" in r.msg)
+                for r in caplog.records)
+
+def test_extras():
+    info = config.read_flit_config(samples_dir / 'extras.toml')
+    requires_dist = set(info.metadata['requires_dist'])
+    assert requires_dist == {
+        'toml',
+        'pytest ; extra == "test"',
+        'requests ; extra == "custom"',
+    }
+    assert set(info.metadata['provides_extra']) == {'test', 'custom'}
+
+def test_extras_dev_conflict():
+    with pytest.raises(config.ConfigError, match=r'dev-requires'):
+        config.read_flit_config(samples_dir / 'extras-dev-conflict.toml')
+
+def test_extras_dev_warning(caplog):
+    info = config.read_flit_config(samples_dir / 'requires-dev.toml')
+    assert '"dev-requires = ..." is obsolete' in caplog.text
+    assert set(info.metadata['requires_dist']) == {'apackage ; extra == "dev"'}
+
+def test_requires_extra_env_marker():
+    info = config.read_flit_config(samples_dir / 'requires-extra-envmark.toml')
+    assert info.metadata['requires_dist'][0].startswith('pathlib2 ;')
+
+@pytest.mark.parametrize(('erroneous', 'match'), [
+    ({'requires-extra': None}, r'Expected a dict for requires-extra field'),
+    ({'requires-extra': dict(dev=None)}, r'Expected a dict of lists for requires-extra field'),
+    ({'requires-extra': dict(dev=[1])}, r'Expected a string list for requires-extra'),
+])
+def test_faulty_requires_extra(erroneous, match):
+    metadata = {'module': 'mymod', 'author': '', 'author-email': ''}
+    with pytest.raises(config.ConfigError, match=match):
+        config._prep_metadata(dict(metadata, **erroneous), None)
+
+@pytest.mark.parametrize(('path', 'err_match'), [
+    ('../bar', 'out of the directory'),
+    ('foo/../../bar', 'out of the directory'),
+    ('/home', 'absolute path'),
+    ('foo:bar', 'bad character'),
+])
+def test_bad_include_paths(path, err_match):
+    toml_cfg = {'tool': {'flit': {
+        'metadata': {'module': 'xyz', 'author': 'nobody'},
+        'sdist': {'include': [path]}
+    }}}
+
+    with pytest.raises(config.ConfigError, match=err_match):
+        config.prep_toml_config(toml_cfg, None)
+
+@pytest.mark.parametrize(('proj_bad', 'err_match'), [
+    ({'version': 1}, r'\bstr\b'),
+    ({'license': {'fromage': 2}}, '[Uu]nrecognised'),
+    ({'license': {'file': 'LICENSE', 'text': 'xyz'}}, 'both'),
+    ({'license': {}}, 'required'),
+    ({'keywords': 'foo'}, 'list'),
+    ({'keywords': ['foo', 7]}, 'strings'),
+    ({'entry-points': {'foo': 'module1:main'}}, 'entry-point.*tables'),
+    ({'entry-points': {'group': {'foo': 7}}}, 'entry-point.*string'),
+    ({'entry-points': {'gui_scripts': {'foo': 'a:b'}}}, r'\[project\.gui-scripts\]'),
+    ({'scripts': {'foo': 7}}, 'scripts.*string'),
+    ({'gui-scripts': {'foo': 7}}, 'gui-scripts.*string'),
+    ({'optional-dependencies': {'test': 'requests'}}, 'list.*optional-dep'),
+    ({'optional-dependencies': {'test': [7]}}, 'string.*optional-dep'),
+    ({'dynamic': ['classifiers']}, 'dynamic'),
+    ({'dynamic': ['version']}, r'dynamic.*\[project\]'),
+    ({'authors': ['thomas']}, r'author.*\bdict'),
+    ({'maintainers': [{'title': 'Dr'}]}, r'maintainer.*title'),
+])
+def test_bad_pep621_info(proj_bad, err_match):
+    proj = {'name': 'module1', 'version': '1.0', 'description': 'x'}
+    proj.update(proj_bad)
+    with pytest.raises(config.ConfigError, match=err_match):
+        config.read_pep621_metadata(proj, samples_dir / 'pep621')
+
+@pytest.mark.parametrize(('readme', 'err_match'), [
+    ({'file': 'README.rst'}, 'required'),
+    ({'file': 'README.rst', 'content-type': 'text/x-python'}, 'content-type'),
+    ('/opt/README.rst', 'relative'),
+    ({'file': 'README.rst', 'text': '', 'content-type': 'text/x-rst'}, 'both'),
+    ({'content-type': 'text/x-rst'}, 'required'),
+    ({'file': 'README.rst', 'content-type': 'text/x-rst', 'a': 'b'}, '[Uu]nrecognised'),
+    (5, r'readme.*string'),
+])
+def test_bad_pep621_readme(readme, err_match):
+    proj = {
+        'name': 'module1', 'version': '1.0', 'description': 'x', 'readme': readme
+    }
+    with pytest.raises(config.ConfigError, match=err_match):
+        config.read_pep621_metadata(proj, samples_dir / 'pep621')
diff --git a/flit_core/flit_core/tests/test_sdist.py b/flit_core/flit_core/tests/test_sdist.py
new file mode 100644
index 0000000..cffea02
--- /dev/null
+++ b/flit_core/flit_core/tests/test_sdist.py
@@ -0,0 +1,61 @@
+from io import BytesIO
+import os.path as osp
+from pathlib import Path
+import tarfile
+from testpath import assert_isfile
+
+from flit_core import sdist
+
+samples_dir = Path(__file__).parent / 'samples'
+
+def test_make_sdist(tmp_path):
+    # Smoke test of making a complete sdist
+    builder = sdist.SdistBuilder.from_ini_path(samples_dir / 'package1.toml')
+    builder.build(tmp_path)
+    assert_isfile(tmp_path / 'package1-0.1.tar.gz')
+
+
+def test_make_sdist_pep621(tmp_path):
+    builder = sdist.SdistBuilder.from_ini_path(samples_dir / 'pep621' / 'pyproject.toml')
+    path = builder.build(tmp_path)
+    assert path == tmp_path / 'module1-0.1.tar.gz'
+    assert_isfile(path)
+
+
+def test_make_sdist_pep621_nodynamic(tmp_path):
+    builder = sdist.SdistBuilder.from_ini_path(
+        samples_dir / 'pep621_nodynamic' / 'pyproject.toml'
+    )
+    path = builder.build(tmp_path)
+    assert path == tmp_path / 'module1-0.3.tar.gz'
+    assert_isfile(path)
+
+
+def test_clean_tarinfo():
+    with tarfile.open(mode='w', fileobj=BytesIO()) as tf:
+        ti = tf.gettarinfo(str(samples_dir / 'module1.py'))
+    cleaned = sdist.clean_tarinfo(ti, mtime=42)
+    assert cleaned.uid == 0
+    assert cleaned.uname == ''
+    assert cleaned.mtime == 42
+
+
+def test_include_exclude():
+    builder = sdist.SdistBuilder.from_ini_path(
+        samples_dir / 'inclusion' / 'pyproject.toml'
+    )
+    files = builder.apply_includes_excludes(builder.select_files())
+
+    assert osp.join('doc', 'test.rst') in files
+    assert osp.join('doc', 'test.txt') not in files
+    assert osp.join('doc', 'subdir', 'test.txt') in files
+    assert osp.join('doc', 'subdir', 'subsubdir', 'test.md') not in files
+
+
+def test_data_dir():
+    builder = sdist.SdistBuilder.from_ini_path(
+        samples_dir / 'with_data_dir' / 'pyproject.toml'
+    )
+    files = builder.apply_includes_excludes(builder.select_files())
+
+    assert osp.join('data', 'share', 'man', 'man1', 'foo.1') in files
diff --git a/flit_core/flit_core/tests/test_versionno.py b/flit_core/flit_core/tests/test_versionno.py
new file mode 100644
index 0000000..b02792b
--- /dev/null
+++ b/flit_core/flit_core/tests/test_versionno.py
@@ -0,0 +1,40 @@
+import pytest
+
+from flit_core.common import InvalidVersion
+from flit_core.versionno import normalise_version
+
+def test_normalise_version():
+    nv = normalise_version
+    assert nv('4.3.1') == '4.3.1'
+    assert nv('1.0b2') == '1.0b2'
+    assert nv('2!1.3') == '2!1.3'
+
+    # Prereleases
+    assert nv('1.0B2') == '1.0b2'
+    assert nv('1.0.b2') == '1.0b2'
+    assert nv('1.0beta2') == '1.0b2'
+    assert nv('1.01beta002') == '1.1b2'
+    assert nv('1.0-preview2') == '1.0rc2'
+    assert nv('1.0_c') == '1.0rc0'
+
+    # Post releases
+    assert nv('1.0post-2') == '1.0.post2'
+    assert nv('1.0post') == '1.0.post0'
+    assert nv('1.0-rev3') == '1.0.post3'
+    assert nv('1.0-2') == '1.0.post2'
+
+    # Development versions
+    assert nv('1.0dev-2') == '1.0.dev2'
+    assert nv('1.0dev') == '1.0.dev0'
+    assert nv('1.0-dev3') == '1.0.dev3'
+
+    assert nv('1.0+ubuntu-01') == '1.0+ubuntu.1'
+    assert nv('v1.3-pre2') == '1.3rc2'
+    assert nv(' 1.2.5.6\t') == '1.2.5.6'
+    assert nv('1.0-alpha3-post02+ubuntu_xenial_5') == '1.0a3.post2+ubuntu.xenial.5'
+
+    with pytest.raises(InvalidVersion):
+        nv('3!')
+
+    with pytest.raises(InvalidVersion):
+        nv('abc')
diff --git a/flit_core/flit_core/tests/test_wheel.py b/flit_core/flit_core/tests/test_wheel.py
new file mode 100644
index 0000000..310f9c6
--- /dev/null
+++ b/flit_core/flit_core/tests/test_wheel.py
@@ -0,0 +1,47 @@
+from pathlib import Path
+from zipfile import ZipFile
+
+from testpath import assert_isfile
+
+from flit_core.wheel import make_wheel_in, main
+
+samples_dir = Path(__file__).parent / 'samples'
+
+def test_licenses_dir(tmp_path):
+    # Smoketest for https://github.com/pypa/flit/issues/399
+    info = make_wheel_in(samples_dir / 'inclusion' / 'pyproject.toml', tmp_path)
+    assert_isfile(info.file)
+
+
+def test_source_date_epoch(tmp_path, monkeypatch):
+    monkeypatch.setenv('SOURCE_DATE_EPOCH', '1633007882')
+    info = make_wheel_in(samples_dir / 'pep621' / 'pyproject.toml', tmp_path)
+    assert_isfile(info.file)
+    # Minimum value for zip timestamps is 1980-1-1
+    with ZipFile(info.file, 'r') as zf:
+        assert zf.getinfo('module1a.py').date_time[:3] == (2021, 9, 30)
+
+
+def test_zero_timestamp(tmp_path, monkeypatch):
+    monkeypatch.setenv('SOURCE_DATE_EPOCH', '0')
+    info = make_wheel_in(samples_dir / 'pep621' / 'pyproject.toml', tmp_path)
+    assert_isfile(info.file)
+    # Minimum value for zip timestamps is 1980-1-1
+    with ZipFile(info.file, 'r') as zf:
+        assert zf.getinfo('module1a.py').date_time == (1980, 1, 1, 0, 0, 0)
+
+
+def test_main(tmp_path):
+    main(['--outdir', str(tmp_path), str(samples_dir / 'pep621')])
+    wheels = list(tmp_path.glob('*.whl'))
+    assert len(wheels) == 1
+    # Minimum value for zip timestamps is 1980-1-1
+    with ZipFile(wheels[0], 'r') as zf:
+        assert 'module1a.py' in zf.namelist()
+
+        
+def test_data_dir(tmp_path):
+    info = make_wheel_in(samples_dir / 'with_data_dir' / 'pyproject.toml', tmp_path)
+    assert_isfile(info.file)
+    with ZipFile(info.file, 'r') as zf:
+        assert 'module1-0.1.data/data/share/man/man1/foo.1' in zf.namelist()
diff --git a/flit_core/flit_core/vendor/README b/flit_core/flit_core/vendor/README
new file mode 100644
index 0000000..32e1b00
--- /dev/null
+++ b/flit_core/flit_core/vendor/README
@@ -0,0 +1,13 @@
+flit_core bundles the 'tomli' TOML parser, to avoid a bootstrapping problem.
+tomli is packaged using Flit, so there would be a dependency cycle when building
+from source. Vendoring a copy of tomli avoids this. The code in tomli is under
+the MIT license, and the LICENSE file is in the .dist-info folder.
+
+If you want to unbundle tomli and rely on it as a separate package, you can
+replace the package with Python code doing 'from tomli import *'. You will
+probably need to work around the dependency cycle between flit_core and tomli.
+
+Bundling a TOML parser should be a special case - I don't plan on bundling
+anything else in flit_core (or depending on any other packages).
+I hope that a TOML parser will be added to the Python standard library, and then
+this bundled parser will go away.
diff --git a/flit_core/flit_core/vendor/__init__.py b/flit_core/flit_core/vendor/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/flit_core/flit_core/vendor/__init__.py
diff --git a/flit_core/flit_core/vendor/tomli-1.2.3.dist-info/LICENSE b/flit_core/flit_core/vendor/tomli-1.2.3.dist-info/LICENSE
new file mode 100644
index 0000000..e859590
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli-1.2.3.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Taneli Hukkinen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/flit_core/flit_core/vendor/tomli-1.2.3.dist-info/METADATA b/flit_core/flit_core/vendor/tomli-1.2.3.dist-info/METADATA
new file mode 100644
index 0000000..0ddc586
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli-1.2.3.dist-info/METADATA
@@ -0,0 +1,208 @@
+Metadata-Version: 2.1
+Name: tomli
+Version: 1.2.3
+Summary: A lil' TOML parser
+Keywords: toml
+Author-email: Taneli Hukkinen <hukkin@users.noreply.github.com>
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Changelog, https://github.com/hukkin/tomli/blob/master/CHANGELOG.md
+Project-URL: Homepage, https://github.com/hukkin/tomli
+
+[![Build Status](https://github.com/hukkin/tomli/workflows/Tests/badge.svg?branch=master)](https://github.com/hukkin/tomli/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
+[![codecov.io](https://codecov.io/gh/hukkin/tomli/branch/master/graph/badge.svg)](https://codecov.io/gh/hukkin/tomli)
+[![PyPI version](https://img.shields.io/pypi/v/tomli)](https://pypi.org/project/tomli)
+
+# Tomli
+
+> A lil' TOML parser
+
+**Table of Contents**  *generated with [mdformat-toc](https://github.com/hukkin/mdformat-toc)*
+
+<!-- mdformat-toc start --slug=github --maxlevel=6 --minlevel=2 -->
+
+- [Intro](#intro)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Parse a TOML string](#parse-a-toml-string)
+  - [Parse a TOML file](#parse-a-toml-file)
+  - [Handle invalid TOML](#handle-invalid-toml)
+  - [Construct `decimal.Decimal`s from TOML floats](#construct-decimaldecimals-from-toml-floats)
+- [FAQ](#faq)
+  - [Why this parser?](#why-this-parser)
+  - [Is comment preserving round-trip parsing supported?](#is-comment-preserving-round-trip-parsing-supported)
+  - [Is there a `dumps`, `write` or `encode` function?](#is-there-a-dumps-write-or-encode-function)
+  - [How do TOML types map into Python types?](#how-do-toml-types-map-into-python-types)
+- [Performance](#performance)
+
+<!-- mdformat-toc end -->
+
+## Intro<a name="intro"></a>
+
+Tomli is a Python library for parsing [TOML](https://toml.io).
+Tomli is fully compatible with [TOML v1.0.0](https://toml.io/en/v1.0.0).
+
+## Installation<a name="installation"></a>
+
+```bash
+pip install tomli
+```
+
+## Usage<a name="usage"></a>
+
+### Parse a TOML string<a name="parse-a-toml-string"></a>
+
+```python
+import tomli
+
+toml_str = """
+           gretzky = 99
+
+           [kurri]
+           jari = 17
+           """
+
+toml_dict = tomli.loads(toml_str)
+assert toml_dict == {"gretzky": 99, "kurri": {"jari": 17}}
+```
+
+### Parse a TOML file<a name="parse-a-toml-file"></a>
+
+```python
+import tomli
+
+with open("path_to_file/conf.toml", "rb") as f:
+    toml_dict = tomli.load(f)
+```
+
+The file must be opened in binary mode (with the `"rb"` flag).
+Binary mode will enforce decoding the file as UTF-8 with universal newlines disabled,
+both of which are required to correctly parse TOML.
+Support for text file objects is deprecated for removal in the next major release.
+
+### Handle invalid TOML<a name="handle-invalid-toml"></a>
+
+```python
+import tomli
+
+try:
+    toml_dict = tomli.loads("]] this is invalid TOML [[")
+except tomli.TOMLDecodeError:
+    print("Yep, definitely not valid.")
+```
+
+Note that while the `TOMLDecodeError` type is public API, error messages of raised instances of it are not.
+Error messages should not be assumed to stay constant across Tomli versions.
+
+### Construct `decimal.Decimal`s from TOML floats<a name="construct-decimaldecimals-from-toml-floats"></a>
+
+```python
+from decimal import Decimal
+import tomli
+
+toml_dict = tomli.loads("precision-matters = 0.982492", parse_float=Decimal)
+assert toml_dict["precision-matters"] == Decimal("0.982492")
+```
+
+Note that `decimal.Decimal` can be replaced with another callable that converts a TOML float from string to a Python type.
+The `decimal.Decimal` is, however, a practical choice for use cases where float inaccuracies can not be tolerated.
+
+Illegal types include `dict`, `list`, and anything that has the `append` attribute.
+Parsing floats into an illegal type results in undefined behavior.
+
+## FAQ<a name="faq"></a>
+
+### Why this parser?<a name="why-this-parser"></a>
+
+- it's lil'
+- pure Python with zero dependencies
+- the fastest pure Python parser [\*](#performance):
+  15x as fast as [tomlkit](https://pypi.org/project/tomlkit/),
+  2.4x as fast as [toml](https://pypi.org/project/toml/)
+- outputs [basic data types](#how-do-toml-types-map-into-python-types) only
+- 100% spec compliant: passes all tests in
+  [a test set](https://github.com/toml-lang/compliance/pull/8)
+  soon to be merged to the official
+  [compliance tests for TOML](https://github.com/toml-lang/compliance)
+  repository
+- thoroughly tested: 100% branch coverage
+
+### Is comment preserving round-trip parsing supported?<a name="is-comment-preserving-round-trip-parsing-supported"></a>
+
+No.
+
+The `tomli.loads` function returns a plain `dict` that is populated with builtin types and types from the standard library only.
+Preserving comments requires a custom type to be returned so will not be supported,
+at least not by the `tomli.loads` and `tomli.load` functions.
+
+Look into [TOML Kit](https://github.com/sdispater/tomlkit) if preservation of style is what you need.
+
+### Is there a `dumps`, `write` or `encode` function?<a name="is-there-a-dumps-write-or-encode-function"></a>
+
+[Tomli-W](https://github.com/hukkin/tomli-w) is the write-only counterpart of Tomli, providing `dump` and `dumps` functions.
+
+The core library does not include write capability, as most TOML use cases are read-only, and Tomli intends to be minimal.
+
+### How do TOML types map into Python types?<a name="how-do-toml-types-map-into-python-types"></a>
+
+| TOML type        | Python type         | Details                                                      |
+| ---------------- | ------------------- | ------------------------------------------------------------ |
+| Document Root    | `dict`              |                                                              |
+| Key              | `str`               |                                                              |
+| String           | `str`               |                                                              |
+| Integer          | `int`               |                                                              |
+| Float            | `float`             |                                                              |
+| Boolean          | `bool`              |                                                              |
+| Offset Date-Time | `datetime.datetime` | `tzinfo` attribute set to an instance of `datetime.timezone` |
+| Local Date-Time  | `datetime.datetime` | `tzinfo` attribute set to `None`                             |
+| Local Date       | `datetime.date`     |                                                              |
+| Local Time       | `datetime.time`     |                                                              |
+| Array            | `list`              |                                                              |
+| Table            | `dict`              |                                                              |
+| Inline Table     | `dict`              |                                                              |
+
+## Performance<a name="performance"></a>
+
+The `benchmark/` folder in this repository contains a performance benchmark for comparing the various Python TOML parsers.
+The benchmark can be run with `tox -e benchmark-pypi`.
+Running the benchmark on my personal computer output the following:
+
+```console
+foo@bar:~/dev/tomli$ tox -e benchmark-pypi
+benchmark-pypi installed: attrs==19.3.0,click==7.1.2,pytomlpp==1.0.2,qtoml==0.3.0,rtoml==0.7.0,toml==0.10.2,tomli==1.1.0,tomlkit==0.7.2
+benchmark-pypi run-test-pre: PYTHONHASHSEED='2658546909'
+benchmark-pypi run-test: commands[0] | python -c 'import datetime; print(datetime.date.today())'
+2021-07-23
+benchmark-pypi run-test: commands[1] | python --version
+Python 3.8.10
+benchmark-pypi run-test: commands[2] | python benchmark/run.py
+Parsing data.toml 5000 times:
+------------------------------------------------------
+    parser |  exec time | performance (more is better)
+-----------+------------+-----------------------------
+     rtoml |    0.901 s | baseline (100%)
+  pytomlpp |     1.08 s | 83.15%
+     tomli |     3.89 s | 23.15%
+      toml |     9.36 s | 9.63%
+     qtoml |     11.5 s | 7.82%
+   tomlkit |     56.8 s | 1.59%
+```
+
+The parsers are ordered from fastest to slowest, using the fastest parser as baseline.
+Tomli performed the best out of all pure Python TOML parsers,
+losing only to pytomlpp (wraps C++) and rtoml (wraps Rust).
+
diff --git a/flit_core/flit_core/vendor/tomli/__init__.py b/flit_core/flit_core/vendor/tomli/__init__.py
new file mode 100644
index 0000000..8597467
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli/__init__.py
@@ -0,0 +1,9 @@
+"""A lil' TOML parser."""
+
+__all__ = ("loads", "load", "TOMLDecodeError")
+__version__ = "1.2.3"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT
+
+from ._parser import TOMLDecodeError, load, loads
+
+# Pretend this exception was created here.
+TOMLDecodeError.__module__ = "tomli"
diff --git a/flit_core/flit_core/vendor/tomli/_parser.py b/flit_core/flit_core/vendor/tomli/_parser.py
new file mode 100644
index 0000000..093afe5
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli/_parser.py
@@ -0,0 +1,663 @@
+import string
+from types import MappingProxyType
+from typing import Any, BinaryIO, Dict, FrozenSet, Iterable, NamedTuple, Optional, Tuple
+import warnings
+
+from ._re import (
+    RE_DATETIME,
+    RE_LOCALTIME,
+    RE_NUMBER,
+    match_to_datetime,
+    match_to_localtime,
+    match_to_number,
+)
+from ._types import Key, ParseFloat, Pos
+
+ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+
+# Neither of these sets include quotation mark or backslash. They are
+# currently handled as separate cases in the parser functions.
+ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")
+ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n")
+
+ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS
+ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+
+ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS
+
+TOML_WS = frozenset(" \t")
+TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")
+BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")
+KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")
+HEXDIGIT_CHARS = frozenset(string.hexdigits)
+
+BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType(
+    {
+        "\\b": "\u0008",  # backspace
+        "\\t": "\u0009",  # tab
+        "\\n": "\u000A",  # linefeed
+        "\\f": "\u000C",  # form feed
+        "\\r": "\u000D",  # carriage return
+        '\\"': "\u0022",  # quote
+        "\\\\": "\u005C",  # backslash
+    }
+)
+
+
+class TOMLDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
+
+
+def load(fp: BinaryIO, *, parse_float: ParseFloat = float) -> Dict[str, Any]:
+    """Parse TOML from a binary file object."""
+    s_bytes = fp.read()
+    try:
+        s = s_bytes.decode()
+    except AttributeError:
+        warnings.warn(
+            "Text file object support is deprecated in favor of binary file objects."
+            ' Use `open("foo.toml", "rb")` to open the file in binary mode.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        s = s_bytes  # type: ignore[assignment]
+    return loads(s, parse_float=parse_float)
+
+
+def loads(s: str, *, parse_float: ParseFloat = float) -> Dict[str, Any]:  # noqa: C901
+    """Parse TOML from a string."""
+
+    # The spec allows converting "\r\n" to "\n", even in string
+    # literals. Let's do so to simplify parsing.
+    src = s.replace("\r\n", "\n")
+    pos = 0
+    out = Output(NestedDict(), Flags())
+    header: Key = ()
+
+    # Parse one statement at a time
+    # (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = skip_chars(src, pos, TOML_WS)
+
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == "\n":
+            pos += 1
+            continue
+        if char in KEY_INITIAL_CHARS:
+            pos = key_value_rule(src, pos, out, header, parse_float)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char == "[":
+            try:
+                second_char: Optional[str] = src[pos + 1]
+            except IndexError:
+                second_char = None
+            if second_char == "[":
+                pos, header = create_list_rule(src, pos, out)
+            else:
+                pos, header = create_dict_rule(src, pos, out)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char != "#":
+            raise suffixed_err(src, pos, "Invalid statement")
+
+        # 3. Skip comment
+        pos = skip_comment(src, pos)
+
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != "\n":
+            raise suffixed_err(
+                src, pos, "Expected newline or end of document after a statement"
+            )
+        pos += 1
+
+    return out.data.dict
+
+
+class Flags:
+    """Flags that map to parsed keys/namespaces."""
+
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN = 0
+    # Marks a nest that has been explicitly created and can no longer
+    # be opened using the "[table]" syntax.
+    EXPLICIT_NEST = 1
+
+    def __init__(self) -> None:
+        self._flags: Dict[str, dict] = {}
+
+    def unset_all(self, key: Key) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]["nested"]
+        cont.pop(key[-1], None)
+
+    def set_for_relative_key(self, head_key: Key, rel_key: Key, flag: int) -> None:
+        cont = self._flags
+        for k in head_key:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        for k in rel_key:
+            if k in cont:
+                cont[k]["flags"].add(flag)
+            else:
+                cont[k] = {"flags": {flag}, "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+
+    def set(self, key: Key, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        if key_stem not in cont:
+            cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+        cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag)
+
+    def is_(self, key: Key, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont["recursive_flags"]:
+                return True
+            cont = inner_cont["nested"]
+        key_stem = key[-1]
+        if key_stem in cont:
+            cont = cont[key_stem]
+            return flag in cont["flags"] or flag in cont["recursive_flags"]
+        return False
+
+
+class NestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: Dict[str, Any] = {}
+
+    def get_or_create_nest(
+        self,
+        key: Key,
+        *,
+        access_lists: bool = True,
+    ) -> dict:
+        cont: Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError("There is no nest behind this key")
+        return cont
+
+    def append_nest_to_list(self, key: Key) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            try:
+                list_.append({})
+            except AttributeError:
+                raise KeyError("An object other than list found behind this key")
+        else:
+            cont[last_key] = [{}]
+
+
+class Output(NamedTuple):
+    data: NestedDict
+    flags: Flags
+
+
+def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
+
+
+def skip_until(
+    src: str,
+    pos: Pos,
+    expect: str,
+    *,
+    error_on: FrozenSet[str],
+    error_on_eof: bool,
+) -> Pos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None
+
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}")
+    return new_pos
+
+
+def skip_comment(src: str, pos: Pos) -> Pos:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char == "#":
+        return skip_until(
+            src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False
+        )
+    return pos
+
+
+def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
+    while True:
+        pos_before_skip = pos
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def create_dict_rule(src: str, pos: Pos, out: Output) -> Tuple[Pos, Key]:
+    pos += 1  # Skip "["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not declare {key} twice")
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value") from None
+
+    if not src.startswith("]", pos):
+        raise suffixed_err(src, pos, 'Expected "]" at the end of a table declaration')
+    return pos + 1, key
+
+
+def create_list_rule(src: str, pos: Pos, out: Output) -> Tuple[Pos, Key]:
+    pos += 2  # Skip "[["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not mutate immutable namespace {key}")
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value") from None
+
+    if not src.startswith("]]", pos):
+        raise suffixed_err(src, pos, 'Expected "]]" at the end of an array declaration')
+    return pos + 2, key
+
+
+def key_value_rule(
+    src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat
+) -> Pos:
+    pos, key, value = parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    if out.flags.is_(abs_key_parent, Flags.FROZEN):
+        raise suffixed_err(
+            src, pos, f"Can not mutate immutable namespace {abs_key_parent}"
+        )
+    # Containers in the relative path can't be opened with the table syntax after this
+    out.flags.set_for_relative_key(header, key, Flags.EXPLICIT_NEST)
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value") from None
+    if key_stem in nest:
+        raise suffixed_err(src, pos, "Can not overwrite a value")
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, Flags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def parse_key_value_pair(
+    src: str, pos: Pos, parse_float: ParseFloat
+) -> Tuple[Pos, Key, Any]:
+    pos, key = parse_key(src, pos)
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != "=":
+        raise suffixed_err(src, pos, 'Expected "=" after a key in a key/value pair')
+    pos += 1
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, value = parse_value(src, pos, parse_float)
+    return pos, key, value
+
+
+def parse_key(src: str, pos: Pos) -> Tuple[Pos, Key]:
+    pos, key_part = parse_key_part(src, pos)
+    key: Key = (key_part,)
+    pos = skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != ".":
+            return pos, key
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+        pos, key_part = parse_key_part(src, pos)
+        key += (key_part,)
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_key_part(src: str, pos: Pos) -> Tuple[Pos, str]:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in BARE_KEY_CHARS:
+        start_pos = pos
+        pos = skip_chars(src, pos, BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return parse_literal_str(src, pos)
+    if char == '"':
+        return parse_one_line_basic_str(src, pos)
+    raise suffixed_err(src, pos, "Invalid initial character for a key part")
+
+
+def parse_one_line_basic_str(src: str, pos: Pos) -> Tuple[Pos, str]:
+    pos += 1
+    return parse_basic_str(src, pos, multiline=False)
+
+
+def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, list]:
+    pos += 1
+    array: list = []
+
+    pos = skip_comments_and_array_ws(src, pos)
+    if src.startswith("]", pos):
+        return pos + 1, array
+    while True:
+        pos, val = parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = skip_comments_and_array_ws(src, pos)
+
+        c = src[pos : pos + 1]
+        if c == "]":
+            return pos + 1, array
+        if c != ",":
+            raise suffixed_err(src, pos, "Unclosed array")
+        pos += 1
+
+        pos = skip_comments_and_array_ws(src, pos)
+        if src.startswith("]", pos):
+            return pos + 1, array
+
+
+def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, dict]:
+    pos += 1
+    nested_dict = NestedDict()
+    flags = Flags()
+
+    pos = skip_chars(src, pos, TOML_WS)
+    if src.startswith("}", pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, Flags.FROZEN):
+            raise suffixed_err(src, pos, f"Can not mutate immutable namespace {key}")
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise suffixed_err(src, pos, "Can not overwrite a value") from None
+        if key_stem in nest:
+            raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}")
+        nest[key_stem] = value
+        pos = skip_chars(src, pos, TOML_WS)
+        c = src[pos : pos + 1]
+        if c == "}":
+            return pos + 1, nested_dict.dict
+        if c != ",":
+            raise suffixed_err(src, pos, "Unclosed inline table")
+        if isinstance(value, (dict, list)):
+            flags.set(key, Flags.FROZEN, recursive=True)
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_basic_str_escape(  # noqa: C901
+    src: str, pos: Pos, *, multiline: bool = False
+) -> Tuple[Pos, str]:
+    escape_id = src[pos : pos + 2]
+    pos += 2
+    if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
+        # Skip whitespace until next non-whitespace character or end of
+        # the doc. Error if non-whitespace is found before newline.
+        if escape_id != "\\\n":
+            pos = skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ""
+            if char != "\n":
+                raise suffixed_err(src, pos, 'Unescaped "\\" in a string')
+            pos += 1
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ""
+    if escape_id == "\\u":
+        return parse_hex_char(src, pos, 4)
+    if escape_id == "\\U":
+        return parse_hex_char(src, pos, 8)
+    try:
+        return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        if len(escape_id) != 2:
+            raise suffixed_err(src, pos, "Unterminated string") from None
+        raise suffixed_err(src, pos, 'Unescaped "\\" in a string') from None
+
+
+def parse_basic_str_escape_multiline(src: str, pos: Pos) -> Tuple[Pos, str]:
+    return parse_basic_str_escape(src, pos, multiline=True)
+
+
+def parse_hex_char(src: str, pos: Pos, hex_len: int) -> Tuple[Pos, str]:
+    hex_str = src[pos : pos + hex_len]
+    if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
+        raise suffixed_err(src, pos, "Invalid hex value")
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not is_unicode_scalar_value(hex_int):
+        raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
+    return pos, chr(hex_int)
+
+
+def parse_literal_str(src: str, pos: Pos) -> Tuple[Pos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = skip_until(
+        src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
+
+
+def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> Tuple[Pos, str]:
+    pos += 3
+    if src.startswith("\n", pos):
+        pos += 1
+
+    if literal:
+        delim = "'"
+        end_pos = skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = parse_basic_str(src, pos, multiline=True)
+
+    # Add at maximum two extra apostrophes/quotes if the end sequence
+    # is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
+
+
+def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> Tuple[Pos, str]:
+    if multiline:
+        error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape_multiline
+    else:
+        error_on = ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape
+    result = ""
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise suffixed_err(src, pos, "Unterminated string") from None
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == "\\":
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise suffixed_err(src, pos, f"Illegal character {char!r}")
+        pos += 1
+
+
+def parse_value(  # noqa: C901
+    src: str, pos: Pos, parse_float: ParseFloat
+) -> Tuple[Pos, Any]:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return parse_multiline_str(src, pos, literal=False)
+        return parse_one_line_basic_str(src, pos)
+
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return parse_multiline_str(src, pos, literal=True)
+        return parse_literal_str(src, pos)
+
+    # Booleans
+    if char == "t":
+        if src.startswith("true", pos):
+            return pos + 4, True
+    if char == "f":
+        if src.startswith("false", pos):
+            return pos + 5, False
+
+    # Dates and times
+    datetime_match = RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = match_to_datetime(datetime_match)
+        except ValueError as e:
+            raise suffixed_err(src, pos, "Invalid date or datetime") from e
+        return datetime_match.end(), datetime_obj
+    localtime_match = RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), match_to_localtime(localtime_match)
+
+    # Integers and "normal" floats.
+    # The regex will greedily match any type starting with a decimal
+    # char, so needs to be located after handling of dates and times.
+    number_match = RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), match_to_number(number_match, parse_float)
+
+    # Arrays
+    if char == "[":
+        return parse_array(src, pos, parse_float)
+
+    # Inline tables
+    if char == "{":
+        return parse_inline_table(src, pos, parse_float)
+
+    # Special floats
+    first_three = src[pos : pos + 3]
+    if first_three in {"inf", "nan"}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos : pos + 4]
+    if first_four in {"-inf", "+inf", "-nan", "+nan"}:
+        return pos + 4, parse_float(first_four)
+
+    raise suffixed_err(src, pos, "Invalid value")
+
+
+def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
+    """Return a `TOMLDecodeError` where error message is suffixed with
+    coordinates in source."""
+
+    def coord_repr(src: str, pos: Pos) -> str:
+        if pos >= len(src):
+            return "end of document"
+        line = src.count("\n", 0, pos) + 1
+        if line == 1:
+            column = pos + 1
+        else:
+            column = pos - src.rindex("\n", 0, pos)
+        return f"line {line}, column {column}"
+
+    return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")
+
+
+def is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
diff --git a/flit_core/flit_core/vendor/tomli/_re.py b/flit_core/flit_core/vendor/tomli/_re.py
new file mode 100644
index 0000000..45e17e2
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli/_re.py
@@ -0,0 +1,101 @@
+from datetime import date, datetime, time, timedelta, timezone, tzinfo
+from functools import lru_cache
+import re
+from typing import Any, Optional, Union
+
+from ._types import ParseFloat
+
+# E.g.
+# - 00:32:00.999999
+# - 00:32:00
+_TIME_RE_STR = r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?"
+
+RE_NUMBER = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P<floatpart>
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+RE_LOCALTIME = re.compile(_TIME_RE_STR)
+RE_DATETIME = re.compile(
+    fr"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [Tt ]
+    {_TIME_RE_STR}
+    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
+
+
+def match_to_datetime(match: "re.Match") -> Union[datetime, date]:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+
+    Raises ValueError if the match does not correspond to a valid date
+    or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return date(year, month, day)
+    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    if offset_sign_str:
+        tz: Optional[tzinfo] = cached_tz(
+            offset_hour_str, offset_minute_str, offset_sign_str
+        )
+    elif zulu_time:
+        tz = timezone.utc
+    else:  # local date-time
+        tz = None
+    return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+
+
+@lru_cache(maxsize=None)
+def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
+    sign = 1 if sign_str == "+" else -1
+    return timezone(
+        timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        )
+    )
+
+
+def match_to_localtime(match: "re.Match") -> time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    return time(int(hour_str), int(minute_str), int(sec_str), micros)
+
+
+def match_to_number(match: "re.Match", parse_float: "ParseFloat") -> Any:
+    if match.group("floatpart"):
+        return parse_float(match.group())
+    return int(match.group(), 0)
diff --git a/flit_core/flit_core/vendor/tomli/_types.py b/flit_core/flit_core/vendor/tomli/_types.py
new file mode 100644
index 0000000..e37cc80
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli/_types.py
@@ -0,0 +1,6 @@
+from typing import Any, Callable, Tuple
+
+# Type annotations
+ParseFloat = Callable[[str], Any]
+Key = Tuple[str, ...]
+Pos = int
diff --git a/flit_core/flit_core/vendor/tomli/py.typed b/flit_core/flit_core/vendor/tomli/py.typed
new file mode 100644
index 0000000..7632ecf
--- /dev/null
+++ b/flit_core/flit_core/vendor/tomli/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561
diff --git a/flit_core/flit_core/versionno.py b/flit_core/flit_core/versionno.py
new file mode 100644
index 0000000..eed1a5b
--- /dev/null
+++ b/flit_core/flit_core/versionno.py
@@ -0,0 +1,127 @@
+"""Normalise version number according to PEP 440"""
+import logging
+import os
+import re
+
+log = logging.getLogger(__name__)
+
+# Regex below from packaging, via PEP 440. BSD License:
+# Copyright (c) Donald Stufft and individual contributors.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     1. Redistributions of source code must retain the above copyright notice,
+#        this list of conditions and the following disclaimer.
+#
+#     2. Redistributions in binary form must reproduce the above copyright
+#        notice, this list of conditions and the following disclaimer in the
+#        documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+VERSION_PERMISSIVE = re.compile(r"""
+    \s*v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+\s*$""", re.VERBOSE)
+
+pre_spellings = {
+    'a': 'a', 'alpha': 'a',
+    'b': 'b', 'beta': 'b',
+    'rc': 'rc', 'c': 'rc', 'pre': 'rc', 'preview': 'rc',
+}
+
+def normalise_version(orig_version):
+    """Normalise version number according to rules in PEP 440
+
+    Raises InvalidVersion if the version does not match PEP 440. This can be
+    overridden with the FLIT_ALLOW_INVALID environment variable.
+
+    https://www.python.org/dev/peps/pep-0440/#normalization
+    """
+    version = orig_version.lower()
+    m = VERSION_PERMISSIVE.match(version)
+    if not m:
+        if os.environ.get('FLIT_ALLOW_INVALID'):
+            log.warning("Invalid version number {!r} allowed by FLIT_ALLOW_INVALID"
+                        .format(orig_version))
+            return version
+        else:
+            from .common import InvalidVersion
+            raise InvalidVersion("Version number {!r} does not match PEP 440 rules"
+                                 .format(orig_version))
+
+    components = []
+    add = components.append
+
+    epoch, release = m.group('epoch', 'release')
+    if epoch is not None:
+        add(str(int(epoch)) + '!')
+    add('.'.join(str(int(rp)) for rp in release.split('.')))
+
+    pre_l, pre_n = m.group('pre_l', 'pre_n')
+    if pre_l is not None:
+        pre_l = pre_spellings[pre_l]
+        pre_n = '0' if pre_n is None else str(int(pre_n))
+        add(pre_l + pre_n)
+
+    post_n1, post_l, post_n2 = m.group('post_n1', 'post_l', 'post_n2')
+    if post_n1 is not None:
+        add('.post' + str(int(post_n1)))
+    elif post_l is not None:
+        post_n = '0' if post_n2 is None else str(int(post_n2))
+        add('.post' + str(int(post_n)))
+
+    dev_l, dev_n = m.group('dev_l', 'dev_n')
+    if dev_l is not None:
+        dev_n = '0' if dev_n is None else str(int(dev_n))
+        add('.dev' + dev_n)
+
+    local = m.group('local')
+    if local is not None:
+        local = local.replace('-', '.').replace('_', '.')
+        l = [str(int(c)) if c.isdigit() else c
+             for c in local.split('.')]
+        add('+' + '.'.join(l))
+
+    version = ''.join(components)
+    if version != orig_version:
+        log.warning("Version number normalised: {!r} -> {!r} (see PEP 440)"
+                    .format(orig_version, version))
+    return version
+
diff --git a/flit_core/flit_core/wheel.py b/flit_core/flit_core/wheel.py
new file mode 100644
index 0000000..08cb70a
--- /dev/null
+++ b/flit_core/flit_core/wheel.py
@@ -0,0 +1,259 @@
+import argparse
+from base64 import urlsafe_b64encode
+import contextlib
+from datetime import datetime
+import hashlib
+import io
+import logging
+import os
+import os.path as osp
+import stat
+import tempfile
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Optional
+import zipfile
+
+from flit_core import __version__
+from . import common
+
+log = logging.getLogger(__name__)
+
+wheel_file_template = u"""\
+Wheel-Version: 1.0
+Generator: flit {version}
+Root-Is-Purelib: true
+""".format(version=__version__)
+
+def _write_wheel_file(f, supports_py2=False):
+    f.write(wheel_file_template)
+    if supports_py2:
+        f.write(u"Tag: py2-none-any\n")
+    f.write(u"Tag: py3-none-any\n")
+
+
+def _set_zinfo_mode(zinfo, mode):
+    # Set the bits for the mode and bit 0xFFFF for “regular file”
+    zinfo.external_attr = mode << 16
+
+
+def zip_timestamp_from_env() -> Optional[tuple]:
+    """Prepare a timestamp from $SOURCE_DATE_EPOCH, if set"""
+    try:
+        # If SOURCE_DATE_EPOCH is set (e.g. by Debian), it's used for
+        # timestamps inside the zip file.
+        d = datetime.utcfromtimestamp(int(os.environ['SOURCE_DATE_EPOCH']))
+    except (KeyError, ValueError):
+        # Otherwise, we'll use the mtime of files, and generated files will
+        # default to 2016-1-1 00:00:00
+        return None
+
+    if d.year >= 1980:
+        log.info("Zip timestamps will be from SOURCE_DATE_EPOCH: %s", d)
+        # zipfile expects a 6-tuple, not a datetime object
+        return d.year, d.month, d.day, d.hour, d.minute, d.second
+    else:
+        log.info("SOURCE_DATE_EPOCH is below the minimum for zip file timestamps")
+        log.info("Zip timestamps will be 1980-01-01 00:00:00")
+        return 1980, 1, 1, 0, 0, 0
+
+
+class WheelBuilder:
+    def __init__(
+            self, directory, module, metadata, entrypoints, target_fp, data_directory
+    ):
+        """Build a wheel from a module/package
+        """
+        self.directory = directory
+        self.module = module
+        self.metadata = metadata
+        self.entrypoints = entrypoints
+        self.data_directory = data_directory
+
+        self.records = []
+        self.source_time_stamp = zip_timestamp_from_env()
+
+        # Open the zip file ready to write
+        self.wheel_zip = zipfile.ZipFile(target_fp, 'w',
+                             compression=zipfile.ZIP_DEFLATED)
+
+    @classmethod
+    def from_ini_path(cls, ini_path, target_fp):
+        from .config import read_flit_config
+        directory = ini_path.parent
+        ini_info = read_flit_config(ini_path)
+        entrypoints = ini_info.entrypoints
+        module = common.Module(ini_info.module, directory)
+        metadata = common.make_metadata(module, ini_info)
+        return cls(
+            directory, module, metadata, entrypoints, target_fp, ini_info.data_directory
+        )
+
+    @property
+    def dist_info(self):
+        return common.dist_info_name(self.metadata.name, self.metadata.version)
+
+    @property
+    def wheel_filename(self):
+        dist_name = common.normalize_dist_name(self.metadata.name, self.metadata.version)
+        tag = ('py2.' if self.metadata.supports_py2 else '') + 'py3-none-any'
+        return '{}-{}.whl'.format(dist_name, tag)
+
+    def _add_file(self, full_path, rel_path):
+        log.debug("Adding %s to zip file", full_path)
+        full_path, rel_path = str(full_path), str(rel_path)
+        if os.sep != '/':
+            # We always want to have /-separated paths in the zip file and in
+            # RECORD
+            rel_path = rel_path.replace(os.sep, '/')
+
+        if self.source_time_stamp is None:
+            zinfo = zipfile.ZipInfo.from_file(full_path, rel_path)
+        else:
+            # Set timestamps in zipfile for reproducible build
+            zinfo = zipfile.ZipInfo(rel_path, self.source_time_stamp)
+
+        # Normalize permission bits to either 755 (executable) or 644
+        st_mode = os.stat(full_path).st_mode
+        new_mode = common.normalize_file_permissions(st_mode)
+        _set_zinfo_mode(zinfo, new_mode & 0xFFFF)  # Unix attributes
+
+        if stat.S_ISDIR(st_mode):
+            zinfo.external_attr |= 0x10  # MS-DOS directory flag
+
+        zinfo.compress_type = zipfile.ZIP_DEFLATED
+
+        hashsum = hashlib.sha256()
+        with open(full_path, 'rb') as src, self.wheel_zip.open(zinfo, 'w') as dst:
+            while True:
+                buf = src.read(1024 * 8)
+                if not buf:
+                    break
+                hashsum.update(buf)
+                dst.write(buf)
+
+        size = os.stat(full_path).st_size
+        hash_digest = urlsafe_b64encode(hashsum.digest()).decode('ascii').rstrip('=')
+        self.records.append((rel_path, hash_digest, size))
+
+    @contextlib.contextmanager
+    def _write_to_zip(self, rel_path, mode=0o644):
+        sio = io.StringIO()
+        yield sio
+
+        log.debug("Writing data to %s in zip file", rel_path)
+        # The default is a fixed timestamp rather than the current time, so
+        # that building a wheel twice on the same computer can automatically
+        # give you the exact same result.
+        date_time = self.source_time_stamp or (2016, 1, 1, 0, 0, 0)
+        zi = zipfile.ZipInfo(rel_path, date_time)
+        _set_zinfo_mode(zi, mode)
+        b = sio.getvalue().encode('utf-8')
+        hashsum = hashlib.sha256(b)
+        hash_digest = urlsafe_b64encode(hashsum.digest()).decode('ascii').rstrip('=')
+        self.wheel_zip.writestr(zi, b, compress_type=zipfile.ZIP_DEFLATED)
+        self.records.append((rel_path, hash_digest, len(b)))
+
+    def copy_module(self):
+        log.info('Copying package file(s) from %s', self.module.path)
+        source_dir = str(self.module.source_dir)
+
+        for full_path in self.module.iter_files():
+            rel_path = osp.relpath(full_path, source_dir)
+            self._add_file(full_path, rel_path)
+
+    def add_pth(self):
+        with self._write_to_zip(self.module.name + ".pth") as f:
+            f.write(str(self.module.source_dir.resolve()))
+
+    def add_data_directory(self):
+        dir_in_whl = '{}.data/data/'.format(
+            common.normalize_dist_name(self.metadata.name, self.metadata.version)
+        )
+        for full_path in common.walk_data_dir(self.data_directory):
+            rel_path = os.path.relpath(full_path, self.data_directory)
+            self._add_file(full_path, dir_in_whl + rel_path)
+
+    def write_metadata(self):
+        log.info('Writing metadata files')
+
+        if self.entrypoints:
+            with self._write_to_zip(self.dist_info + '/entry_points.txt') as f:
+                common.write_entry_points(self.entrypoints, f)
+
+        for base in ('COPYING', 'LICENSE'):
+            for path in sorted(self.directory.glob(base + '*')):
+                if path.is_file():
+                    self._add_file(path, '%s/%s' % (self.dist_info, path.name))
+
+        with self._write_to_zip(self.dist_info + '/WHEEL') as f:
+            _write_wheel_file(f, supports_py2=self.metadata.supports_py2)
+
+        with self._write_to_zip(self.dist_info + '/METADATA') as f:
+            self.metadata.write_metadata_file(f)
+
+    def write_record(self):
+        log.info('Writing the record of files')
+        # Write a record of the files in the wheel
+        with self._write_to_zip(self.dist_info + '/RECORD') as f:
+            for path, hash, size in self.records:
+                f.write(u'{},sha256={},{}\n'.format(path, hash, size))
+            # RECORD itself is recorded with no hash or size
+            f.write(self.dist_info + '/RECORD,,\n')
+
+    def build(self, editable=False):
+        try:
+            if editable:
+                self.add_pth()
+            else:
+                self.copy_module()
+            self.add_data_directory()
+            self.write_metadata()
+            self.write_record()
+        finally:
+            self.wheel_zip.close()
+
+def make_wheel_in(ini_path, wheel_directory, editable=False):
+    # We don't know the final filename until metadata is loaded, so write to
+    # a temporary_file, and rename it afterwards.
+    (fd, temp_path) = tempfile.mkstemp(suffix='.whl', dir=str(wheel_directory))
+    try:
+        with io.open(fd, 'w+b') as fp:
+            wb = WheelBuilder.from_ini_path(ini_path, fp)
+            wb.build(editable)
+
+        wheel_path = wheel_directory / wb.wheel_filename
+        os.replace(temp_path, str(wheel_path))
+    except:
+        os.unlink(temp_path)
+        raise
+
+    log.info("Built wheel: %s", wheel_path)
+    return SimpleNamespace(builder=wb, file=wheel_path)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        'srcdir',
+        type=Path,
+        nargs='?',
+        default=Path.cwd(),
+        help='source directory (defaults to current directory)',
+    )
+
+    parser.add_argument(
+        '--outdir',
+        '-o',
+        help='output directory (defaults to {srcdir}/dist)',
+    )
+    args = parser.parse_args(argv)
+    outdir = args.srcdir / 'dist' if args.outdir is None else Path(args.outdir)
+    print("Building wheel from", args.srcdir)
+    pyproj_toml = args.srcdir / 'pyproject.toml'
+    outdir.mkdir(parents=True, exist_ok=True)
+    info = make_wheel_in(pyproj_toml, outdir)
+    print("Wheel built", outdir / info.file.name)
+
+if __name__ == "__main__":
+    main()
diff --git a/flit_core/pyproject.toml b/flit_core/pyproject.toml
new file mode 100644
index 0000000..e11bf62
--- /dev/null
+++ b/flit_core/pyproject.toml
@@ -0,0 +1,25 @@
+[build-system]
+requires = []
+build-backend = "flit_core.buildapi"
+backend-path = ["."]
+
+[project]
+name="flit_core"
+authors=[
+    {name = "Thomas Kluyver & contributors", email = "thomas@kluyver.me.uk"},
+]
+description = "Distribution-building parts of Flit. See flit package for more information"
+dependencies = []
+requires-python = '>=3.6'
+license = {file = "LICENSE"}
+classifiers = [
+    "License :: OSI Approved :: BSD License",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dynamic = ["version"]
+
+[project.urls]
+Source = "https://github.com/pypa/flit"
+
+[tool.flit.sdist]
+include = ["bootstrap_install.py", "build_dists.py"]
diff --git a/flit_core/update-vendored-tomli.sh b/flit_core/update-vendored-tomli.sh
new file mode 100755
index 0000000..c10af1f
--- /dev/null
+++ b/flit_core/update-vendored-tomli.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# Update the vendored copy of tomli
+set -euo pipefail
+
+version=$1
+echo "Bundling tomli version $version"
+
+rm -rf flit_core/vendor/tomli*
+pip install --target flit_core/vendor/ "tomli==$version"
+
+# Convert absolute imports to relative (from tomli.foo -> from .foo)
+for file in flit_core/vendor/tomli/*.py; do
+  sed -i -E 's/((from|import)[[:space:]]+)tomli\./\1\./' "$file"
+done
+
+# Delete some files that aren't useful in this context.
+# Leave LICENSE & METADATA present.
+rm flit_core/vendor/tomli*.dist-info/{INSTALLER,RECORD,REQUESTED,WHEEL}