5017901797736448

Committed 21 Apr 2024 06:28PM UTC coverage: 97.864% (+0.005%) from 97.859%

Build # 5017901797736448

Build Type

Pull #163

cirrus-ci

Committed by

abravalheri

Commit Message

Add link to formats to debug info

Pull Request Pull Request #163: Improve API docs

Run Details

322 of 335 branches covered (96.12%)

Branch coverage included in aggregate %.

8 of 8 new or added lines in 3 files covered. (100.0%)

4 existing lines in 1 file now uncovered.

915 of 929 relevant lines covered (98.49%)

10.81 hits per line

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

97.74

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

abravalheri / validate-pyproject / 5017901797736448

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