5745497816694784

Committed 07 Aug 2024 04:58PM UTC coverage: 97.812%. Remained the same

Build # 5745497816694784

Build Type

Pull #191

cirrus-ci

Committed by

pre-commit-ci[bot]

Commit Message

[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Pull Request Pull Request #191: Apply assorted repo-review rules

Run Details

286 of 299 branches covered (95.65%)

Branch coverage included in aggregate %.

921 of 935 relevant lines covered (98.5%)

9.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.84

/src/validate_pyproject/formats.py

"""
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
import string
import typing
from itertools import chain as _chain

if typing.TYPE_CHECKING:
    from typing_extensions import Literal

_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>alpha|a|beta|b|preview|pre|c|rc)
            [-_\.]?
            (?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:
    """See :ref:`PyPA's version specification <pypa:version-specifiers>`
    (initially introduced in :pep:`440`).
    """
    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:
    """See :ref:`PyPA's name specification <pypa:name-format>`
    (initially introduced in :pep:`508#names`).
    """
    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 (  # type: ignore[no-redef]
            requirements as _req,
        )

    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
        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)
    See ``versionspec`` in :ref:`PyPA's dependency specifiers
    <pypa:dependency-specifiers>` (initially introduced in :pep:`508`).
    """
    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:
    return pep508(f"requirement{value}")


# -------------------------------------------------------------------------------------
# PEP 517


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)


# -------------------------------------------------------------------------------------
# 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:  # noqa: S310 (audit URLs)
        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]


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).
    """

    downloaded: typing.Union[None, "Literal[False]", typing.Set[str]]

    def __init__(self) -> None:
        self.downloaded = 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:
        # 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:
        """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:
        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:
    """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):
        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:
    """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("[")
        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)


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

