xm/video
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

up

Browse Source
This commit is contained in:
lz_db
2026-10-16 22:48:30 +08:00
parent 190de72571
commit 0b36fd3383
3161 changed files with 12787 additions and 77274 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/.venv/lib/python3.11/site-packages/setuptools/config/NOTICE
-10
View File
@@ -1,10 +0,0 @@
The following files include code from opensource projects
(either as direct copies or modified versions):
- `setuptools.schema.json`, `distutils.schema.json`:
- project: `validate-pyproject` - licensed under MPL-2.0
(https://github.com/abravalheri/validate-pyproject):
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this file,
You can obtain one at https://mozilla.org/MPL/2.0/.
server/.venv/lib/python3.11/site-packages/setuptools/config/__init__.py
+11 -19
View File
@@ -1,11 +1,12 @@
"""For backward compatibility, expose main functions from
``setuptools.config.setupcfg``
"""
import warnings
from functools import wraps
from textwrap import dedent
from typing import Callable, TypeVar, cast
from ..warnings import SetuptoolsDeprecationWarning
from .._deprecation_warning import SetuptoolsDeprecationWarning
from . import setupcfg
Fn = TypeVar("Fn", bound=Callable)
@@ -16,24 +17,15 @@ __all__ = ('parse_configuration', 'read_configuration')
def _deprecation_notice(fn: Fn) -> Fn:
@wraps(fn)
def _wrapper(*args, **kwargs):
SetuptoolsDeprecationWarning.emit(
"Deprecated API usage.",
f"""
As setuptools moves its configuration towards `pyproject.toml`,
`{__name__}.{fn.__name__}` became deprecated.
msg = f"""\
As setuptools moves its configuration towards `pyproject.toml`,
`{__name__}.{fn.__name__}` became deprecated.
For the time being, you can use the `{setupcfg.__name__}` module
to access a backward compatible API, but this module is provisional
and might be removed in the future.
To read project metadata, consider using
``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
For simple scenarios, you can also try parsing the file directly
with the help of ``configparser``.
""",
# due_date not defined yet, because the community still heavily relies on it
# Warning introduced in 24 Mar 2022
)
For the time being, you can use the `{setupcfg.__name__}` module
to access a backward compatible API, but this module is provisional
and might be removed in the future.
"""
warnings.warn(dedent(msg), SetuptoolsDeprecationWarning, stacklevel=2)
return fn(*args, **kwargs)
return cast(Fn, _wrapper)
server/.venv/lib/python3.11/site-packages/setuptools/config/__pycache__/__init__.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/__pycache__/expand.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/__pycache__/pyprojecttoml.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/__pycache__/setupcfg.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_apply_pyprojecttoml.py
+89 -238
View File
@@ -7,43 +7,33 @@ need to be processed before being applied.
**PRIVATE MODULE**: API reserved for setuptools internal usage only.
"""
from __future__ import annotations
import logging
import os
import warnings
from collections.abc import Mapping
from email.headerregistry import Address
from functools import partial, reduce
from inspect import cleandoc
from itertools import chain
from types import MappingProxyType
from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
from typing import (TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Tuple,
Type, Union)
from .. import _static
from .._path import StrPath
from ..errors import InvalidConfigError, RemovedConfigError
from ..extension import Extension
from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
from setuptools._deprecation_warning import SetuptoolsDeprecationWarning
if TYPE_CHECKING:
from typing_extensions import TypeAlias
from setuptools._importlib import metadata
from setuptools.dist import Distribution
from distutils.dist import _OptionsList # Comes from typeshed
from setuptools._importlib import metadata # noqa
from setuptools.dist import Distribution # noqa
EMPTY: Mapping = MappingProxyType({}) # Immutable dict-like
_ProjectReadmeValue: TypeAlias = Union[str, dict[str, str]]
_Correspondence: TypeAlias = Callable[["Distribution", Any, Union[StrPath, None]], None]
_T = TypeVar("_T")
_Path = Union[os.PathLike, str]
_DictOrStr = Union[dict, str]
_CorrespFn = Callable[["Distribution", Any, _Path], None]
_Correspondence = Union[str, _CorrespFn]
_logger = logging.getLogger(__name__)
def apply(dist: Distribution, config: dict, filename: StrPath) -> Distribution:
def apply(dist: "Distribution", config: dict, filename: _Path) -> "Distribution":
"""Apply configuration dict read with :func:`read_configuration`"""
if not config:
@@ -58,7 +48,6 @@ def apply(dist: Distribution, config: dict, filename: StrPath) -> Distribution:
os.chdir(root_dir)
try:
dist._finalize_requires()
dist._finalize_license_expression()
dist._finalize_license_files()
finally:
os.chdir(current_directory)
@@ -66,12 +55,11 @@ def apply(dist: Distribution, config: dict, filename: StrPath) -> Distribution:
return dist
def _apply_project_table(dist: Distribution, config: dict, root_dir: StrPath):
orig_config = config.get("project", {})
if not orig_config:
def _apply_project_table(dist: "Distribution", config: dict, root_dir: _Path):
project_table = config.get("project", {}).copy()
if not project_table:
return # short-circuit
project_table = {k: _static.attempt_conversion(v) for k, v in orig_config.items()}
_handle_missing_dynamic(dist, project_table)
_unify_entry_points(project_table)
@@ -84,57 +72,35 @@ def _apply_project_table(dist: Distribution, config: dict, root_dir: StrPath):
_set_config(dist, corresp, value)
def _apply_tool_table(dist: Distribution, config: dict, filename: StrPath):
def _apply_tool_table(dist: "Distribution", config: dict, filename: _Path):
tool_table = config.get("tool", {}).get("setuptools", {})
if not tool_table:
return # short-circuit
if "license-files" in tool_table:
if "license-files" in config.get("project", {}):
# https://github.com/pypa/setuptools/pull/4837#discussion_r2004983349
raise InvalidConfigError(
"'project.license-files' is defined already. "
"Remove 'tool.setuptools.license-files'."
)
pypa_guides = "guides/writing-pyproject-toml/#license-files"
SetuptoolsDeprecationWarning.emit(
"'tool.setuptools.license-files' is deprecated in favor of "
"'project.license-files' (available on setuptools>=77.0.0).",
see_url=f"https://packaging.python.org/en/latest/{pypa_guides}",
due_date=(2026, 2, 18), # Warning introduced on 2025-02-18
)
for field, value in tool_table.items():
norm_key = json_compatible_key(field)
if norm_key in TOOL_TABLE_REMOVALS:
suggestion = cleandoc(TOOL_TABLE_REMOVALS[norm_key])
msg = f"""
The parameter `tool.setuptools.{field}` was long deprecated
and has been removed from `pyproject.toml`.
"""
raise RemovedConfigError("\n".join([cleandoc(msg), suggestion]))
if norm_key in TOOL_TABLE_DEPRECATIONS:
suggestion = TOOL_TABLE_DEPRECATIONS[norm_key]
msg = f"The parameter `{norm_key}` is deprecated, {suggestion}"
warnings.warn(msg, SetuptoolsDeprecationWarning)
norm_key = TOOL_TABLE_RENAMES.get(norm_key, norm_key)
corresp = TOOL_TABLE_CORRESPONDENCE.get(norm_key, norm_key)
if callable(corresp):
corresp(dist, value)
else:
_set_config(dist, corresp, value)
_set_config(dist, norm_key, value)
_copy_command_options(config, dist, filename)
def _handle_missing_dynamic(dist: Distribution, project_table: dict):
def _handle_missing_dynamic(dist: "Distribution", project_table: dict):
"""Be temporarily forgiving with ``dynamic`` fields not listed in ``dynamic``"""
# TODO: Set fields back to `None` once the feature stabilizes
dynamic = set(project_table.get("dynamic", []))
for field, getter in _PREVIOUSLY_DEFINED.items():
if not (field in project_table or field in dynamic):
value = getter(dist)
if value:
_MissingDynamic.emit(field=field, value=value)
project_table[field] = _RESET_PREVIOUSLY_DEFINED.get(field)
msg = _WouldIgnoreField.message(field, value)
warnings.warn(msg, _WouldIgnoreField)
def json_compatible_key(key: str) -> str:
@@ -142,15 +108,14 @@ def json_compatible_key(key: str) -> str:
return key.lower().replace("-", "_")
def _set_config(dist: Distribution, field: str, value: Any):
val = _PREPROCESS.get(field, _noop)(dist, value)
def _set_config(dist: "Distribution", field: str, value: Any):
setter = getattr(dist.metadata, f"set_{field}", None)
if setter:
setter(val)
setter(value)
elif hasattr(dist.metadata, field) or field in SETUPTOOLS_PATCHES:
setattr(dist.metadata, field, val)
setattr(dist.metadata, field, value)
else:
setattr(dist, field, val)
setattr(dist, field, value)
_CONTENT_TYPES = {
@@ -160,72 +125,44 @@ _CONTENT_TYPES = {
}
def _guess_content_type(file: str) -> str | None:
def _guess_content_type(file: str) -> Optional[str]:
_, ext = os.path.splitext(file.lower())
if not ext:
return None
if ext in _CONTENT_TYPES:
return _static.Str(_CONTENT_TYPES[ext])
return _CONTENT_TYPES[ext]
valid = ", ".join(f"{k} ({v})" for k, v in _CONTENT_TYPES.items())
msg = f"only the following file extensions are recognized: {valid}."
raise ValueError(f"Undefined content type for {file}, {msg}")
def _long_description(
dist: Distribution, val: _ProjectReadmeValue, root_dir: StrPath | None
):
def _long_description(dist: "Distribution", val: _DictOrStr, root_dir: _Path):
from setuptools.config import expand
file: str | tuple[()]
if isinstance(val, str):
file = val
text = expand.read_files(file, root_dir)
ctype = _guess_content_type(file)
text = expand.read_files(val, root_dir)
ctype = _guess_content_type(val)
else:
file = val.get("file") or ()
text = val.get("text") or expand.read_files(file, root_dir)
text = val.get("text") or expand.read_files(val.get("file", []), root_dir)
ctype = val["content-type"]
# XXX: Is it completely safe to assume static?
_set_config(dist, "long_description", _static.Str(text))
_set_config(dist, "long_description", text)
if ctype:
_set_config(dist, "long_description_content_type", _static.Str(ctype))
if file:
dist._referenced_files.add(file)
_set_config(dist, "long_description_content_type", ctype)
def _license(dist: Distribution, val: str | dict, root_dir: StrPath | None):
def _license(dist: "Distribution", val: dict, root_dir: _Path):
from setuptools.config import expand
if isinstance(val, str):
if getattr(dist.metadata, "license", None):
SetuptoolsWarning.emit("`license` overwritten by `pyproject.toml`")
dist.metadata.license = None
_set_config(dist, "license_expression", _static.Str(val))
if "file" in val:
_set_config(dist, "license", expand.read_files([val["file"]], root_dir))
else:
pypa_guides = "guides/writing-pyproject-toml/#license"
SetuptoolsDeprecationWarning.emit(
"`project.license` as a TOML table is deprecated",
"Please use a simple string containing a SPDX expression for "
"`project.license`. You can also use `project.license-files`. "
"(Both options available on setuptools>=77.0.0).",
see_url=f"https://packaging.python.org/en/latest/{pypa_guides}",
due_date=(2026, 2, 18), # Introduced on 2025-02-18
)
if "file" in val:
# XXX: Is it completely safe to assume static?
value = expand.read_files([val["file"]], root_dir)
_set_config(dist, "license", _static.Str(value))
dist._referenced_files.add(val["file"])
else:
_set_config(dist, "license", _static.Str(val["text"]))
_set_config(dist, "license", val["text"])
def _people(dist: Distribution, val: list[dict], _root_dir: StrPath | None, kind: str):
def _people(dist: "Distribution", val: List[dict], _root_dir: _Path, kind: str):
field = []
email_field = []
for person in val:
@@ -238,70 +175,50 @@ def _people(dist: Distribution, val: list[dict], _root_dir: StrPath | None, kind
email_field.append(str(addr))
if field:
_set_config(dist, kind, _static.Str(", ".join(field)))
_set_config(dist, kind, ", ".join(field))
if email_field:
_set_config(dist, f"{kind}_email", _static.Str(", ".join(email_field)))
_set_config(dist, f"{kind}_email", ", ".join(email_field))
def _project_urls(dist: Distribution, val: dict, _root_dir: StrPath | None):
def _project_urls(dist: "Distribution", val: dict, _root_dir):
_set_config(dist, "project_urls", val)
def _python_requires(dist: Distribution, val: str, _root_dir: StrPath | None):
_set_config(dist, "python_requires", _static.SpecifierSet(val))
def _python_requires(dist: "Distribution", val: dict, _root_dir):
from setuptools.extern.packaging.specifiers import SpecifierSet
_set_config(dist, "python_requires", SpecifierSet(val))
def _dependencies(dist: Distribution, val: list, _root_dir: StrPath | None):
def _dependencies(dist: "Distribution", val: list, _root_dir):
if getattr(dist, "install_requires", []):
msg = "`install_requires` overwritten in `pyproject.toml` (dependencies)"
SetuptoolsWarning.emit(msg)
dist.install_requires = val
warnings.warn(msg)
_set_config(dist, "install_requires", val)
def _optional_dependencies(dist: Distribution, val: dict, _root_dir: StrPath | None):
if getattr(dist, "extras_require", None):
msg = "`extras_require` overwritten in `pyproject.toml` (optional-dependencies)"
SetuptoolsWarning.emit(msg)
dist.extras_require = val
def _ext_modules(dist: Distribution, val: list[dict]) -> list[Extension]:
existing = dist.ext_modules or []
args = ({k.replace("-", "_"): v for k, v in x.items()} for x in val)
new = [Extension(**kw) for kw in args]
return [*existing, *new]
def _noop(_dist: Distribution, val: _T) -> _T:
return val
def _identity(val: _T) -> _T:
return val
def _optional_dependencies(dist: "Distribution", val: dict, _root_dir):
existing = getattr(dist, "extras_require", {})
_set_config(dist, "extras_require", {**existing, **val})
def _unify_entry_points(project_table: dict):
project = project_table
given = project.pop("entry-points", project.pop("entry_points", {}))
entry_points = dict(given) # Avoid problems with static
entry_points = project.pop("entry-points", project.pop("entry_points", {}))
renaming = {"scripts": "console_scripts", "gui_scripts": "gui_scripts"}
for key, value in list(project.items()): # eager to allow modifications
norm_key = json_compatible_key(key)
if norm_key in renaming:
# Don't skip even if value is empty (reason: reset missing `dynamic`)
if norm_key in renaming and value:
entry_points[renaming[norm_key]] = project.pop(key)
if entry_points:
project["entry-points"] = {
name: [f"{k} = {v}" for k, v in group.items()]
for name, group in entry_points.items()
if group # now we can skip empty groups
}
# Sometimes this will set `project["entry-points"] = {}`, and that is
# intentional (for resetting configurations that are missing `dynamic`).
def _copy_command_options(pyproject: dict, dist: Distribution, filename: StrPath):
def _copy_command_options(pyproject: dict, dist: "Distribution", filename: _Path):
tool_table = pyproject.get("tool", {})
cmdclass = tool_table.get("setuptools", {}).get("cmdclass", {})
valid_options = _valid_command_options(cmdclass)
@@ -320,10 +237,9 @@ def _copy_command_options(pyproject: dict, dist: Distribution, filename: StrPath
_logger.warning(f"Command option {cmd}.{key} is not defined")
def _valid_command_options(cmdclass: Mapping = EMPTY) -> dict[str, set[str]]:
from setuptools.dist import Distribution
def _valid_command_options(cmdclass: Mapping = EMPTY) -> Dict[str, Set[str]]:
from .._importlib import metadata
from setuptools.dist import Distribution
valid_options = {"global": _normalise_cmd_options(Distribution.global_options)}
@@ -338,12 +254,7 @@ def _valid_command_options(cmdclass: Mapping = EMPTY) -> dict[str, set[str]]:
return valid_options
def _load_ep(ep: metadata.EntryPoint) -> tuple[str, type] | None:
if ep.value.startswith("wheel.bdist_wheel"):
# Ignore deprecated entrypoint from wheel and avoid warning pypa/wheel#631
# TODO: remove check when `bdist_wheel` has been fully removed from pypa/wheel
return None
def _load_ep(ep: "metadata.EntryPoint") -> Optional[Tuple[str, Type]]:
# Ignore all the errors
try:
return (ep.name, ep.load())
@@ -357,34 +268,10 @@ def _normalise_cmd_option_key(name: str) -> str:
return json_compatible_key(name).strip("_=")
def _normalise_cmd_options(desc: _OptionsList) -> set[str]:
def _normalise_cmd_options(desc: List[Tuple[str, Optional[str], str]]) -> Set[str]:
return {_normalise_cmd_option_key(fancy_option[0]) for fancy_option in desc}
def _get_previous_entrypoints(dist: Distribution) -> dict[str, list]:
ignore = ("console_scripts", "gui_scripts")
value = getattr(dist, "entry_points", None) or {}
return {k: v for k, v in value.items() if k not in ignore}
def _get_previous_scripts(dist: Distribution) -> list | None:
value = getattr(dist, "entry_points", None) or {}
return value.get("console_scripts")
def _get_previous_gui_scripts(dist: Distribution) -> list | None:
value = getattr(dist, "entry_points", None) or {}
return value.get("gui_scripts")
def _set_static_list_metadata(attr: str, dist: Distribution, val: list) -> None:
"""Apply distutils metadata validation but preserve "static" behaviour"""
meta = dist.metadata
setter, getter = getattr(meta, f"set_{attr}"), getattr(meta, f"get_{attr}")
setter(val)
setattr(meta, attr, _static.List(getter()))
def _attrgetter(attr):
"""
Similar to ``operator.attrgetter`` but returns None if ``attr`` is not found
@@ -412,15 +299,13 @@ def _some_attrgetter(*items):
>>> _some_attrgetter("d", "e", "f")(obj) is None
True
"""
def _acessor(obj):
values = (_attrgetter(i)(obj) for i in items)
return next((i for i in values if i is not None), None)
return _acessor
PYPROJECT_CORRESPONDENCE: dict[str, _Correspondence] = {
PYPROJECT_CORRESPONDENCE: Dict[str, _Correspondence] = {
"readme": _long_description,
"license": _license,
"authors": partial(_people, kind="author"),
@@ -432,31 +317,12 @@ PYPROJECT_CORRESPONDENCE: dict[str, _Correspondence] = {
}
TOOL_TABLE_RENAMES = {"script_files": "scripts"}
TOOL_TABLE_REMOVALS = {
"namespace_packages": """
Please migrate to implicit native namespaces instead.
See https://packaging.python.org/en/latest/guides/packaging-namespace-packages/.
""",
}
TOOL_TABLE_CORRESPONDENCE = {
# Fields with corresponding core metadata need to be marked as static:
"obsoletes": partial(_set_static_list_metadata, "obsoletes"),
"provides": partial(_set_static_list_metadata, "provides"),
"platforms": partial(_set_static_list_metadata, "platforms"),
TOOL_TABLE_DEPRECATIONS = {
"namespace_packages": "consider using implicit namespaces instead (PEP 420)."
}
SETUPTOOLS_PATCHES = {
"long_description_content_type",
"project_urls",
"provides_extras",
"license_file",
"license_files",
"license_expression",
}
_PREPROCESS = {
"ext_modules": _ext_modules,
}
SETUPTOOLS_PATCHES = {"long_description_content_type", "project_urls",
"provides_extras", "license_file", "license_files"}
_PREVIOUSLY_DEFINED = {
"name": _attrgetter("metadata.name"),
@@ -464,63 +330,48 @@ _PREVIOUSLY_DEFINED = {
"description": _attrgetter("metadata.description"),
"readme": _attrgetter("metadata.long_description"),
"requires-python": _some_attrgetter("python_requires", "metadata.python_requires"),
"license": _some_attrgetter("metadata.license_expression", "metadata.license"),
# XXX: `license-file` is currently not considered in the context of `dynamic`.
# See TestPresetField.test_license_files_exempt_from_dynamic
"license": _attrgetter("metadata.license"),
"authors": _some_attrgetter("metadata.author", "metadata.author_email"),
"maintainers": _some_attrgetter("metadata.maintainer", "metadata.maintainer_email"),
"keywords": _attrgetter("metadata.keywords"),
"classifiers": _attrgetter("metadata.classifiers"),
"urls": _attrgetter("metadata.project_urls"),
"entry-points": _get_previous_entrypoints,
"scripts": _get_previous_scripts,
"gui-scripts": _get_previous_gui_scripts,
"dependencies": _attrgetter("install_requires"),
"optional-dependencies": _attrgetter("extras_require"),
"entry-points": _attrgetter("entry_points"),
"dependencies": _some_attrgetter("_orig_install_requires", "install_requires"),
"optional-dependencies": _some_attrgetter("_orig_extras_require", "extras_require"),
}
_RESET_PREVIOUSLY_DEFINED: dict = {
# Fix improper setting: given in `setup.py`, but not listed in `dynamic`
# Use "immutable" data structures to avoid in-place modification.
# dict: pyproject name => value to which reset
"license": "",
# XXX: `license-file` is currently not considered in the context of `dynamic`.
# See TestPresetField.test_license_files_exempt_from_dynamic
"authors": _static.EMPTY_LIST,
"maintainers": _static.EMPTY_LIST,
"keywords": _static.EMPTY_LIST,
"classifiers": _static.EMPTY_LIST,
"urls": _static.EMPTY_DICT,
"entry-points": _static.EMPTY_DICT,
"scripts": _static.EMPTY_DICT,
"gui-scripts": _static.EMPTY_DICT,
"dependencies": _static.EMPTY_LIST,
"optional-dependencies": _static.EMPTY_DICT,
}
class _WouldIgnoreField(UserWarning):
"""Inform users that ``pyproject.toml`` would overwrite previous metadata."""
MESSAGE = """\
{field!r} defined outside of `pyproject.toml` would be ignored.
!!\n\n
##########################################################################
# configuration would be ignored/result in error due to `pyproject.toml` #
##########################################################################
class _MissingDynamic(SetuptoolsWarning):
_SUMMARY = "`{field}` defined outside of `pyproject.toml` is ignored."
_DETAILS = """
The following seems to be defined outside of `pyproject.toml`:
`{field} = {value!r}`
According to the spec (see the link below), however, setuptools CANNOT
consider this value unless `{field}` is listed as `dynamic`.
consider this value unless {field!r} is listed as `dynamic`.
https://packaging.python.org/en/latest/specifications/pyproject-toml/#declaring-project-metadata-the-project-table
https://packaging.python.org/en/latest/specifications/declaring-project-metadata/
To prevent this problem, you can list `{field}` under `dynamic` or alternatively
For the time being, `setuptools` will still consider the given value (as a
**transitional** measure), but please note that future releases of setuptools will
follow strictly the standard.
To prevent this warning, you can list {field!r} under `dynamic` or alternatively
remove the `[project]` table from your file and rely entirely on other means of
configuration.
\n\n!!
"""
# TODO: Consider removing this check in the future?
# There is a trade-off here between improving "debug-ability" and the cost
# of running/testing/maintaining these unnecessary checks...
@classmethod
def details(cls, field: str, value: Any) -> str:
return cls._DETAILS.format(field=field, value=value)
def message(cls, field, value):
from inspect import cleandoc
return cleandoc(cls.MESSAGE.format(field=field, value=value))
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/NOTICE
-438
View File
@@ -1,438 +0,0 @@
The code contained in this directory was automatically generated using the
following command:
python -m validate_pyproject.pre_compile --output-dir=setuptools/config/_validate_pyproject --enable-plugins setuptools distutils --very-verbose -t setuptools=setuptools/config/setuptools.schema.json -t distutils=setuptools/config/distutils.schema.json
Please avoid changing it manually.
You can report issues or suggest changes directly to `validate-pyproject`
(or to the relevant plugin repository)
- https://github.com/abravalheri/validate-pyproject/issues
***
The following files include code from opensource projects
(either as direct copies or modified versions):
- `fastjsonschema_exceptions.py`:
- project: `fastjsonschema` - licensed under BSD-3-Clause
(https://github.com/horejsek/python-fastjsonschema)
- `extra_validations.py` and `format.py`, `error_reporting.py`:
- project: `validate-pyproject` - licensed under MPL-2.0
(https://github.com/abravalheri/validate-pyproject)
Additionally the following files are automatically generated by tools provided
by the same projects:
- `__init__.py`
- `fastjsonschema_validations.py`
The relevant copyright notes and licenses are included below.
***
`fastjsonschema`
================
Copyright (c) 2018, Michal Horejsek
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
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.
Neither the name of the {organization} 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.
***
`validate-pyproject`
====================
Mozilla Public License, version 2.0
1. Definitions
1.1. "Contributor"
means each individual or legal entity that creates, contributes to the
creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used by a
Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached the
notice in Exhibit A, the Executable Form of such Source Code Form, and
Modifications of such Source Code Form, in each case including portions
thereof.
1.5. "Incompatible With Secondary Licenses"
means
a. that the initial Contributor has attached the notice described in
Exhibit B to the Covered Software; or
b. that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the terms of
a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in a
separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible, whether
at the time of the initial grant or subsequently, any and all of the
rights conveyed by this License.
1.10. "Modifications"
means any of the following:
a. any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered Software; or
b. any new file in Source Code Form that contains any Covered Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the License,
by the making, using, selling, offering for sale, having made, import,
or transfer of either its Contributions or its Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU Lesser
General Public License, Version 2.1, the GNU Affero General Public
License, Version 3.0, or any later versions of those licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that controls, is
controlled by, or is under common control with You. For purposes of this
definition, "control" means (a) the power, direct or indirect, to cause
the direction or management of such entity, whether by contract or
otherwise, or (b) ownership of more than fifty percent (50%) of the
outstanding shares or beneficial ownership of such entity.
2. License Grants and Conditions
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
a. under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
b. under Patent Claims of such Contributor to make, use, sell, offer for
sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
a. for any code that a Contributor has removed from Covered Software; or
b. for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
c. under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights to
grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
Section 2.1.
3. Responsibilities
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
a. such Covered Software must also be made available in Source Code Form,
as described in Section 3.1, and You must inform recipients of the
Executable Form how they can obtain a copy of such Source Code Form by
reasonable means in a timely manner, at a charge no more than the cost
of distribution to the recipient; and
b. You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter the
recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty, or
limitations of liability) contained within the Source Code Form of the
Covered Software, except that You may alter any license notices to the
extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
If it is impossible for You to comply with any of the terms of this License
with respect to some or all of the Covered Software due to statute,
judicial order, or regulation then You must: (a) comply with the terms of
this License to the maximum extent possible; and (b) describe the
limitations and the code they affect. Such description must be placed in a
text file included with all distributions of the Covered Software under
this License. Except to the extent prohibited by statute or regulation,
such description must be sufficiently detailed for a recipient of ordinary
skill to be able to understand it.
5. Termination
5.1. The rights granted under this License will terminate automatically if You
fail to comply with any of its terms. However, if You become compliant,
then the rights granted under this License from a particular Contributor
are reinstated (a) provisionally, unless and until such Contributor
explicitly and finally terminates Your grants, and (b) on an ongoing
basis, if such Contributor fails to notify You of the non-compliance by
some reasonable means prior to 60 days after You have come back into
compliance. Moreover, Your grants from a particular Contributor are
reinstated on an ongoing basis if such Contributor notifies You of the
non-compliance by some reasonable means, this is the first time You have
received notice of non-compliance with this License from such
Contributor, and You become compliant prior to 30 days after Your receipt
of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
license agreements (excluding distributors and resellers) which have been
validly granted by You or Your distributors under this License prior to
termination shall survive termination.
6. Disclaimer of Warranty
Covered Software is provided under this License on an "as is" basis,
without warranty of any kind, either expressed, implied, or statutory,
including, without limitation, warranties that the Covered Software is free
of defects, merchantable, fit for a particular purpose or non-infringing.
The entire risk as to the quality and performance of the Covered Software
is with You. Should any Covered Software prove defective in any respect,
You (not any Contributor) assume the cost of any necessary servicing,
repair, or correction. This disclaimer of warranty constitutes an essential
part of this License. No use of any Covered Software is authorized under
this License except under this disclaimer.
7. Limitation of Liability
Under no circumstances and under no legal theory, whether tort (including
negligence), contract, or otherwise, shall any Contributor, or anyone who
distributes Covered Software as permitted above, be liable to You for any
direct, indirect, special, incidental, or consequential damages of any
character including, without limitation, damages for lost profits, loss of
goodwill, work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses, even if such party shall have been
informed of the possibility of such damages. This limitation of liability
shall not apply to liability for death or personal injury resulting from
such party's negligence to the extent applicable law prohibits such
limitation. Some jurisdictions do not allow the exclusion or limitation of
incidental or consequential damages, so this exclusion and limitation may
not apply to You.
8. Litigation
Any litigation relating to this License may be brought only in the courts
of a jurisdiction where the defendant maintains its principal place of
business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions. Nothing
in this Section shall prevent a party's ability to bring cross-claims or
counter-claims.
9. Miscellaneous
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides that
the language of a contract shall be construed against the drafter shall not
be used to construe this License against a Contributor.
10. Versions of the License
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses If You choose to distribute Source Code Form that is
Incompatible With Secondary Licenses under the terms of this version of
the License, the notice described in Exhibit B of this License must be
attached.
Exhibit A - Source Code Form License Notice
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
https://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular file,
then You may include the notice in a location (such as a LICENSE file in a
relevant directory) where a recipient would be likely to look for such a
notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
This Source Code Form is "Incompatible
With Secondary Licenses", as defined by
the Mozilla Public License, v. 2.0.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__init__.py
+1 -1
View File
@@ -30,5 +30,5 @@ def validate(data: Any) -> bool:
"""
with detailed_errors():
_validate(data, custom_formats=FORMAT_FUNCTIONS)
reduce(lambda acc, fn: fn(acc), EXTRA_VALIDATIONS, data)
reduce(lambda acc, fn: fn(acc), EXTRA_VALIDATIONS, data)
return True
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/formats.cpython-311.pyc
BIN
View File
Binary file not shown.
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/error_reporting.py
+17 -35
View File
@@ -3,21 +3,12 @@ import json
import logging
import os
import re
import typing
from contextlib import contextmanager
from textwrap import indent, wrap
from typing import Any, Dict, Generator, Iterator, List, Optional, Sequence, Union
from typing import Any, Dict, Iterator, List, Optional, Sequence, Union, cast
from .fastjsonschema_exceptions import JsonSchemaValueException
if typing.TYPE_CHECKING:
import sys
if sys.version_info < (3, 11):
from typing_extensions import Self
else:
from typing import Self
_logger = logging.getLogger(__name__)
_MESSAGE_REPLACEMENTS = {
@@ -33,7 +24,7 @@ _SKIP_DETAILS = (
"must not be there",
)
_NEED_DETAILS = {"anyOf", "oneOf", "allOf", "contains", "propertyNames", "not", "items"}
_NEED_DETAILS = {"anyOf", "oneOf", "anyOf", "contains", "propertyNames", "not", "items"}
_CAMEL_CASE_SPLITTER = re.compile(r"\W+|([A-Z][^A-Z\W]*)")
_IDENTIFIER = re.compile(r"^[\w_]+$", re.I)
@@ -45,11 +36,6 @@ _TOML_JARGON = {
"property names": "keys",
}
_FORMATS_HELP = """
For more details about `format` see
https://validate-pyproject.readthedocs.io/en/latest/api/validate_pyproject.formats.html
"""
class ValidationError(JsonSchemaValueException):
"""Report violations of a given JSON schema.
@@ -73,7 +59,7 @@ class ValidationError(JsonSchemaValueException):
_original_message = ""
@classmethod
def _from_jsonschema(cls, ex: JsonSchemaValueException) -> "Self":
def _from_jsonschema(cls, ex: JsonSchemaValueException):
formatter = _ErrorFormatting(ex)
obj = cls(str(formatter), ex.value, formatter.name, ex.definition, ex.rule)
debug_code = os.getenv("JSONSCHEMA_DEBUG_CODE_GENERATION", "false").lower()
@@ -86,7 +72,7 @@ class ValidationError(JsonSchemaValueException):
@contextmanager
def detailed_errors() -> Generator[None, None, None]:
def detailed_errors():
try:
yield
except JsonSchemaValueException as ex:
@@ -97,7 +83,7 @@ class _ErrorFormatting:
def __init__(self, ex: JsonSchemaValueException):
self.ex = ex
self.name = f"`{self._simplify_name(ex.name)}`"
self._original_message: str = self.ex.message.replace(ex.name, self.name)
self._original_message = self.ex.message.replace(ex.name, self.name)
self._summary = ""
self._details = ""
@@ -121,12 +107,11 @@ class _ErrorFormatting:
return self._details
@staticmethod
def _simplify_name(name: str) -> str:
def _simplify_name(self, name):
x = len("data.")
return name[x:] if name.startswith("data.") else name
def _expand_summary(self) -> str:
def _expand_summary(self):
msg = self._original_message
for bad, repl in _MESSAGE_REPLACEMENTS.items():
@@ -144,9 +129,8 @@ class _ErrorFormatting:
def _expand_details(self) -> str:
optional = []
definition = self.ex.definition or {}
desc_lines = definition.pop("$$description", [])
desc = definition.pop("description", None) or " ".join(desc_lines)
desc_lines = self.ex.definition.pop("$$description", [])
desc = self.ex.definition.pop("description", None) or " ".join(desc_lines)
if desc:
description = "\n".join(
wrap(
@@ -158,20 +142,18 @@ class _ErrorFormatting:
)
)
optional.append(f"DESCRIPTION:\n{description}")
schema = json.dumps(definition, indent=4)
schema = json.dumps(self.ex.definition, indent=4)
value = json.dumps(self.ex.value, indent=4)
defaults = [
f"GIVEN VALUE:\n{indent(value, ' ')}",
f"OFFENDING RULE: {self.ex.rule!r}",
f"DEFINITION:\n{indent(schema, ' ')}",
]
msg = "\n\n".join(optional + defaults)
epilog = f"\n{_FORMATS_HELP}" if "format" in msg.lower() else ""
return msg + epilog
return "\n\n".join(optional + defaults)
class _SummaryWriter:
_IGNORE = frozenset(("description", "default", "title", "examples"))
_IGNORE = {"description", "default", "title", "examples"}
def __init__(self, jargon: Optional[Dict[str, str]] = None):
self.jargon: Dict[str, str] = jargon or {}
@@ -260,9 +242,7 @@ class _SummaryWriter:
key = path[-1]
return any(key.startswith(k) for k in "$_") or key in self._IGNORE
def _filter_unecessary(
self, schema: Dict[str, Any], path: Sequence[str]
) -> Dict[str, Any]:
def _filter_unecessary(self, schema: dict, path: Sequence[str]):
return {
key: value
for key, value in schema.items()
@@ -291,7 +271,7 @@ class _SummaryWriter:
self(v, item_prefix, _path=[*path, f"[{i}]"]) for i, v in enumerate(schemas)
)
def _is_property(self, path: Sequence[str]) -> bool:
def _is_property(self, path: Sequence[str]):
"""Check if the given path can correspond to an arbitrarily named property"""
counter = 0
for key in path[-2::-1]:
@@ -316,7 +296,9 @@ class _SummaryWriter:
def _value(self, value: Any, path: Sequence[str]) -> str:
if path[-1] == "type" and not self._is_property(path):
type_ = self._jargon(value)
return f"[{', '.join(type_)}]" if isinstance(type_, list) else type_
return (
f"[{', '.join(type_)}]" if isinstance(value, list) else cast(str, type_)
)
return repr(value)
def _inline_attrs(self, schema: dict, path: Sequence[str]) -> Iterator[str]:
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/extra_validations.py
+7 -53
View File
@@ -3,7 +3,6 @@ difficult to express as a JSON Schema (or that are not supported by the current
JSON Schema library).
"""
from inspect import cleandoc
from typing import Mapping, TypeVar
from .error_reporting import ValidationError
@@ -12,23 +11,11 @@ T = TypeVar("T", bound=Mapping)
class RedefiningStaticFieldAsDynamic(ValidationError):
_DESC = """According to PEP 621:
"""According to PEP 621:
Build back-ends MUST raise an error if the metadata specifies a field
statically as well as being listed in dynamic.
"""
__doc__ = _DESC
_URL = (
"https://packaging.python.org/en/latest/specifications/"
"pyproject-toml/#dynamic"
)
class IncludedDependencyGroupMustExist(ValidationError):
_DESC = """An included dependency group must exist and must not be cyclic.
"""
__doc__ = _DESC
_URL = "https://peps.python.org/pep-0735/"
def validate_project_dynamic(pyproject: T) -> T:
@@ -37,46 +24,13 @@ def validate_project_dynamic(pyproject: T) -> T:
for field in dynamic:
if field in project_table:
raise RedefiningStaticFieldAsDynamic(
message=f"You cannot provide a value for `project.{field}` and "
"list it under `project.dynamic` at the same time",
value={
field: project_table[field],
"...": " # ...",
"dynamic": dynamic,
},
name=f"data.project.{field}",
definition={
"description": cleandoc(RedefiningStaticFieldAsDynamic._DESC),
"see": RedefiningStaticFieldAsDynamic._URL,
},
rule="PEP 621",
)
msg = f"You cannot provide a value for `project.{field}` and "
msg += "list it under `project.dynamic` at the same time"
name = f"data.project.{field}"
value = {field: project_table[field], "...": " # ...", "dynamic": dynamic}
raise RedefiningStaticFieldAsDynamic(msg, value, name, rule="PEP 621")
return pyproject
def validate_include_depenency(pyproject: T) -> T:
dependency_groups = pyproject.get("dependency-groups", {})
for key, value in dependency_groups.items():
for each in value:
if (
isinstance(each, dict)
and (include_group := each.get("include-group"))
and include_group not in dependency_groups
):
raise IncludedDependencyGroupMustExist(
message=f"The included dependency group {include_group} doesn't exist",
value=each,
name=f"data.dependency_groups.{key}",
definition={
"description": cleandoc(IncludedDependencyGroupMustExist._DESC),
"see": IncludedDependencyGroupMustExist._URL,
},
rule="PEP 735",
)
# TODO: check for `include-group` cycles (can be conditional to graphlib)
return pyproject
EXTRA_VALIDATIONS = (validate_project_dynamic, validate_include_depenency)
EXTRA_VALIDATIONS = (validate_project_dynamic,)
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_validations.py
+227 -604
View File
File diff suppressed because one or more lines are too long
server/.venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/formats.py
+12 -155
View File
@@ -1,13 +1,3 @@
"""
The functions in this module are used to validate schemas with the
`format JSON Schema keyword
<https://json-schema.org/understanding-json-schema/reference/string#format>`_.
The correspondence is given by replacing the ``_`` character in the name of the
function with a ``-`` to obtain the format name and vice versa.
"""
import builtins
import logging
import os
import re
@@ -15,9 +5,6 @@ import string
import typing
from itertools import chain as _chain
if typing.TYPE_CHECKING:
from typing_extensions import Literal
_logger = logging.getLogger(__name__)
# -------------------------------------------------------------------------------------
@@ -30,7 +17,7 @@ VERSION_PATTERN = r"""
(?P<release>[0-9]+(?:\.[0-9]+)*) # release segment
(?P<pre> # pre-release
[-_\.]?
(?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
(?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
[-_\.]?
(?P<pre_n>[0-9]+)?
)?
@@ -58,9 +45,6 @@ VERSION_REGEX = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.X | re.I)
def pep440(version: str) -> bool:
"""See :ref:`PyPA's version specification <pypa:version-specifiers>`
(initially introduced in :pep:`440`).
"""
return VERSION_REGEX.match(version) is not None
@@ -72,9 +56,6 @@ PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)
def pep508_identifier(name: str) -> bool:
"""See :ref:`PyPA's name specification <pypa:name-format>`
(initially introduced in :pep:`508#names`).
"""
return PEP508_IDENTIFIER_REGEX.match(name) is not None
@@ -83,14 +64,9 @@ try:
from packaging import requirements as _req
except ImportError: # pragma: no cover
# let's try setuptools vendored version
from setuptools._vendor.packaging import ( # type: ignore[no-redef]
requirements as _req,
)
from setuptools._vendor.packaging import requirements as _req # type: ignore
def pep508(value: str) -> bool:
"""See :ref:`PyPA's dependency specifiers <pypa:dependency-specifiers>`
(initially introduced in :pep:`508`).
"""
try:
_req.Requirement(value)
return True
@@ -109,17 +85,14 @@ except ImportError: # pragma: no cover
def pep508_versionspec(value: str) -> bool:
"""Expression that can be used to specify/lock versions (including ranges)
See ``versionspec`` in :ref:`PyPA's dependency specifiers
<pypa:dependency-specifiers>` (initially introduced in :pep:`508`).
"""
"""Expression that can be used to specify/lock versions (including ranges)"""
if any(c in value for c in (";", "]", "@")):
# In PEP 508:
# conditional markers, extras and URL specs are not included in the
# versionspec
return False
# Let's pretend we have a dependency called `requirement` with the given
# version spec, then we can reuse the pep508 function for validation:
# version spec, then we can re-use the pep508 function for validation:
return pep508(f"requirement{value}")
@@ -128,11 +101,6 @@ def pep508_versionspec(value: str) -> bool:
def pep517_backend_reference(value: str) -> bool:
"""See PyPA's specification for defining build-backend references
introduced in :pep:`517#source-trees`.
This is similar to an entry-point reference (e.g., ``package.module:object``).
"""
module, _, obj = value.partition(":")
identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))
return all(python_identifier(i) for i in identifiers if i)
@@ -149,10 +117,10 @@ def _download_classifiers() -> str:
url = "https://pypi.org/pypi?:action=list_classifiers"
context = ssl.create_default_context()
with urlopen(url, context=context) as response: # noqa: S310 (audit URLs)
with urlopen(url, context=context) as response:
headers = Message()
headers["content_type"] = response.getheader("content-type", "text/plain")
return response.read().decode(headers.get_param("charset", "utf-8")) # type: ignore[no-any-return]
return response.read().decode(headers.get_param("charset", "utf-8"))
class _TroveClassifier:
@@ -163,19 +131,14 @@ class _TroveClassifier:
option (classifiers will be validated anyway during the upload to PyPI).
"""
downloaded: typing.Union[None, "Literal[False]", typing.Set[str]]
"""
None => not cached yet
False => unavailable
set => cached values
"""
def __init__(self) -> None:
self.downloaded = None
def __init__(self):
self.downloaded: typing.Union[None, False, typing.Set[str]] = None
self._skip_download = False
# None => not cached yet
# False => cache not available
self.__name__ = "trove_classifier" # Emulate a public function
def _disable_download(self) -> None:
def _disable_download(self):
# This is a private API. Only setuptools has the consent of using it.
self._skip_download = True
@@ -212,37 +175,17 @@ try:
from trove_classifiers import classifiers as _trove_classifiers
def trove_classifier(value: str) -> bool:
"""See https://pypi.org/classifiers/"""
return value in _trove_classifiers or value.lower().startswith("private ::")
except ImportError: # pragma: no cover
trove_classifier = _TroveClassifier()
# -------------------------------------------------------------------------------------
# Stub packages - PEP 561
def pep561_stub_name(value: str) -> bool:
"""Name of a directory containing type stubs.
It must follow the name scheme ``<package>-stubs`` as defined in
:pep:`561#stub-only-packages`.
"""
top, *children = value.split(".")
if not top.endswith("-stubs"):
return False
return python_module_name(".".join([top[: -len("-stubs")], *children]))
# -------------------------------------------------------------------------------------
# Non-PEP related
def url(value: str) -> bool:
"""Valid URL (validation uses :obj:`urllib.parse`).
For maximum compatibility please make sure to include a ``scheme`` prefix
in your URL (e.g. ``http://``).
"""
from urllib.parse import urlparse
try:
@@ -271,59 +214,24 @@ ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)
def python_identifier(value: str) -> bool:
"""Can be used as identifier in Python.
(Validation uses :obj:`str.isidentifier`).
"""
return value.isidentifier()
def python_qualified_identifier(value: str) -> bool:
"""
Python "dotted identifier", i.e. a sequence of :obj:`python_identifier`
concatenated with ``"."`` (e.g.: ``package.module.submodule``).
"""
if value.startswith(".") or value.endswith("."):
return False
return all(python_identifier(m) for m in value.split("."))
def python_module_name(value: str) -> bool:
"""Module name that can be used in an ``import``-statement in Python.
See :obj:`python_qualified_identifier`.
"""
return python_qualified_identifier(value)
def python_module_name_relaxed(value: str) -> bool:
"""Similar to :obj:`python_module_name`, but relaxed to also accept
dash characters (``-``) and cover special cases like ``pip-run``.
It is recommended, however, that beginners avoid dash characters,
as they require advanced knowledge about Python internals.
The following are disallowed:
* names starting/ending in dashes,
* names ending in ``-stubs`` (potentially collide with :obj:`pep561_stub_name`).
"""
if value.startswith("-") or value.endswith("-"):
return False
if value.endswith("-stubs"):
return False # Avoid collision with PEP 561
return python_module_name(value.replace("-", "_"))
def python_entrypoint_group(value: str) -> bool:
"""See ``Data model > group`` in the :ref:`PyPA's entry-points specification
<pypa:entry-points>`.
"""
return ENTRYPOINT_GROUP_REGEX.match(value) is not None
def python_entrypoint_name(value: str) -> bool:
"""See ``Data model > name`` in the :ref:`PyPA's entry-points specification
<pypa:entry-points>`.
"""
if not ENTRYPOINT_REGEX.match(value):
return False
if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
@@ -334,13 +242,6 @@ def python_entrypoint_name(value: str) -> bool:
def python_entrypoint_reference(value: str) -> bool:
"""Reference to a Python object using in the format::
importable.module:object.attr
See ``Data model >object reference`` in the :ref:`PyPA's entry-points specification
<pypa:entry-points>`.
"""
module, _, rest = value.partition(":")
if "[" in rest:
obj, _, extras_ = rest.partition("[")
@@ -354,49 +255,5 @@ def python_entrypoint_reference(value: str) -> bool:
obj = rest
module_parts = module.split(".")
identifiers = _chain(module_parts, obj.split(".")) if rest else iter(module_parts)
identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts
return all(python_identifier(i.strip()) for i in identifiers)
def uint8(value: builtins.int) -> bool:
r"""Unsigned 8-bit integer (:math:`0 \leq x < 2^8`)"""
return 0 <= value < 2**8
def uint16(value: builtins.int) -> bool:
r"""Unsigned 16-bit integer (:math:`0 \leq x < 2^{16}`)"""
return 0 <= value < 2**16
def uint(value: builtins.int) -> bool:
r"""Unsigned 64-bit integer (:math:`0 \leq x < 2^{64}`)"""
return 0 <= value < 2**64
def int(value: builtins.int) -> bool:
r"""Signed 64-bit integer (:math:`-2^{63} \leq x < 2^{63}`)"""
return -(2**63) <= value < 2**63
try:
from packaging import licenses as _licenses
def SPDX(value: str) -> bool:
"""See :ref:`PyPA's License-Expression specification
<pypa:core-metadata-license-expression>` (added in :pep:`639`).
"""
try:
_licenses.canonicalize_license_expression(value)
return True
except _licenses.InvalidLicenseExpression:
return False
except ImportError: # pragma: no cover
_logger.warning(
"Could not find an up-to-date installation of `packaging`. "
"License expressions might not be validated. "
"To enforce validation, please install `packaging>=24.2`."
)
def SPDX(value: str) -> bool:
return True
server/.venv/lib/python3.11/site-packages/setuptools/config/distutils.schema.json
-26
View File
@@ -1,26 +0,0 @@
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html",
"title": "``tool.distutils`` table",
"$$description": [
"**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``",
"subtables to configure arguments for ``distutils`` commands.",
"Originally, ``distutils`` allowed developers to configure arguments for",
"``setup.py`` commands via `distutils configuration files",
"<https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html>`_.",
"See also `the old Python docs <https://docs.python.org/3.11/install/>_`."
],
"type": "object",
"properties": {
"global": {
"type": "object",
"description": "Global options applied to all ``distutils`` commands"
}
},
"patternProperties": {
".+": {"type": "object"}
},
"$comment": "TODO: Is there a practical way of making this schema more specific?"
}
server/.venv/lib/python3.11/site-packages/setuptools/config/expand.py
+124 -114
View File
@@ -17,55 +17,65 @@ functions among several configuration file formats.
**PRIVATE MODULE**: API reserved for setuptools internal usage only.
"""
from __future__ import annotations
import ast
import importlib
import io
import os
import pathlib
import sys
from collections.abc import Iterable, Iterator, Mapping
from configparser import ConfigParser
import warnings
from glob import iglob
from importlib.machinery import ModuleSpec, all_suffixes
from configparser import ConfigParser
from importlib.machinery import ModuleSpec
from itertools import chain
from typing import (
TYPE_CHECKING,
Callable,
Dict,
Iterable,
Iterator,
List,
Mapping,
Optional,
Tuple,
TypeVar,
Union,
cast
)
from pathlib import Path
from types import ModuleType, TracebackType
from typing import TYPE_CHECKING, Any, Callable, TypeVar
from .. import _static
from .._path import StrPath, same_path as _same_path
from ..discovery import find_package_path
from ..warnings import SetuptoolsWarning
from types import ModuleType
from distutils.errors import DistutilsOptionError
from .._path import same_path as _same_path
if TYPE_CHECKING:
from typing_extensions import Self
from setuptools.dist import Distribution
from setuptools.dist import Distribution # noqa
from setuptools.discovery import ConfigDiscovery # noqa
from distutils.dist import DistributionMetadata # noqa
chain_iter = chain.from_iterable
_Path = Union[str, os.PathLike]
_K = TypeVar("_K")
_V_co = TypeVar("_V_co", covariant=True)
_V = TypeVar("_V", covariant=True)
class StaticModule:
"""Proxy to a module object that avoids executing arbitrary code."""
def __init__(self, name: str, spec: ModuleSpec) -> None:
module = ast.parse(pathlib.Path(spec.origin).read_bytes()) # type: ignore[arg-type] # Let it raise an error on None
def __init__(self, name: str, spec: ModuleSpec):
module = ast.parse(pathlib.Path(spec.origin).read_bytes())
vars(self).update(locals())
del self.self
def _find_assignments(self) -> Iterator[tuple[ast.AST, ast.AST]]:
def _find_assignments(self) -> Iterator[Tuple[ast.AST, ast.AST]]:
for statement in self.module.body:
if isinstance(statement, ast.Assign):
yield from ((target, statement.value) for target in statement.targets)
elif isinstance(statement, ast.AnnAssign) and statement.value:
yield (statement.target, statement.value)
def __getattr__(self, attr: str):
def __getattr__(self, attr):
"""Attempt to load an attribute "statically", via :func:`ast.literal_eval`."""
try:
return next(
@@ -78,8 +88,8 @@ class StaticModule:
def glob_relative(
patterns: Iterable[str], root_dir: StrPath | None = None
) -> list[str]:
patterns: Iterable[str], root_dir: Optional[_Path] = None
) -> List[str]:
"""Expand the list of glob patterns, but preserving relative paths.
:param list[str] patterns: List of glob patterns
@@ -91,16 +101,14 @@ def glob_relative(
expanded_values = []
root_dir = root_dir or os.getcwd()
for value in patterns:
# Has globby characters?
if any(char in value for char in glob_characters):
# then expand the glob pattern while keeping paths *relative*:
glob_path = os.path.abspath(os.path.join(root_dir, value))
expanded_values.extend(
sorted(
os.path.relpath(path, root_dir).replace(os.sep, "/")
for path in iglob(glob_path, recursive=True)
)
)
expanded_values.extend(sorted(
os.path.relpath(path, root_dir).replace(os.sep, "/")
for path in iglob(glob_path, recursive=True)))
else:
# take the value as-is
@@ -110,16 +118,14 @@ def glob_relative(
return expanded_values
def read_files(
filepaths: StrPath | Iterable[StrPath], root_dir: StrPath | None = None
) -> str:
def read_files(filepaths: Union[str, bytes, Iterable[_Path]], root_dir=None) -> str:
"""Return the content of the files concatenated using ``\n`` as str
This function is sandboxed and won't reach anything outside ``root_dir``
(By default ``root_dir`` is the current directory).
"""
from more_itertools import always_iterable
from setuptools.extern.more_itertools import always_iterable
root_dir = os.path.abspath(root_dir or os.getcwd())
_filepaths = (os.path.join(root_dir, path) for path in always_iterable(filepaths))
@@ -130,20 +136,20 @@ def read_files(
)
def _filter_existing_files(filepaths: Iterable[StrPath]) -> Iterator[StrPath]:
def _filter_existing_files(filepaths: Iterable[_Path]) -> Iterator[_Path]:
for path in filepaths:
if os.path.isfile(path):
yield path
else:
SetuptoolsWarning.emit(f"File {path!r} cannot be found")
warnings.warn(f"File {path!r} cannot be found")
def _read_file(filepath: bytes | StrPath) -> str:
with open(filepath, encoding='utf-8') as f:
def _read_file(filepath: Union[bytes, _Path]) -> str:
with io.open(filepath, encoding='utf-8') as f:
return f.read()
def _assert_local(filepath: StrPath, root_dir: str):
def _assert_local(filepath: _Path, root_dir: str):
if Path(os.path.abspath(root_dir)) not in Path(os.path.abspath(filepath)).parents:
msg = f"Cannot access {filepath!r} (or anything outside {root_dir!r})"
raise DistutilsOptionError(msg)
@@ -153,9 +159,9 @@ def _assert_local(filepath: StrPath, root_dir: str):
def read_attr(
attr_desc: str,
package_dir: Mapping[str, str] | None = None,
root_dir: StrPath | None = None,
) -> Any:
package_dir: Optional[Mapping[str, str]] = None,
root_dir: Optional[_Path] = None
):
"""Reads the value of an attribute from a module.
This function will try to read the attributed statically first
@@ -178,20 +184,18 @@ def read_attr(
attr_name = attrs_path.pop()
module_name = '.'.join(attrs_path)
module_name = module_name or '__init__'
path = _find_module(module_name, package_dir, root_dir)
_parent_path, path, module_name = _find_module(module_name, package_dir, root_dir)
spec = _find_spec(module_name, path)
try:
value = getattr(StaticModule(module_name, spec), attr_name)
# XXX: Is marking as static contents coming from modules too optimistic?
return _static.attempt_conversion(value)
return getattr(StaticModule(module_name, spec), attr_name)
except Exception:
# fallback to evaluate module
module = _load_spec(spec, module_name)
return getattr(module, attr_name)
def _find_spec(module_name: str, module_path: StrPath | None) -> ModuleSpec:
def _find_spec(module_name: str, module_path: Optional[_Path]) -> ModuleSpec:
spec = importlib.util.spec_from_file_location(module_name, module_path)
spec = spec or importlib.util.find_spec(module_name)
@@ -207,38 +211,48 @@ def _load_spec(spec: ModuleSpec, module_name: str) -> ModuleType:
return sys.modules[name]
module = importlib.util.module_from_spec(spec)
sys.modules[name] = module # cache (it also ensures `==` works on loaded items)
assert spec.loader is not None
spec.loader.exec_module(module)
spec.loader.exec_module(module) # type: ignore
return module
def _find_module(
module_name: str, package_dir: Mapping[str, str] | None, root_dir: StrPath
) -> str | None:
"""Find the path to the module named ``module_name``,
considering the ``package_dir`` in the build configuration and ``root_dir``.
>>> tmp = getfixture('tmpdir')
>>> _ = tmp.ensure("a/b/c.py")
>>> _ = tmp.ensure("a/b/d/__init__.py")
>>> r = lambda x: x.replace(str(tmp), "tmp").replace(os.sep, "/")
>>> r(_find_module("a.b.c", None, tmp))
'tmp/a/b/c.py'
>>> r(_find_module("f.g.h", {"": "1", "f": "2", "f.g": "3", "f.g.h": "a/b/d"}, tmp))
'tmp/a/b/d/__init__.py'
module_name: str, package_dir: Optional[Mapping[str, str]], root_dir: _Path
) -> Tuple[_Path, Optional[str], str]:
"""Given a module (that could normally be imported by ``module_name``
after the build is complete), find the path to the parent directory where
it is contained and the canonical name that could be used to import it
considering the ``package_dir`` in the build configuration and ``root_dir``
"""
path_start = find_package_path(module_name, package_dir or {}, root_dir)
candidates = chain.from_iterable(
(f"{path_start}{ext}", os.path.join(path_start, f"__init__{ext}"))
for ext in all_suffixes()
parent_path = root_dir
module_parts = module_name.split('.')
if package_dir:
if module_parts[0] in package_dir:
# A custom path was specified for the module we want to import
custom_path = package_dir[module_parts[0]]
parts = custom_path.rsplit('/', 1)
if len(parts) > 1:
parent_path = os.path.join(root_dir, parts[0])
parent_module = parts[1]
else:
parent_module = custom_path
module_name = ".".join([parent_module, *module_parts[1:]])
elif '' in package_dir:
# A custom parent directory was specified for all root modules
parent_path = os.path.join(root_dir, package_dir[''])
path_start = os.path.join(parent_path, *module_name.split("."))
candidates = chain(
(f"{path_start}.py", os.path.join(path_start, "__init__.py")),
iglob(f"{path_start}.*")
)
return next((x for x in candidates if os.path.isfile(x)), None)
module_path = next((x for x in candidates if os.path.isfile(x)), None)
return parent_path, module_path, module_name
def resolve_class(
qualified_class_name: str,
package_dir: Mapping[str, str] | None = None,
root_dir: StrPath | None = None,
package_dir: Optional[Mapping[str, str]] = None,
root_dir: Optional[_Path] = None
) -> Callable:
"""Given a qualified class name, return the associated class object"""
root_dir = root_dir or os.getcwd()
@@ -246,16 +260,16 @@ def resolve_class(
class_name = qualified_class_name[idx + 1 :]
pkg_name = qualified_class_name[:idx]
path = _find_module(pkg_name, package_dir, root_dir)
module = _load_spec(_find_spec(pkg_name, path), pkg_name)
_parent_path, path, module_name = _find_module(pkg_name, package_dir, root_dir)
module = _load_spec(_find_spec(module_name, path), module_name)
return getattr(module, class_name)
def cmdclass(
values: dict[str, str],
package_dir: Mapping[str, str] | None = None,
root_dir: StrPath | None = None,
) -> dict[str, Callable]:
values: Dict[str, str],
package_dir: Optional[Mapping[str, str]] = None,
root_dir: Optional[_Path] = None
) -> Dict[str, Callable]:
"""Given a dictionary mapping command names to strings for qualified class
names, apply :func:`resolve_class` to the dict values.
"""
@@ -265,10 +279,10 @@ def cmdclass(
def find_packages(
*,
namespaces=True,
fill_package_dir: dict[str, str] | None = None,
root_dir: StrPath | None = None,
**kwargs,
) -> list[str]:
fill_package_dir: Optional[Dict[str, str]] = None,
root_dir: Optional[_Path] = None,
**kwargs
) -> List[str]:
"""Works similarly to :func:`setuptools.find_packages`, but with all
arguments given as keyword arguments. Moreover, ``where`` can be given
as a list (the results will be simply concatenated).
@@ -286,19 +300,17 @@ def find_packages(
:rtype: list
"""
from more_itertools import always_iterable, unique_everseen
from setuptools.discovery import construct_package_dir
from setuptools.extern.more_itertools import unique_everseen, always_iterable
# check "not namespaces" first due to python/mypy#6232
if not namespaces:
from setuptools.discovery import PackageFinder
else:
if namespaces:
from setuptools.discovery import PEP420PackageFinder as PackageFinder
else:
from setuptools.discovery import PackageFinder # type: ignore
root_dir = root_dir or os.curdir
where = kwargs.pop('where', ['.'])
packages: list[str] = []
packages: List[str] = []
fill_package_dir = {} if fill_package_dir is None else fill_package_dir
search = list(unique_everseen(always_iterable(where)))
@@ -310,29 +322,35 @@ def find_packages(
pkgs = PackageFinder.find(package_path, **kwargs)
packages.extend(pkgs)
if pkgs and not (
fill_package_dir.get("") == path or os.path.samefile(package_path, root_dir)
fill_package_dir.get("") == path
or os.path.samefile(package_path, root_dir)
):
fill_package_dir.update(construct_package_dir(pkgs, path))
return packages
def _nest_path(parent: StrPath, path: StrPath) -> str:
def _nest_path(parent: _Path, path: _Path) -> str:
path = parent if path in {".", ""} else os.path.join(parent, path)
return os.path.normpath(path)
def version(value: Callable | Iterable[str | int] | str) -> str:
def version(value: Union[Callable, Iterable[Union[str, int]], str]) -> str:
"""When getting the version directly from an attribute,
it should be normalised to string.
"""
_value = value() if callable(value) else value
if callable(value):
value = value()
if isinstance(_value, str):
return _value
if hasattr(_value, '__iter__'):
return '.'.join(map(str, _value))
return f'{_value}'
value = cast(Iterable[Union[str, int]], value)
if not isinstance(value, str):
if hasattr(value, '__iter__'):
value = '.'.join(map(str, value))
else:
value = '%s' % value
return value
def canonic_package_data(package_data: dict) -> dict:
@@ -342,8 +360,8 @@ def canonic_package_data(package_data: dict) -> dict:
def canonic_data_files(
data_files: list | dict, root_dir: StrPath | None = None
) -> list[tuple[str, list[str]]]:
data_files: Union[list, dict], root_dir: Optional[_Path] = None
) -> List[Tuple[str, List[str]]]:
"""For compatibility with ``setup.py``, ``data_files`` should be a list
of pairs instead of a dict.
@@ -358,17 +376,14 @@ def canonic_data_files(
]
def entry_points(
text: str, text_source: str = "entry-points"
) -> dict[str, dict[str, str]]:
def entry_points(text: str, text_source="entry-points") -> Dict[str, dict]:
"""Given the contents of entry-points file,
process it into a 2-level dictionary (``dict[str, dict[str, str]]``).
The first level keys are entry-point groups, the second level keys are
entry-point names, and the second level values are references to objects
(that correspond to the entry-point value).
"""
# Using undocumented behaviour, see python/typeshed#12700
parser = ConfigParser(default_section=None, delimiters=("=",)) # type: ignore[call-overload]
parser = ConfigParser(default_section=None, delimiters=("=",)) # type: ignore
parser.optionxform = str # case sensitive
parser.read_string(text, text_source)
groups = {k: dict(v.items()) for k, v in parser.items()}
@@ -386,7 +401,7 @@ class EnsurePackagesDiscovered:
and those might not have been processed yet.
"""
def __init__(self, distribution: Distribution) -> None:
def __init__(self, distribution: "Distribution"):
self._dist = distribution
self._called = False
@@ -396,15 +411,10 @@ class EnsurePackagesDiscovered:
self._called = True
self._dist.set_defaults(name=False) # Skip name, we can still be parsing
def __enter__(self) -> Self:
def __enter__(self):
return self
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_value: BaseException | None,
traceback: TracebackType | None,
):
def __exit__(self, _exc_type, _exc_value, _traceback):
if self._called:
self._dist.set_defaults.analyse_name() # Now we can set a default name
@@ -419,7 +429,7 @@ class EnsurePackagesDiscovered:
return LazyMappingProxy(self._get_package_dir)
class LazyMappingProxy(Mapping[_K, _V_co]):
class LazyMappingProxy(Mapping[_K, _V]):
"""Mapping proxy that delays resolving the target object, until really needed.
>>> def obtain_mapping():
@@ -433,16 +443,16 @@ class LazyMappingProxy(Mapping[_K, _V_co]):
'other value'
"""
def __init__(self, obtain_mapping_value: Callable[[], Mapping[_K, _V_co]]) -> None:
def __init__(self, obtain_mapping_value: Callable[[], Mapping[_K, _V]]):
self._obtain = obtain_mapping_value
self._value: Mapping[_K, _V_co] | None = None
self._value: Optional[Mapping[_K, _V]] = None
def _target(self) -> Mapping[_K, _V_co]:
def _target(self) -> Mapping[_K, _V]:
if self._value is None:
self._value = self._obtain()
return self._value
def __getitem__(self, key: _K) -> _V_co:
def __getitem__(self, key: _K) -> _V:
return self._target()[key]
def __len__(self) -> int:
server/.venv/lib/python3.11/site-packages/setuptools/config/pyprojecttoml.py
+128 -103
View File
@@ -2,51 +2,41 @@
Load setuptools configuration from ``pyproject.toml`` files.
**PRIVATE MODULE**: API reserved for setuptools internal usage only.
To read project metadata, consider using
``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
For simple scenarios, you can also try parsing the file directly
with the help of ``tomllib`` or ``tomli``.
"""
from __future__ import annotations
import logging
import os
from collections.abc import Mapping
import warnings
from contextlib import contextmanager
from functools import partial
from types import TracebackType
from typing import TYPE_CHECKING, Any, Callable
from typing import TYPE_CHECKING, Callable, Dict, Optional, Mapping, Union
from setuptools.errors import FileError, OptionError
from .._path import StrPath
from ..errors import FileError, InvalidConfigError
from ..warnings import SetuptoolsWarning
from . import expand as _expand
from ._apply_pyprojecttoml import _PREVIOUSLY_DEFINED, _MissingDynamic, apply as _apply
from ._apply_pyprojecttoml import apply as _apply
from ._apply_pyprojecttoml import _PREVIOUSLY_DEFINED, _WouldIgnoreField
if TYPE_CHECKING:
from typing_extensions import Self
from setuptools.dist import Distribution
from setuptools.dist import Distribution # noqa
_Path = Union[str, os.PathLike]
_logger = logging.getLogger(__name__)
def load_file(filepath: StrPath) -> dict:
from ..compat.py310 import tomllib
def load_file(filepath: _Path) -> dict:
from setuptools.extern import tomli # type: ignore
with open(filepath, "rb") as file:
return tomllib.load(file)
return tomli.load(file)
def validate(config: dict, filepath: StrPath) -> bool:
def validate(config: dict, filepath: _Path) -> bool:
from . import _validate_pyproject as validator
trove_classifier = validator.FORMAT_FUNCTIONS.get("trove-classifier")
if hasattr(trove_classifier, "_disable_download"):
# Improve reproducibility by default. See abravalheri/validate-pyproject#31
trove_classifier._disable_download() # type: ignore[union-attr]
# Improve reproducibility by default. See issue 31 for validate-pyproject.
trove_classifier._disable_download() # type: ignore
try:
return validator.validate(config)
@@ -62,10 +52,10 @@ def validate(config: dict, filepath: StrPath) -> bool:
def apply_configuration(
dist: Distribution,
filepath: StrPath,
ignore_option_errors: bool = False,
) -> Distribution:
dist: "Distribution",
filepath: _Path,
ignore_option_errors=False,
) -> "Distribution":
"""Apply the configuration from a ``pyproject.toml`` file into an existing
distribution object.
"""
@@ -74,11 +64,11 @@ def apply_configuration(
def read_configuration(
filepath: StrPath,
expand: bool = True,
ignore_option_errors: bool = False,
dist: Distribution | None = None,
) -> dict[str, Any]:
filepath: _Path,
expand=True,
ignore_option_errors=False,
dist: Optional["Distribution"] = None,
):
"""Read given configuration file and returns options from it as a dict.
:param str|unicode filepath: Path to configuration file in the ``pyproject.toml``
@@ -94,8 +84,8 @@ def read_configuration(
:param Distribution|None: Distribution object to which the configuration refers.
If not given a dummy object will be created and discarded after the
configuration is read. This is used for auto-discovery of packages and in the
case a dynamic configuration (e.g. ``attr`` or ``cmdclass``) is expanded.
configuration is read. This is used for auto-discovery of packages in the case
a dynamic configuration (e.g. ``attr`` or ``cmdclass``) is expanded.
When ``expand=False`` this object is simply ignored.
:rtype: dict
@@ -112,18 +102,17 @@ def read_configuration(
if not asdict or not (project_table or setuptools_table):
return {} # User is not using pyproject to configure setuptools
if "setuptools" in asdict.get("tools", {}):
# let the user know they probably have a typo in their metadata
_ToolsTypoInMetadata.emit()
if "distutils" in tool_table:
_ExperimentalConfiguration.emit(subject="[tool.distutils]")
if setuptools_table:
# TODO: Remove the following once the feature stabilizes:
msg = "Support for `[tool.setuptools]` in `pyproject.toml` is still *beta*."
warnings.warn(msg, _BetaConfiguration)
# There is an overall sense in the community that making include_package_data=True
# the default would be an improvement.
# `ini2toml` backfills include_package_data=False when nothing is explicitly given,
# therefore setting a default here is backwards compatible.
if dist and dist.include_package_data is not None:
orig_setuptools_table = setuptools_table.copy()
if dist and getattr(dist, "include_package_data") is not None:
setuptools_table.setdefault("include-package-data", dist.include_package_data)
else:
setuptools_table.setdefault("include-package-data", True)
@@ -131,13 +120,20 @@ def read_configuration(
asdict["tool"] = tool_table
tool_table["setuptools"] = setuptools_table
if "ext-modules" in setuptools_table:
_ExperimentalConfiguration.emit(subject="[tool.setuptools.ext-modules]")
with _ignore_errors(ignore_option_errors):
try:
# Don't complain about unrelated errors (e.g. tools not using the "tool" table)
subset = {"project": project_table, "tool": {"setuptools": setuptools_table}}
validate(subset, filepath)
except Exception as ex:
# TODO: Remove the following once the feature stabilizes:
if _skip_bad_config(project_table, orig_setuptools_table, dist):
return {}
# TODO: After the previous statement is removed the try/except can be replaced
# by the _ignore_errors context manager.
if ignore_option_errors:
_logger.debug(f"ignored error: {ex.__class__.__name__} - {ex}")
else:
raise # re-raise exception
if expand:
root_dir = os.path.dirname(filepath)
@@ -146,11 +142,41 @@ def read_configuration(
return asdict
def _skip_bad_config(
project_cfg: dict, setuptools_cfg: dict, dist: Optional["Distribution"]
) -> bool:
"""Be temporarily forgiving with invalid ``pyproject.toml``"""
# See pypa/setuptools#3199 and pypa/cibuildwheel#1064
if dist is None or (
dist.metadata.name is None
and dist.metadata.version is None
and dist.install_requires is None
):
# It seems that the build is not getting any configuration from other places
return False
if setuptools_cfg:
# If `[tool.setuptools]` is set, then `pyproject.toml` config is intentional
return False
given_config = set(project_cfg.keys())
popular_subset = {"name", "version", "python_requires", "requires-python"}
if given_config <= popular_subset:
# It seems that the docs in cibuildtool has been inadvertently encouraging users
# to create `pyproject.toml` files that are not compliant with the standards.
# Let's be forgiving for the time being.
warnings.warn(_InvalidFile.message(), _InvalidFile, stacklevel=2)
return True
return False
def expand_configuration(
config: dict,
root_dir: StrPath | None = None,
root_dir: Optional[_Path] = None,
ignore_option_errors: bool = False,
dist: Distribution | None = None,
dist: Optional["Distribution"] = None,
) -> dict:
"""Given a configuration with unresolved fields (e.g. dynamic, cmdclass, ...)
find their final values.
@@ -173,10 +199,10 @@ class _ConfigExpander:
def __init__(
self,
config: dict,
root_dir: StrPath | None = None,
root_dir: Optional[_Path] = None,
ignore_option_errors: bool = False,
dist: Distribution | None = None,
) -> None:
dist: Optional["Distribution"] = None,
):
self.config = config
self.root_dir = root_dir or os.getcwd()
self.project_cfg = config.get("project", {})
@@ -185,9 +211,8 @@ class _ConfigExpander:
self.dynamic_cfg = self.setuptools_cfg.get("dynamic", {})
self.ignore_option_errors = ignore_option_errors
self._dist = dist
self._referenced_files = set[str]()
def _ensure_dist(self) -> Distribution:
def _ensure_dist(self) -> "Distribution":
from setuptools.dist import Distribution
attrs = {"src_root": self.root_dir, "name": self.project_cfg.get("name", None)}
@@ -216,7 +241,6 @@ class _ConfigExpander:
self._expand_cmdclass(package_dir)
self._expand_all_dynamic(dist, package_dir)
dist._referenced_files.update(self._referenced_files)
return self.config
def _expand_packages(self):
@@ -240,7 +264,7 @@ class _ConfigExpander:
cmdclass = partial(_expand.cmdclass, package_dir=package_dir, root_dir=root_dir)
self._process_field(self.setuptools_cfg, "cmdclass", cmdclass)
def _expand_all_dynamic(self, dist: Distribution, package_dir: Mapping[str, str]):
def _expand_all_dynamic(self, dist: "Distribution", package_dir: Mapping[str, str]):
special = ( # need special handling
"version",
"readme",
@@ -270,7 +294,7 @@ class _ConfigExpander:
updates = {k: v for k, v in obtained_dynamic.items() if v is not None}
self.project_cfg.update(updates)
def _ensure_previously_set(self, dist: Distribution, field: str):
def _ensure_previously_set(self, dist: "Distribution", field: str):
previous = _PREVIOUSLY_DEFINED[field](dist)
if previous is None and not self.ignore_option_errors:
msg = (
@@ -278,24 +302,21 @@ class _ConfigExpander:
"Some dynamic fields need to be specified via `tool.setuptools.dynamic`"
"\nothers must be specified via the equivalent attribute in `setup.py`."
)
raise InvalidConfigError(msg)
raise OptionError(msg)
def _expand_directive(
self, specifier: str, directive, package_dir: Mapping[str, str]
):
from more_itertools import always_iterable
with _ignore_errors(self.ignore_option_errors):
root_dir = self.root_dir
if "file" in directive:
self._referenced_files.update(always_iterable(directive["file"]))
return _expand.read_files(directive["file"], root_dir)
if "attr" in directive:
return _expand.read_attr(directive["attr"], package_dir, root_dir)
raise ValueError(f"invalid `{specifier}`: {directive!r}")
return None
def _obtain(self, dist: Distribution, field: str, package_dir: Mapping[str, str]):
def _obtain(self, dist: "Distribution", field: str, package_dir: Mapping[str, str]):
if field in self.dynamic_cfg:
return self._expand_directive(
f"tool.setuptools.dynamic.{field}",
@@ -305,33 +326,29 @@ class _ConfigExpander:
self._ensure_previously_set(dist, field)
return None
def _obtain_version(self, dist: Distribution, package_dir: Mapping[str, str]):
def _obtain_version(self, dist: "Distribution", package_dir: Mapping[str, str]):
# Since plugins can set version, let's silently skip if it cannot be obtained
if "version" in self.dynamic and "version" in self.dynamic_cfg:
return _expand.version(
# We already do an early check for the presence of "version"
self._obtain(dist, "version", package_dir) # pyright: ignore[reportArgumentType]
)
return _expand.version(self._obtain(dist, "version", package_dir))
return None
def _obtain_readme(self, dist: Distribution) -> dict[str, str] | None:
def _obtain_readme(self, dist: "Distribution") -> Optional[Dict[str, str]]:
if "readme" not in self.dynamic:
return None
dynamic_cfg = self.dynamic_cfg
if "readme" in dynamic_cfg:
return {
# We already do an early check for the presence of "readme"
"text": self._obtain(dist, "readme", {}),
"content-type": dynamic_cfg["readme"].get("content-type", "text/x-rst"),
} # pyright: ignore[reportReturnType]
}
self._ensure_previously_set(dist, "readme")
return None
def _obtain_entry_points(
self, dist: Distribution, package_dir: Mapping[str, str]
) -> dict[str, dict[str, Any]] | None:
self, dist: "Distribution", package_dir: Mapping[str, str]
) -> Optional[Dict[str, dict]]:
fields = ("entry-points", "scripts", "gui-scripts")
if not any(field in self.dynamic for field in fields):
return None
@@ -341,14 +358,16 @@ class _ConfigExpander:
return None
groups = _expand.entry_points(text)
# Any is str | dict[str, str], but causes variance issues
expanded: dict[str, dict[str, Any]] = {"entry-points": groups}
expanded = {"entry-points": groups}
def _set_scripts(field: str, group: str):
if group in groups:
value = groups.pop(group)
if field not in self.dynamic:
raise InvalidConfigError(_MissingDynamic.details(field, value))
msg = _WouldIgnoreField.message(field, value)
warnings.warn(msg, _WouldIgnoreField)
# TODO: Don't set field when support for pyproject.toml stabilizes
# instead raise an error as specified in PEP 621
expanded[field] = value
_set_scripts("scripts", "console_scripts")
@@ -356,34 +375,32 @@ class _ConfigExpander:
return expanded
def _obtain_classifiers(self, dist: Distribution):
def _obtain_classifiers(self, dist: "Distribution"):
if "classifiers" in self.dynamic:
value = self._obtain(dist, "classifiers", {})
if value:
return value.splitlines()
return None
def _obtain_dependencies(self, dist: Distribution):
def _obtain_dependencies(self, dist: "Distribution"):
if "dependencies" in self.dynamic:
value = self._obtain(dist, "dependencies", {})
if value:
return _parse_requirements_list(value)
return None
def _obtain_optional_dependencies(self, dist: Distribution):
def _obtain_optional_dependencies(self, dist: "Distribution"):
if "optional-dependencies" not in self.dynamic:
return None
if "optional-dependencies" in self.dynamic_cfg:
optional_dependencies_map = self.dynamic_cfg["optional-dependencies"]
assert isinstance(optional_dependencies_map, dict)
return {
group: _parse_requirements_list(
self._expand_directive(
f"tool.setuptools.dynamic.optional-dependencies.{group}",
directive,
{},
)
)
group: _parse_requirements_list(self._expand_directive(
f"tool.setuptools.dynamic.optional-dependencies.{group}",
directive,
{},
))
for group, directive in optional_dependencies_map.items()
}
self._ensure_previously_set(dist, "optional-dependencies")
@@ -412,18 +429,18 @@ def _ignore_errors(ignore_option_errors: bool):
class _EnsurePackagesDiscovered(_expand.EnsurePackagesDiscovered):
def __init__(
self, distribution: Distribution, project_cfg: dict, setuptools_cfg: dict
) -> None:
self, distribution: "Distribution", project_cfg: dict, setuptools_cfg: dict
):
super().__init__(distribution)
self._project_cfg = project_cfg
self._setuptools_cfg = setuptools_cfg
def __enter__(self) -> Self:
def __enter__(self):
"""When entering the context, the values of ``packages``, ``py_modules`` and
``package_dir`` that are missing in ``dist`` are copied from ``setuptools_cfg``.
"""
dist, cfg = self._dist, self._setuptools_cfg
package_dir: dict[str, str] = cfg.setdefault("package-dir", {})
package_dir: Dict[str, str] = cfg.setdefault("package-dir", {})
package_dir.update(dist.package_dir or {})
dist.package_dir = package_dir # needs to be the same object
@@ -440,12 +457,7 @@ class _EnsurePackagesDiscovered(_expand.EnsurePackagesDiscovered):
return super().__enter__()
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_value: BaseException | None,
traceback: TracebackType | None,
) -> None:
def __exit__(self, exc_type, exc_value, traceback):
"""When exiting the context, if values of ``packages``, ``py_modules`` and
``package_dir`` are missing in ``setuptools_cfg``, copy from ``dist``.
"""
@@ -455,14 +467,27 @@ class _EnsurePackagesDiscovered(_expand.EnsurePackagesDiscovered):
return super().__exit__(exc_type, exc_value, traceback)
class _ExperimentalConfiguration(SetuptoolsWarning):
_SUMMARY = (
"`{subject}` in `pyproject.toml` is still *experimental* "
"and likely to change in future releases."
)
class _BetaConfiguration(UserWarning):
"""Explicitly inform users that some `pyproject.toml` configuration is *beta*"""
class _ToolsTypoInMetadata(SetuptoolsWarning):
_SUMMARY = (
"Ignoring [tools.setuptools] in pyproject.toml, did you mean [tool.setuptools]?"
)
class _InvalidFile(UserWarning):
"""The given `pyproject.toml` file is invalid and would be ignored.
!!\n\n
############################
# Invalid `pyproject.toml` #
############################
Any configurations in `pyproject.toml` will be ignored.
Please note that future releases of setuptools will halt the build process
if an invalid file is given.
To prevent setuptools from considering `pyproject.toml` please
DO NOT include the `[project]` or `[tool.setuptools]` tables in your file.
\n\n!!
"""
@classmethod
def message(cls):
from inspect import cleandoc
return cleandoc(cls.__doc__)
server/.venv/lib/python3.11/site-packages/setuptools/config/setupcfg.py
+164 -182
View File
@@ -2,53 +2,45 @@
Load setuptools configuration from ``setup.cfg`` files.
**API will be made private in the future**
To read project metadata, consider using
``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
For simple scenarios, you can also try parsing the file directly
with the help of ``configparser``.
"""
from __future__ import annotations
import os
import contextlib
import functools
import os
import warnings
from collections import defaultdict
from collections.abc import Iterable, Iterator
from functools import partial, wraps
from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, TypeVar, cast
from functools import partial
from functools import wraps
from typing import (TYPE_CHECKING, Callable, Any, Dict, Generic, Iterable, List,
Optional, Tuple, TypeVar, Union)
from packaging.markers import default_environment as marker_env
from packaging.requirements import InvalidRequirement, Requirement
from packaging.version import InvalidVersion, Version
from distutils.errors import DistutilsOptionError, DistutilsFileError
from setuptools.extern.packaging.requirements import Requirement, InvalidRequirement
from setuptools.extern.packaging.version import Version, InvalidVersion
from setuptools.extern.packaging.specifiers import SpecifierSet
from setuptools._deprecation_warning import SetuptoolsDeprecationWarning
from .. import _static
from .._path import StrPath
from ..errors import FileError, OptionError
from ..warnings import SetuptoolsDeprecationWarning
from . import expand
if TYPE_CHECKING:
from typing_extensions import TypeAlias
from setuptools.dist import Distribution # noqa
from distutils.dist import DistributionMetadata # noqa
from setuptools.dist import Distribution
from distutils.dist import DistributionMetadata
SingleCommandOptions: TypeAlias = dict[str, tuple[str, Any]]
_Path = Union[str, os.PathLike]
SingleCommandOptions = Dict["str", Tuple["str", Any]]
"""Dict that associate the name of the options of a particular command to a
tuple. The first element of the tuple indicates the origin of the option value
(e.g. the name of the configuration file where it was read from),
while the second element of the tuple is the option value itself
"""
AllCommandOptions: TypeAlias = dict[str, SingleCommandOptions]
"""cmd name => its options"""
Target = TypeVar("Target", "Distribution", "DistributionMetadata")
AllCommandOptions = Dict["str", SingleCommandOptions] # cmd name => its options
Target = TypeVar("Target", bound=Union["Distribution", "DistributionMetadata"])
def read_configuration(
filepath: StrPath, find_others: bool = False, ignore_option_errors: bool = False
filepath: _Path,
find_others=False,
ignore_option_errors=False
) -> dict:
"""Read given configuration file and returns options from it as a dict.
@@ -73,7 +65,7 @@ def read_configuration(
return configuration_to_dict(handlers)
def apply_configuration(dist: Distribution, filepath: StrPath) -> Distribution:
def apply_configuration(dist: "Distribution", filepath: _Path) -> "Distribution":
"""Apply the configuration from a ``setup.cfg`` file into an existing
distribution object.
"""
@@ -83,26 +75,24 @@ def apply_configuration(dist: Distribution, filepath: StrPath) -> Distribution:
def _apply(
dist: Distribution,
filepath: StrPath,
other_files: Iterable[StrPath] = (),
dist: "Distribution", filepath: _Path,
other_files: Iterable[_Path] = (),
ignore_option_errors: bool = False,
) -> tuple[ConfigMetadataHandler, ConfigOptionsHandler]:
) -> Tuple["ConfigHandler", ...]:
"""Read configuration from ``filepath`` and applies to the ``dist`` object."""
from setuptools.dist import _Distribution
filepath = os.path.abspath(filepath)
if not os.path.isfile(filepath):
raise FileError(f'Configuration file {filepath} does not exist.')
raise DistutilsFileError('Configuration file %s does not exist.' % filepath)
current_directory = os.getcwd()
os.chdir(os.path.dirname(filepath))
filenames = [*other_files, filepath]
try:
# TODO: Temporary cast until mypy 1.12 is released with upstream fixes from typeshed
_Distribution.parse_config_files(dist, filenames=cast(list[str], filenames))
_Distribution.parse_config_files(dist, filenames=filenames)
handlers = parse_configuration(
dist, dist.command_options, ignore_option_errors=ignore_option_errors
)
@@ -113,26 +103,22 @@ def _apply(
return handlers
def _get_option(target_obj: Distribution | DistributionMetadata, key: str):
def _get_option(target_obj: Target, key: str):
"""
Given a target object and option key, get that option from
the target object, either through a get_{key} method or
from an attribute directly.
"""
getter_name = f'get_{key}'
getter_name = 'get_{key}'.format(**locals())
by_attribute = functools.partial(getattr, target_obj, key)
getter = getattr(target_obj, getter_name, by_attribute)
return getter()
def configuration_to_dict(
handlers: Iterable[
ConfigHandler[Distribution] | ConfigHandler[DistributionMetadata]
],
) -> dict:
def configuration_to_dict(handlers: Tuple["ConfigHandler", ...]) -> dict:
"""Returns configuration data gathered by given handlers as a dict.
:param Iterable[ConfigHandler] handlers: Handlers list,
:param list[ConfigHandler] handlers: Handlers list,
usually from parse_configuration()
:rtype: dict
@@ -148,10 +134,10 @@ def configuration_to_dict(
def parse_configuration(
distribution: Distribution,
distribution: "Distribution",
command_options: AllCommandOptions,
ignore_option_errors: bool = False,
) -> tuple[ConfigMetadataHandler, ConfigOptionsHandler]:
ignore_option_errors=False
) -> Tuple["ConfigMetadataHandler", "ConfigOptionsHandler"]:
"""Performs additional parsing of configuration options
for a distribution.
@@ -186,9 +172,6 @@ def parse_configuration(
distribution.src_root,
)
meta.parse()
distribution._referenced_files.update(
options._referenced_files, meta._referenced_files
)
return meta, options
@@ -213,16 +196,17 @@ def _warn_accidental_env_marker_misconfig(label: str, orig_value: str, parsed: l
if "\n" in orig_value or len(parsed) != 2:
return
markers = marker_env().keys()
try:
req = Requirement(parsed[1])
if req.name in markers:
_AmbiguousMarker.emit(field=label, req=parsed[1])
except InvalidRequirement as ex:
if any(parsed[1].startswith(marker) for marker in markers):
msg = _AmbiguousMarker.message(field=label, req=parsed[1])
raise InvalidRequirement(msg) from ex
with contextlib.suppress(InvalidRequirement):
original_requirements_str = ";".join(parsed)
req = Requirement(original_requirements_str)
if req.marker is not None:
msg = (
f"One of the parsed requirements in `{label}` "
f"looks like a valid environment marker: '{parsed[1]}'\n"
"Make sure that the config is correct and check "
"https://setuptools.pypa.io/en/latest/userguide/declarative_config.html#opt-2" # noqa: E501
)
warnings.warn(msg, UserWarning)
class ConfigHandler(Generic[Target]):
@@ -234,7 +218,7 @@ class ConfigHandler(Generic[Target]):
"""
aliases: ClassVar[dict[str, str]] = {}
aliases: Dict[str, str] = {}
"""Options aliases.
For compatibility with various packages. E.g.: d2to1 and pbr.
Note: `-` in keys is replaced with `_` by config parser.
@@ -247,57 +231,65 @@ class ConfigHandler(Generic[Target]):
options: AllCommandOptions,
ignore_option_errors,
ensure_discovered: expand.EnsurePackagesDiscovered,
) -> None:
self.ignore_option_errors = ignore_option_errors
self.target_obj: Target = target_obj
self.sections = dict(self._section_options(options))
self.set_options: list[str] = []
self.ensure_discovered = ensure_discovered
self._referenced_files = set[str]()
"""After parsing configurations, this property will enumerate
all files referenced by the "file:" directive. Private API for setuptools only.
"""
):
sections: AllCommandOptions = {}
@classmethod
def _section_options(
cls, options: AllCommandOptions
) -> Iterator[tuple[str, SingleCommandOptions]]:
for full_name, value in options.items():
pre, _sep, name = full_name.partition(cls.section_prefix)
if pre:
section_prefix = self.section_prefix
for section_name, section_options in options.items():
if not section_name.startswith(section_prefix):
continue
yield name.lstrip('.'), value
section_name = section_name.replace(section_prefix, '').strip('.')
sections[section_name] = section_options
self.ignore_option_errors = ignore_option_errors
self.target_obj = target_obj
self.sections = sections
self.set_options: List[str] = []
self.ensure_discovered = ensure_discovered
@property
def parsers(self):
"""Metadata item name to parser function mapping."""
raise NotImplementedError(
f'{self.__class__.__name__} must provide .parsers property'
'%s must provide .parsers property' % self.__class__.__name__
)
def __setitem__(self, option_name, value) -> None:
def __setitem__(self, option_name, value):
unknown = tuple()
target_obj = self.target_obj
# Translate alias into real name.
option_name = self.aliases.get(option_name, option_name)
try:
current_value = getattr(target_obj, option_name)
except AttributeError as e:
raise KeyError(option_name) from e
current_value = getattr(target_obj, option_name, unknown)
if current_value is unknown:
raise KeyError(option_name)
if current_value:
# Already inhabited. Skipping.
return
try:
parsed = self.parsers.get(option_name, lambda x: x)(value)
except (Exception,) * self.ignore_option_errors:
skip_option = False
parser = self.parsers.get(option_name)
if parser:
try:
value = parser(value)
except Exception:
skip_option = True
if not self.ignore_option_errors:
raise
if skip_option:
return
simple_setter = functools.partial(target_obj.__setattr__, option_name)
setter = getattr(target_obj, f"set_{option_name}", simple_setter)
setter(parsed)
setter = getattr(target_obj, 'set_%s' % option_name, None)
if setter is None:
setattr(target_obj, option_name, value)
else:
setter(value)
self.set_options.append(option_name)
@@ -333,7 +325,9 @@ class ConfigHandler(Generic[Target]):
for line in cls._parse_list(value):
key, sep, val = line.partition(separator)
if sep != separator:
raise OptionError(f"Unable to parse option value to dict: {value}")
raise DistutilsOptionError(
'Unable to parse option value to dict: %s' % value
)
result[key.strip()] = val.strip()
return result
@@ -364,14 +358,15 @@ class ConfigHandler(Generic[Target]):
exclude_directive = 'file:'
if value.startswith(exclude_directive):
raise ValueError(
f'Only strings are accepted for the {key} field, '
'files are not accepted'
'Only strings are accepted for the {0} field, '
'files are not accepted'.format(key)
)
return _static.Str(value)
return value
return parser
def _parse_file(self, value, root_dir: StrPath | None):
@classmethod
def _parse_file(cls, value, root_dir: _Path):
"""Represents value as a string, allowing including text
from nearest files using `file:` directive.
@@ -390,15 +385,13 @@ class ConfigHandler(Generic[Target]):
return value
if not value.startswith(include_directive):
return _static.Str(value)
return value
spec = value[len(include_directive) :]
filepaths = [path.strip() for path in spec.split(',')]
self._referenced_files.update(filepaths)
# XXX: Is marking as static contents coming from files too optimistic?
return _static.Str(expand.read_files(filepaths, root_dir))
filepaths = (path.strip() for path in spec.split(','))
return expand.read_files(filepaths, root_dir)
def _parse_attr(self, value, package_dir, root_dir: StrPath):
def _parse_attr(self, value, package_dir, root_dir: _Path):
"""Represents value as a module attribute.
Examples:
@@ -410,7 +403,7 @@ class ConfigHandler(Generic[Target]):
"""
attr_directive = 'attr:'
if not value.startswith(attr_directive):
return _static.Str(value)
return value
attr_desc = value.replace(attr_directive, '')
@@ -466,58 +459,60 @@ class ConfigHandler(Generic[Target]):
parser = (lambda _, v: values_parser(v)) if values_parser else (lambda _, v: v)
return cls._parse_section_to_dict_with_key(section_options, parser)
def parse_section(self, section_options) -> None:
def parse_section(self, section_options):
"""Parses configuration file section.
:param dict section_options:
"""
for name, (_, value) in section_options.items():
for (name, (_, value)) in section_options.items():
with contextlib.suppress(KeyError):
# Keep silent for a new option may appear anytime.
self[name] = value
def parse(self) -> None:
def parse(self):
"""Parses configuration file items from one
or more related sections.
"""
for section_name, section_options in self.sections.items():
method_postfix = ''
if section_name: # [section.option] variant
method_postfix = f"_{section_name}"
method_postfix = '_%s' % section_name
section_parser_method: Callable | None = getattr(
section_parser_method: Optional[Callable] = getattr(
self,
# Dots in section names are translated into dunderscores.
f'parse_section{method_postfix}'.replace('.', '__'),
('parse_section%s' % method_postfix).replace('.', '__'),
None,
)
if section_parser_method is None:
raise OptionError(
"Unsupported distribution option section: "
f"[{self.section_prefix}.{section_name}]"
raise DistutilsOptionError(
'Unsupported distribution option section: [%s.%s]'
% (self.section_prefix, section_name)
)
section_parser_method(section_options)
def _deprecated_config_handler(self, func, msg, **kw):
def _deprecated_config_handler(self, func, msg, warning_class):
"""this function will wrap around parameters that are deprecated
:param msg: deprecation message
:param warning_class: class of warning exception to be raised
:param func: function to be wrapped around
"""
@wraps(func)
def config_handler(*args, **kwargs):
kw.setdefault("stacklevel", 2)
_DeprecatedConfig.emit("Deprecated config in `setup.cfg`", msg, **kw)
warnings.warn(msg, warning_class)
return func(*args, **kwargs)
return config_handler
class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
section_prefix = 'metadata'
aliases = {
@@ -535,13 +530,13 @@ class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
def __init__(
self,
target_obj: DistributionMetadata,
target_obj: "DistributionMetadata",
options: AllCommandOptions,
ignore_option_errors: bool,
ensure_discovered: expand.EnsurePackagesDiscovered,
package_dir: dict | None = None,
root_dir: StrPath | None = os.curdir,
) -> None:
package_dir: Optional[dict] = None,
root_dir: _Path = os.curdir
):
super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
self.package_dir = package_dir
self.root_dir = root_dir
@@ -549,29 +544,35 @@ class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
@property
def parsers(self):
"""Metadata item name to parser function mapping."""
parse_list_static = self._get_parser_compound(self._parse_list, _static.List)
parse_dict_static = self._get_parser_compound(self._parse_dict, _static.Dict)
parse_list = self._parse_list
parse_file = partial(self._parse_file, root_dir=self.root_dir)
parse_dict = self._parse_dict
exclude_files_parser = self._exclude_files_parser
return {
'author': _static.Str,
'author_email': _static.Str,
'maintainer': _static.Str,
'maintainer_email': _static.Str,
'platforms': parse_list_static,
'keywords': parse_list_static,
'provides': parse_list_static,
'obsoletes': parse_list_static,
'classifiers': self._get_parser_compound(parse_file, parse_list_static),
'platforms': parse_list,
'keywords': parse_list,
'provides': parse_list,
'requires': self._deprecated_config_handler(
parse_list,
"The requires parameter is deprecated, please use "
"install_requires for runtime dependencies.",
SetuptoolsDeprecationWarning,
),
'obsoletes': parse_list,
'classifiers': self._get_parser_compound(parse_file, parse_list),
'license': exclude_files_parser('license'),
'license_files': parse_list_static,
'license_file': self._deprecated_config_handler(
exclude_files_parser('license_file'),
"The license_file parameter is deprecated, "
"use license_files instead.",
SetuptoolsDeprecationWarning,
),
'license_files': parse_list,
'description': parse_file,
'long_description': parse_file,
'long_description_content_type': _static.Str,
'version': self._parse_version, # Cannot be marked as dynamic
'url': _static.Str,
'project_urls': parse_dict_static,
'version': self._parse_version,
'project_urls': parse_dict,
}
def _parse_version(self, value):
@@ -589,11 +590,12 @@ class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
# accidentally include newlines and other unintended content
try:
Version(version)
except InvalidVersion as e:
raise OptionError(
f'Version loaded from {value} does not '
f'comply with PEP 440: {version}'
) from e
except InvalidVersion:
tmpl = (
'Version loaded from {value} does not '
'comply with PEP 440: {version}'
)
raise DistutilsOptionError(tmpl.format(**locals()))
return version
@@ -601,18 +603,19 @@ class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
class ConfigOptionsHandler(ConfigHandler["Distribution"]):
section_prefix = 'options'
def __init__(
self,
target_obj: Distribution,
target_obj: "Distribution",
options: AllCommandOptions,
ignore_option_errors: bool,
ensure_discovered: expand.EnsurePackagesDiscovered,
) -> None:
):
super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
self.root_dir = target_obj.src_root
self.package_dir: dict[str, str] = {} # To be filled by `find_packages`
self.package_dir: Dict[str, str] = {} # To be filled by `find_packages`
@classmethod
def _parse_list_semicolon(cls, value):
@@ -627,20 +630,20 @@ class ConfigOptionsHandler(ConfigHandler["Distribution"]):
_warn_accidental_env_marker_misconfig(label, value, parsed)
# Filter it to only include lines that are not comments. `parse_list`
# will have stripped each line and filtered out empties.
return _static.List(line for line in parsed if not line.startswith("#"))
# ^-- Use `_static.List` to mark a non-`Dynamic` Core Metadata
return [line for line in parsed if not line.startswith("#")]
@property
def parsers(self):
"""Metadata item name to parser function mapping."""
parse_list = self._parse_list
parse_bool = self._parse_bool
parse_dict = self._parse_dict
parse_cmdclass = self._parse_cmdclass
return {
'zip_safe': parse_bool,
'include_package_data': parse_bool,
'package_dir': self._parse_dict,
'package_dir': parse_dict,
'scripts': parse_list,
'eager_resources': parse_list,
'dependency_links': parse_list,
@@ -648,16 +651,17 @@ class ConfigOptionsHandler(ConfigHandler["Distribution"]):
parse_list,
"The namespace_packages parameter is deprecated, "
"consider using implicit namespaces instead (PEP 420).",
# TODO: define due date, see setuptools.dist:check_nsp.
SetuptoolsDeprecationWarning,
),
'install_requires': partial( # Core Metadata
'install_requires': partial(
self._parse_requirements_list, "install_requires"
),
'setup_requires': self._parse_list_semicolon,
'tests_require': self._parse_list_semicolon,
'packages': self._parse_packages,
'entry_points': self._parse_file_in_root,
'py_modules': parse_list,
'python_requires': _static.SpecifierSet, # Core Metadata
'python_requires': SpecifierSet,
'cmdclass': parse_cmdclass,
}
@@ -700,7 +704,10 @@ class ConfigOptionsHandler(ConfigHandler["Distribution"]):
section_data = self._parse_section_to_dict(section_options, self._parse_list)
valid_keys = ['where', 'include', 'exclude']
find_kwargs = {k: v for k, v in section_data.items() if k in valid_keys and v}
find_kwargs = dict(
[(k, v) for k, v in section_data.items() if k in valid_keys and v]
)
where = find_kwargs.get('where')
if where is not None:
@@ -708,7 +715,7 @@ class ConfigOptionsHandler(ConfigHandler["Distribution"]):
return find_kwargs
def parse_section_entry_points(self, section_options) -> None:
def parse_section_entry_points(self, section_options):
"""Parses `entry_points` configuration file section.
:param dict section_options:
@@ -720,61 +727,36 @@ class ConfigOptionsHandler(ConfigHandler["Distribution"]):
package_data = self._parse_section_to_dict(section_options, self._parse_list)
return expand.canonic_package_data(package_data)
def parse_section_package_data(self, section_options) -> None:
def parse_section_package_data(self, section_options):
"""Parses `package_data` configuration file section.
:param dict section_options:
"""
self['package_data'] = self._parse_package_data(section_options)
def parse_section_exclude_package_data(self, section_options) -> None:
def parse_section_exclude_package_data(self, section_options):
"""Parses `exclude_package_data` configuration file section.
:param dict section_options:
"""
self['exclude_package_data'] = self._parse_package_data(section_options)
def parse_section_extras_require(self, section_options) -> None: # Core Metadata
def parse_section_extras_require(self, section_options):
"""Parses `extras_require` configuration file section.
:param dict section_options:
"""
parsed = self._parse_section_to_dict_with_key(
section_options,
lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v),
lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v)
)
self['extras_require'] = _static.Dict(parsed)
# ^-- Use `_static.Dict` to mark a non-`Dynamic` Core Metadata
self['extras_require'] = parsed
def parse_section_data_files(self, section_options) -> None:
def parse_section_data_files(self, section_options):
"""Parses `data_files` configuration file section.
:param dict section_options:
"""
parsed = self._parse_section_to_dict(section_options, self._parse_list)
self['data_files'] = expand.canonic_data_files(parsed, self.root_dir)
class _AmbiguousMarker(SetuptoolsDeprecationWarning):
_SUMMARY = "Ambiguous requirement marker."
_DETAILS = """
One of the parsed requirements in `{field}` looks like a valid environment marker:
{req!r}
Please make sure that the configuration file is correct.
You can use dangling lines to avoid this problem.
"""
_SEE_DOCS = "userguide/declarative_config.html#opt-2"
# TODO: should we include due_date here? Initially introduced in 6 Aug 2022.
# Does this make sense with latest version of packaging?
@classmethod
def message(cls, **kw):
docs = f"https://setuptools.pypa.io/en/latest/{cls._SEE_DOCS}"
return cls._format(cls._SUMMARY, cls._DETAILS, see_url=docs, format_args=kw)
class _DeprecatedConfig(SetuptoolsDeprecationWarning):
_SEE_DOCS = "userguide/declarative_config.html"
server/.venv/lib/python3.11/site-packages/setuptools/config/setuptools.schema.json
-433
View File
@@ -1,433 +0,0 @@
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html",
"title": "``tool.setuptools`` table",
"$$description": [
"``setuptools``-specific configurations that can be set by users that require",
"customization.",
"These configurations are completely optional and probably can be skipped when",
"creating simple packages. They are equivalent to some of the `Keywords",
"<https://setuptools.pypa.io/en/latest/references/keywords.html>`_",
"used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.",
"It considers only ``setuptools`` `parameters",
"<https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html#setuptools-specific-configuration>`_",
"that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``",
"and ``setup_requires`` (incompatible with modern workflows/standards)."
],
"type": "object",
"additionalProperties": false,
"properties": {
"platforms": {
"type": "array",
"items": {"type": "string"}
},
"provides": {
"$$description": [
"Package and virtual package names contained within this package",
"**(not supported by pip)**"
],
"type": "array",
"items": {"type": "string", "format": "pep508-identifier"}
},
"obsoletes": {
"$$description": [
"Packages which this package renders obsolete",
"**(not supported by pip)**"
],
"type": "array",
"items": {"type": "string", "format": "pep508-identifier"}
},
"zip-safe": {
"$$description": [
"Whether the project can be safely installed and run from a zip file.",
"**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and",
"``setup.py install`` in the context of ``eggs`` (**DEPRECATED**)."
],
"type": "boolean"
},
"script-files": {
"$$description": [
"Legacy way of defining scripts (entry-points are preferred).",
"Equivalent to the ``script`` keyword in ``setup.py``",
"(it was renamed to avoid confusion with entry-point based ``project.scripts``",
"defined in :pep:`621`).",
"**DISCOURAGED**: generic script wrappers are tricky and may not work properly.",
"Whenever possible, please use ``project.scripts`` instead."
],
"type": "array",
"items": {"type": "string"},
"$comment": "TODO: is this field deprecated/should be removed?"
},
"eager-resources": {
"$$description": [
"Resources that should be extracted together, if any of them is needed,",
"or if any C extensions included in the project are imported.",
"**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and",
"``setup.py install`` in the context of ``eggs`` (**DEPRECATED**)."
],
"type": "array",
"items": {"type": "string"}
},
"packages": {
"$$description": [
"Packages that should be included in the distribution.",
"It can be given either as a list of package identifiers",
"or as a ``dict``-like structure with a single key ``find``",
"which corresponds to a dynamic call to",
"``setuptools.config.expand.find_packages`` function.",
"The ``find`` key is associated with a nested ``dict``-like structure that can",
"contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,",
"mimicking the keyword arguments of the associated function."
],
"oneOf": [
{
"title": "Array of Python package identifiers",
"type": "array",
"items": {"$ref": "#/definitions/package-name"}
},
{"$ref": "#/definitions/find-directive"}
]
},
"package-dir": {
"$$description": [
":class:`dict`-like structure mapping from package names to directories where their",
"code can be found.",
"The empty string (as key) means that all packages are contained inside",
"the given directory will be included in the distribution."
],
"type": "object",
"additionalProperties": false,
"propertyNames": {
"anyOf": [{"const": ""}, {"$ref": "#/definitions/package-name"}]
},
"patternProperties": {
"^.*$": {"type": "string" }
}
},
"package-data": {
"$$description": [
"Mapping from package names to lists of glob patterns.",
"Usually this option is not needed when using ``include-package-data = true``",
"For more information on how to include data files, check ``setuptools`` `docs",
"<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
],
"type": "object",
"additionalProperties": false,
"propertyNames": {
"anyOf": [{"type": "string", "format": "python-module-name"}, {"const": "*"}]
},
"patternProperties": {
"^.*$": {"type": "array", "items": {"type": "string"}}
}
},
"include-package-data": {
"$$description": [
"Automatically include any data files inside the package directories",
"that are specified by ``MANIFEST.in``",
"For more information on how to include data files, check ``setuptools`` `docs",
"<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
],
"type": "boolean"
},
"exclude-package-data": {
"$$description": [
"Mapping from package names to lists of glob patterns that should be excluded",
"For more information on how to include data files, check ``setuptools`` `docs",
"<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
],
"type": "object",
"additionalProperties": false,
"propertyNames": {
"anyOf": [{"type": "string", "format": "python-module-name"}, {"const": "*"}]
},
"patternProperties": {
"^.*$": {"type": "array", "items": {"type": "string"}}
}
},
"namespace-packages": {
"type": "array",
"items": {"type": "string", "format": "python-module-name-relaxed"},
"$comment": "https://setuptools.pypa.io/en/latest/userguide/package_discovery.html",
"description": "**DEPRECATED**: use implicit namespaces instead (:pep:`420`)."
},
"py-modules": {
"description": "Modules that setuptools will manipulate",
"type": "array",
"items": {"type": "string", "format": "python-module-name-relaxed"},
"$comment": "TODO: clarify the relationship with ``packages``"
},
"ext-modules": {
"description": "Extension modules to be compiled by setuptools",
"type": "array",
"items": {"$ref": "#/definitions/ext-module"}
},
"data-files": {
"$$description": [
"``dict``-like structure where each key represents a directory and",
"the value is a list of glob patterns that should be installed in them.",
"**DISCOURAGED**: please notice this might not work as expected with wheels.",
"Whenever possible, consider using data files inside the package directories",
"(or create a new namespace package that only contains data files).",
"See `data files support",
"<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
],
"type": "object",
"patternProperties": {
"^.*$": {"type": "array", "items": {"type": "string"}}
}
},
"cmdclass": {
"$$description": [
"Mapping of distutils-style command names to ``setuptools.Command`` subclasses",
"which in turn should be represented by strings with a qualified class name",
"(i.e., \"dotted\" form with module), e.g.::\n\n",
" cmdclass = {mycmd = \"pkg.subpkg.module.CommandClass\"}\n\n",
"The command class should be a directly defined at the top-level of the",
"containing module (no class nesting)."
],
"type": "object",
"patternProperties": {
"^.*$": {"type": "string", "format": "python-qualified-identifier"}
}
},
"license-files": {
"type": "array",
"items": {"type": "string"},
"$$description": [
"**PROVISIONAL**: list of glob patterns for all license files being distributed.",
"(likely to become standard with :pep:`639`).",
"By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"
],
"$comment": "TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?"
},
"dynamic": {
"type": "object",
"description": "Instructions for loading :pep:`621`-related metadata dynamically",
"additionalProperties": false,
"properties": {
"version": {
"$$description": [
"A version dynamically loaded via either the ``attr:`` or ``file:``",
"directives. Please make sure the given file or attribute respects :pep:`440`.",
"Also ensure to set ``project.dynamic`` accordingly."
],
"oneOf": [
{"$ref": "#/definitions/attr-directive"},
{"$ref": "#/definitions/file-directive"}
]
},
"classifiers": {"$ref": "#/definitions/file-directive"},
"description": {"$ref": "#/definitions/file-directive"},
"entry-points": {"$ref": "#/definitions/file-directive"},
"dependencies": {"$ref": "#/definitions/file-directive-for-dependencies"},
"optional-dependencies": {
"type": "object",
"propertyNames": {"type": "string", "format": "pep508-identifier"},
"additionalProperties": false,
"patternProperties": {
".+": {"$ref": "#/definitions/file-directive-for-dependencies"}
}
},
"readme": {
"type": "object",
"anyOf": [
{"$ref": "#/definitions/file-directive"},
{
"type": "object",
"properties": {
"content-type": {"type": "string"},
"file": { "$ref": "#/definitions/file-directive/properties/file" }
},
"additionalProperties": false}
],
"required": ["file"]
}
}
}
},
"definitions": {
"package-name": {
"$id": "#/definitions/package-name",
"title": "Valid package name",
"description": "Valid package name (importable or :pep:`561`).",
"type": "string",
"anyOf": [
{"type": "string", "format": "python-module-name-relaxed"},
{"type": "string", "format": "pep561-stub-name"}
]
},
"ext-module": {
"$id": "#/definitions/ext-module",
"title": "Extension module",
"description": "Parameters to construct a :class:`setuptools.Extension` object",
"type": "object",
"required": ["name", "sources"],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"format": "python-module-name-relaxed"
},
"sources": {
"type": "array",
"items": {"type": "string"}
},
"include-dirs":{
"type": "array",
"items": {"type": "string"}
},
"define-macros": {
"type": "array",
"items": {
"type": "array",
"items": [
{"description": "macro name", "type": "string"},
{"description": "macro value", "oneOf": [{"type": "string"}, {"type": "null"}]}
],
"additionalItems": false
}
},
"undef-macros": {
"type": "array",
"items": {"type": "string"}
},
"library-dirs": {
"type": "array",
"items": {"type": "string"}
},
"libraries": {
"type": "array",
"items": {"type": "string"}
},
"runtime-library-dirs": {
"type": "array",
"items": {"type": "string"}
},
"extra-objects": {
"type": "array",
"items": {"type": "string"}
},
"extra-compile-args": {
"type": "array",
"items": {"type": "string"}
},
"extra-link-args": {
"type": "array",
"items": {"type": "string"}
},
"export-symbols": {
"type": "array",
"items": {"type": "string"}
},
"swig-opts": {
"type": "array",
"items": {"type": "string"}
},
"depends": {
"type": "array",
"items": {"type": "string"}
},
"language": {"type": "string"},
"optional": {"type": "boolean"},
"py-limited-api": {"type": "boolean"}
}
},
"file-directive": {
"$id": "#/definitions/file-directive",
"title": "'file:' directive",
"description":
"Value is read from a file (or list of files and then concatenated)",
"type": "object",
"additionalProperties": false,
"properties": {
"file": {
"oneOf": [
{"type": "string"},
{"type": "array", "items": {"type": "string"}}
]
}
},
"required": ["file"]
},
"file-directive-for-dependencies": {
"title": "'file:' directive for dependencies",
"allOf": [
{
"$$description": [
"**BETA**: subset of the ``requirements.txt`` format",
"without ``pip`` flags and options",
"(one :pep:`508`-compliant string per line,",
"lines that are blank or start with ``#`` are excluded).",
"See `dynamic metadata",
"<https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html#dynamic-metadata>`_."
]
},
{"$ref": "#/definitions/file-directive"}
]
},
"attr-directive": {
"title": "'attr:' directive",
"$id": "#/definitions/attr-directive",
"$$description": [
"Value is read from a module attribute. Supports callables and iterables;",
"unsupported types are cast via ``str()``"
],
"type": "object",
"additionalProperties": false,
"properties": {
"attr": {"type": "string", "format": "python-qualified-identifier"}
},
"required": ["attr"]
},
"find-directive": {
"$id": "#/definitions/find-directive",
"title": "'find:' directive",
"type": "object",
"additionalProperties": false,
"properties": {
"find": {
"type": "object",
"$$description": [
"Dynamic `package discovery",
"<https://setuptools.pypa.io/en/latest/userguide/package_discovery.html>`_."
],
"additionalProperties": false,
"properties": {
"where": {
"description":
"Directories to be searched for packages (Unix-style relative path)",
"type": "array",
"items": {"type": "string"}
},
"exclude": {
"type": "array",
"$$description": [
"Exclude packages that match the values listed in this field.",
"Can container shell-style wildcards (e.g. ``'pkg.*'``)"
],
"items": {"type": "string"}
},
"include": {
"type": "array",
"$$description": [
"Restrict the found packages to just the ones listed in this field.",
"Can container shell-style wildcards (e.g. ``'pkg.*'``)"
],
"items": {"type": "string"}
},
"namespaces": {
"type": "boolean",
"$$description": [
"When ``True``, directories without a ``__init__.py`` file will also",
"be scanned for :pep:`420`-style implicit namespaces"
]
}
}
}
}
}
}
}