260 lines
8.5 KiB
Python
260 lines
8.5 KiB
Python
import logging
|
|
import os
|
|
import re
|
|
import string
|
|
import typing
|
|
from itertools import chain as _chain
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
# -------------------------------------------------------------------------------------
|
|
# PEP 440
|
|
|
|
VERSION_PATTERN = r"""
|
|
v?
|
|
(?:
|
|
(?:(?P<epoch>[0-9]+)!)? # epoch
|
|
(?P<release>[0-9]+(?:\.[0-9]+)*) # release segment
|
|
(?P<pre> # pre-release
|
|
[-_\.]?
|
|
(?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
|
|
[-_\.]?
|
|
(?P<pre_n>[0-9]+)?
|
|
)?
|
|
(?P<post> # post release
|
|
(?:-(?P<post_n1>[0-9]+))
|
|
|
|
|
(?:
|
|
[-_\.]?
|
|
(?P<post_l>post|rev|r)
|
|
[-_\.]?
|
|
(?P<post_n2>[0-9]+)?
|
|
)
|
|
)?
|
|
(?P<dev> # dev release
|
|
[-_\.]?
|
|
(?P<dev_l>dev)
|
|
[-_\.]?
|
|
(?P<dev_n>[0-9]+)?
|
|
)?
|
|
)
|
|
(?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
|
|
"""
|
|
|
|
VERSION_REGEX = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.X | re.I)
|
|
|
|
|
|
def pep440(version: str) -> bool:
|
|
return VERSION_REGEX.match(version) is not None
|
|
|
|
|
|
# -------------------------------------------------------------------------------------
|
|
# PEP 508
|
|
|
|
PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"
|
|
PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)
|
|
|
|
|
|
def pep508_identifier(name: str) -> bool:
|
|
return PEP508_IDENTIFIER_REGEX.match(name) is not None
|
|
|
|
|
|
try:
|
|
try:
|
|
from packaging import requirements as _req
|
|
except ImportError: # pragma: no cover
|
|
# let's try setuptools vendored version
|
|
from setuptools._vendor.packaging import requirements as _req # type: ignore
|
|
|
|
def pep508(value: str) -> bool:
|
|
try:
|
|
_req.Requirement(value)
|
|
return True
|
|
except _req.InvalidRequirement:
|
|
return False
|
|
|
|
except ImportError: # pragma: no cover
|
|
_logger.warning(
|
|
"Could not find an installation of `packaging`. Requirements, dependencies and "
|
|
"versions might not be validated. "
|
|
"To enforce validation, please install `packaging`."
|
|
)
|
|
|
|
def pep508(value: str) -> bool:
|
|
return True
|
|
|
|
|
|
def pep508_versionspec(value: str) -> bool:
|
|
"""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 re-use the pep508 function for validation:
|
|
return pep508(f"requirement{value}")
|
|
|
|
|
|
# -------------------------------------------------------------------------------------
|
|
# PEP 517
|
|
|
|
|
|
def pep517_backend_reference(value: str) -> bool:
|
|
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)
|
|
|
|
|
|
# -------------------------------------------------------------------------------------
|
|
# Classifiers - PEP 301
|
|
|
|
|
|
def _download_classifiers() -> str:
|
|
import ssl
|
|
from email.message import Message
|
|
from urllib.request import urlopen
|
|
|
|
url = "https://pypi.org/pypi?:action=list_classifiers"
|
|
context = ssl.create_default_context()
|
|
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"))
|
|
|
|
|
|
class _TroveClassifier:
|
|
"""The ``trove_classifiers`` package is the official way of validating classifiers,
|
|
however this package might not be always available.
|
|
As a workaround we can still download a list from PyPI.
|
|
We also don't want to be over strict about it, so simply skipping silently is an
|
|
option (classifiers will be validated anyway during the upload to PyPI).
|
|
"""
|
|
|
|
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):
|
|
# This is a private API. Only setuptools has the consent of using it.
|
|
self._skip_download = True
|
|
|
|
def __call__(self, value: str) -> bool:
|
|
if self.downloaded is False or self._skip_download is True:
|
|
return True
|
|
|
|
if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):
|
|
self.downloaded = False
|
|
msg = (
|
|
"Install ``trove-classifiers`` to ensure proper validation. "
|
|
"Skipping download of classifiers list from PyPI (NO_NETWORK)."
|
|
)
|
|
_logger.debug(msg)
|
|
return True
|
|
|
|
if self.downloaded is None:
|
|
msg = (
|
|
"Install ``trove-classifiers`` to ensure proper validation. "
|
|
"Meanwhile a list of classifiers will be downloaded from PyPI."
|
|
)
|
|
_logger.debug(msg)
|
|
try:
|
|
self.downloaded = set(_download_classifiers().splitlines())
|
|
except Exception:
|
|
self.downloaded = False
|
|
_logger.debug("Problem with download, skipping validation")
|
|
return True
|
|
|
|
return value in self.downloaded or value.lower().startswith("private ::")
|
|
|
|
|
|
try:
|
|
from trove_classifiers import classifiers as _trove_classifiers
|
|
|
|
def trove_classifier(value: str) -> bool:
|
|
return value in _trove_classifiers or value.lower().startswith("private ::")
|
|
|
|
except ImportError: # pragma: no cover
|
|
trove_classifier = _TroveClassifier()
|
|
|
|
|
|
# -------------------------------------------------------------------------------------
|
|
# Non-PEP related
|
|
|
|
|
|
def url(value: str) -> bool:
|
|
from urllib.parse import urlparse
|
|
|
|
try:
|
|
parts = urlparse(value)
|
|
if not parts.scheme:
|
|
_logger.warning(
|
|
"For maximum compatibility please make sure to include a "
|
|
"`scheme` prefix in your URL (e.g. 'http://'). "
|
|
f"Given value: {value}"
|
|
)
|
|
if not (value.startswith("/") or value.startswith("\\") or "@" in value):
|
|
parts = urlparse(f"http://{value}")
|
|
|
|
return bool(parts.scheme and parts.netloc)
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
# https://packaging.python.org/specifications/entry-points/
|
|
ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"
|
|
ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.I)
|
|
RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"
|
|
RECOMMEDED_ENTRYPOINT_REGEX = re.compile(f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.I)
|
|
ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"
|
|
ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)
|
|
|
|
|
|
def python_identifier(value: str) -> bool:
|
|
return value.isidentifier()
|
|
|
|
|
|
def python_qualified_identifier(value: str) -> bool:
|
|
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:
|
|
return python_qualified_identifier(value)
|
|
|
|
|
|
def python_entrypoint_group(value: str) -> bool:
|
|
return ENTRYPOINT_GROUP_REGEX.match(value) is not None
|
|
|
|
|
|
def python_entrypoint_name(value: str) -> bool:
|
|
if not ENTRYPOINT_REGEX.match(value):
|
|
return False
|
|
if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
|
|
msg = f"Entry point `{value}` does not follow recommended pattern: "
|
|
msg += RECOMMEDED_ENTRYPOINT_PATTERN
|
|
_logger.warning(msg)
|
|
return True
|
|
|
|
|
|
def python_entrypoint_reference(value: str) -> bool:
|
|
module, _, rest = value.partition(":")
|
|
if "[" in rest:
|
|
obj, _, extras_ = rest.partition("[")
|
|
if extras_.strip()[-1] != "]":
|
|
return False
|
|
extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))
|
|
if not all(pep508_identifier(e) for e in extras):
|
|
return False
|
|
_logger.warning(f"`{value}` - using extras for entry points is not recommended")
|
|
else:
|
|
obj = rest
|
|
|
|
module_parts = module.split(".")
|
|
identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts
|
|
return all(python_identifier(i.strip()) for i in identifiers)
|