1	"""
2	The functions in this module are used to validate schemas with the
3	`format JSON Schema keyword
4	<https://json-schema.org/understanding-json-schema/reference/string#format>`_.
5
6	The correspondence is given by replacing the ``_`` character in the name of the
7	function with a ``-`` to obtain the format name and vice versa.
8	"""
9
10	import builtins	10✔
11	import logging	10✔
12	import os	10✔
13	import re	10✔
14	import string	10✔
15	import typing	10✔
16	from itertools import chain as _chain	10✔
17
18	if typing.TYPE_CHECKING:
19	from typing_extensions import Literal
20
21	_logger = logging.getLogger(__name__)	10✔
22
23	# -------------------------------------------------------------------------------------
24	# PEP 440
25
26	VERSION_PATTERN = r"""	10✔
27	v?
28	(?:
29	(?:(?P<epoch>[0-9]+)!)? # epoch
30	(?P<release>[0-9]+(?:\.[0-9]+)*) # release segment
31	(?P<pre> # pre-release
32	[-_\.]?
33	(?P<pre_l>alpha\|a\|beta\|b\|preview\|pre\|c\|rc)
34	[-_\.]?
35	(?P<pre_n>[0-9]+)?
36	)?
37	(?P<post> # post release
38	(?:-(?P<post_n1>[0-9]+))
39	\|
40	(?:
41	[-_\.]?
42	(?P<post_l>post\|rev\|r)
43	[-_\.]?
44	(?P<post_n2>[0-9]+)?
45	)
46	)?
47	(?P<dev> # dev release
48	[-_\.]?
49	(?P<dev_l>dev)
50	[-_\.]?
51	(?P<dev_n>[0-9]+)?
52	)?
53	)
54	(?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
55	"""
56
57	VERSION_REGEX = re.compile(r"^\s" + VERSION_PATTERN + r"\s$", re.X \| re.I)	10✔
58
59
60	def pep440(version: str) -> bool:	10✔
61	"""See :ref:`PyPA's version specification <pypa:version-specifiers>`
62	(initially introduced in :pep:`440`).
63	"""
64	return VERSION_REGEX.match(version) is not None	10✔
65
66
67	# -------------------------------------------------------------------------------------
68	# PEP 508
69
70	PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]\|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"	10✔
71	PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)	10✔
72
73
74	def pep508_identifier(name: str) -> bool:	10✔
75	"""See :ref:`PyPA's name specification <pypa:name-format>`
76	(initially introduced in :pep:`508#names`).
77	"""
78	return PEP508_IDENTIFIER_REGEX.match(name) is not None	10✔
79
80
81	try:	10✔
82	try:	10✔
83	from packaging import requirements as _req	10✔
84	except ImportError: # pragma: no cover
85	# let's try setuptools vendored version
86	from setuptools._vendor.packaging import ( # type: ignore[no-redef]
87	requirements as _req,
88	)
89
90	def pep508(value: str) -> bool:	10✔
91	"""See :ref:`PyPA's dependency specifiers <pypa:dependency-specifiers>`
92	(initially introduced in :pep:`508`).
93	"""
94	try:	10✔
95	_req.Requirement(value)	10✔
96	return True	10✔
97	except _req.InvalidRequirement:	10✔
98	return False	10✔
99
100	except ImportError: # pragma: no cover
101	_logger.warning(
102	"Could not find an installation of `packaging`. Requirements, dependencies and "
103	"versions might not be validated. "
104	"To enforce validation, please install `packaging`."
105	)
106
107	def pep508(value: str) -> bool:
108	return True
109
110
111	def pep508_versionspec(value: str) -> bool:	10✔
112	"""Expression that can be used to specify/lock versions (including ranges)
113	See ``versionspec`` in :ref:`PyPA's dependency specifiers
114	<pypa:dependency-specifiers>` (initially introduced in :pep:`508`).
115	"""
116	if any(c in value for c in (";", "]", "@")):	10✔
117	# In PEP 508:
118	# conditional markers, extras and URL specs are not included in the
119	# versionspec
120	return False	10✔
121	# Let's pretend we have a dependency called `requirement` with the given
122	# version spec, then we can reuse the pep508 function for validation:
123	return pep508(f"requirement{value}")	10✔
124
125
126	# -------------------------------------------------------------------------------------
127	# PEP 517
128
129
130	def pep517_backend_reference(value: str) -> bool:	10✔
131	"""See PyPA's specification for defining build-backend references
132	introduced in :pep:`517#source-trees`.
133
134	This is similar to an entry-point reference (e.g., ``package.module:object``).
135	"""
136	module, _, obj = value.partition(":")	10✔
137	identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))	10✔
138	return all(python_identifier(i) for i in identifiers if i)	10✔
139
140
141	# -------------------------------------------------------------------------------------
142	# Classifiers - PEP 301
143
144
145	def _download_classifiers() -> str:	10✔
146	import ssl	10✔
147	from email.message import Message	10✔
148	from urllib.request import urlopen	10✔
149
150	url = "https://pypi.org/pypi?:action=list_classifiers"	10✔
151	context = ssl.create_default_context()	10✔
152	with urlopen(url, context=context) as response: # noqa: S310 (audit URLs)	10✔
153	headers = Message()	9✔
154	headers["content_type"] = response.getheader("content-type", "text/plain")	9✔
155	return response.read().decode(headers.get_param("charset", "utf-8")) # type: ignore[no-any-return]	9✔
156
157
158	class _TroveClassifier:	10✔
159	"""The ``trove_classifiers`` package is the official way of validating classifiers,
160	however this package might not be always available.
161	As a workaround we can still download a list from PyPI.
162	We also don't want to be over strict about it, so simply skipping silently is an
163	option (classifiers will be validated anyway during the upload to PyPI).
164	"""
165
166	downloaded: typing.Union[None, "Literal[False]", typing.Set[str]]	10✔
167
168	def __init__(self) -> None:	10✔
169	self.downloaded = None	10✔
170	self._skip_download = False	10✔
171	# None => not cached yet
172	# False => cache not available
173	self.__name__ = "trove_classifier" # Emulate a public function	10✔
174
175	def _disable_download(self) -> None:	10✔
176	# This is a private API. Only setuptools has the consent of using it.
177	self._skip_download = True	10✔
178
179	def __call__(self, value: str) -> bool:	10✔
180	if self.downloaded is False or self._skip_download is True:	10✔
181	return True	10✔
182
183	if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):	10✔
184	self.downloaded = False	10✔
185	msg = (	10✔
186	"Install ``trove-classifiers`` to ensure proper validation. "
187	"Skipping download of classifiers list from PyPI (NO_NETWORK)."
188	)
189	_logger.debug(msg)	10✔
190	return True	10✔
191
192	if self.downloaded is None:	10✔
193	msg = (	10✔
194	"Install ``trove-classifiers`` to ensure proper validation. "
195	"Meanwhile a list of classifiers will be downloaded from PyPI."
196	)
197	_logger.debug(msg)	10✔
198	try:	10✔
199	self.downloaded = set(_download_classifiers().splitlines())	10✔
200	except Exception:	10✔
201	self.downloaded = False	10✔
202	_logger.debug("Problem with download, skipping validation")	10✔
203	return True	10✔
204
205	return value in self.downloaded or value.lower().startswith("private ::")	10✔
206
207
208	try:	10✔
209	from trove_classifiers import (	10✔
210	classifiers as _trove_classifiers,
211	)
212
213	def trove_classifier(value: str) -> bool:	10✔
214	"""See https://pypi.org/classifiers/"""
215	return value in _trove_classifiers or value.lower().startswith("private ::")	10✔
216
217	except ImportError: # pragma: no cover
218	trove_classifier = _TroveClassifier()
219
220
221	# -------------------------------------------------------------------------------------
222	# Stub packages - PEP 561
223
224
225	def pep561_stub_name(value: str) -> bool:	10✔
226	"""Name of a directory containing type stubs.
227	It must follow the name scheme ``<package>-stubs`` as defined in
228	:pep:`561#stub-only-packages`.
229	"""
230	top, *children = value.split(".")	10✔
231	if not top.endswith("-stubs"):	10✔
232	return False	10✔
233	return python_module_name(".".join([top[: -len("-stubs")], *children]))	10✔
234
235
236	# -------------------------------------------------------------------------------------
237	# Non-PEP related
238
239
240	def url(value: str) -> bool:	10✔
241	"""Valid URL (validation uses :obj:`urllib.parse`).
242	For maximum compatibility please make sure to include a ``scheme`` prefix
243	in your URL (e.g. ``http://``).
244	"""
245	from urllib.parse import urlparse	10✔
246
247	try:	10✔
248	parts = urlparse(value)	10✔
249	if not parts.scheme:	10✔
250	_logger.warning(	10✔
251	"For maximum compatibility please make sure to include a "
252	"`scheme` prefix in your URL (e.g. 'http://'). "
253	f"Given value: {value}"
254	)
255	if not (value.startswith("/") or value.startswith("\\") or "@" in value):	10✔
256	parts = urlparse(f"http://{value}")	10✔
257
258	return bool(parts.scheme and parts.netloc)	10✔
259	except Exception:	10✔
260	return False	10✔
261
262
263	# https://packaging.python.org/specifications/entry-points/
264	ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"	10✔
265	ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.I)	10✔
266	RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"	10✔
267	RECOMMEDED_ENTRYPOINT_REGEX = re.compile(f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.I)	10✔
268	ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"	10✔
269	ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)	10✔
270
271
272	def python_identifier(value: str) -> bool:	10✔
273	"""Can be used as identifier in Python.
274	(Validation uses :obj:`str.isidentifier`).
275	"""
276	return value.isidentifier()	10✔
277
278
279	def python_qualified_identifier(value: str) -> bool:	10✔
280	"""
281	Python "dotted identifier", i.e. a sequence of :obj:`python_identifier`
282	concatenated with ``"."`` (e.g.: ``package.module.submodule``).
283	"""
284	if value.startswith(".") or value.endswith("."):	10✔
285	return False	10✔
286	return all(python_identifier(m) for m in value.split("."))	10✔
287
288
289	def python_module_name(value: str) -> bool:	10✔
290	"""Module name that can be used in an ``import``-statement in Python.
291	See :obj:`python_qualified_identifier`.
292	"""
293	return python_qualified_identifier(value)	10✔
294
295
296	def python_module_name_relaxed(value: str) -> bool:	10✔
297	"""Similar to :obj:`python_module_name`, but relaxed to also accept
298	dash characters (``-``) and cover special cases like ``pip-run``.
299
300	It is recommended, however, that beginners avoid dash characters,
301	as they require advanced knowledge about Python internals.
302
303	The following are disallowed:
304
305	* names starting/ending in dashes,
306	* names ending in ``-stubs`` (potentially collide with :obj:`pep561_stub_name`).
307	"""
308	if value.startswith("-") or value.endswith("-"):	10✔
309	return False	10✔
310	if value.endswith("-stubs"):	10✔
311	return False # Avoid collision with PEP 561	10✔
312	return python_module_name(value.replace("-", "_"))	10✔
313
314
315	def python_entrypoint_group(value: str) -> bool:	10✔
316	"""See ``Data model > group`` in the :ref:`PyPA's entry-points specification
317	<pypa:entry-points>`.
318	"""
319	return ENTRYPOINT_GROUP_REGEX.match(value) is not None	10✔
320
321
322	def python_entrypoint_name(value: str) -> bool:	10✔
323	"""See ``Data model > name`` in the :ref:`PyPA's entry-points specification
324	<pypa:entry-points>`.
325	"""
326	if not ENTRYPOINT_REGEX.match(value):	10✔
327	return False	10✔
328	if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):	10✔
329	msg = f"Entry point `{value}` does not follow recommended pattern: "	10✔
330	msg += RECOMMEDED_ENTRYPOINT_PATTERN	10✔
331	_logger.warning(msg)	10✔
332	return True	10✔
333
334
335	def python_entrypoint_reference(value: str) -> bool:	10✔
336	"""Reference to a Python object using in the format::
337
338	importable.module:object.attr
339
340	See ``Data model >object reference`` in the :ref:`PyPA's entry-points specification
341	<pypa:entry-points>`.
342	"""
343	module, _, rest = value.partition(":")	10✔
344	if "[" in rest:	10✔
345	obj, _, extras_ = rest.partition("[")	10✔
346	if extras_.strip()[-1] != "]":	10✔
347	return False	10✔
348	extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))	10✔
349	if not all(pep508_identifier(e) for e in extras):	10✔
350	return False	10✔
351	_logger.warning(f"`{value}` - using extras for entry points is not recommended")	10✔
352	else:
353	obj = rest	10✔
354
355	module_parts = module.split(".")	10✔
356	identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts	10✔
357	return all(python_identifier(i.strip()) for i in identifiers)	10✔
358
359
360	def uint8(value: builtins.int) -> bool:	10✔
361	r"""Unsigned 8-bit integer (:math:`0 \leq x < 2^8`)"""
362	return 0 <= value < 2**8	×
363
364
365	def uint16(value: builtins.int) -> bool:	10✔
366	r"""Unsigned 16-bit integer (:math:`0 \leq x < 2^{16}`)"""
367	return 0 <= value < 2**16	×
368
369
370	def uint(value: builtins.int) -> bool:	10✔
371	r"""Unsigned 64-bit integer (:math:`0 \leq x < 2^{64}`)"""
372	return 0 <= value < 2**64	×
373
374
375	def int(value: builtins.int) -> bool:	10✔
376	r"""Signed 64-bit integer (:math:`-2^{63} \leq x < 2^{63}`)"""
377	return -(263) <= value < 263	×

abravalheri / validate-pyproject / 5745497816694784

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous