6146455325376512

Committed 20 Nov 2023 02:31PM UTC coverage: 97.246% (-1.4%) from 98.601%

Build # 6146455325376512

Build Type

Pull #121

cirrus-ci

Committed by

henryiii

Commit Message

feat: support fragments

Signed-off-by: Henry Schreiner <henryschreineriii@gmail.com>

Pull Request Pull Request #121: WIP: load tool via URL

Run Details

291 of 301 branches covered (0.0%)

Branch coverage included in aggregate %.

65 of 77 new or added lines in 6 files covered. (84.42%)

10 existing lines in 1 file now uncovered.

839 of 861 relevant lines covered (97.44%)

10.66 hits per line

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

94.06

/src/validate_pyproject/plugins/__init__.py

# The code in this module is mostly borrowed/adapted from PyScaffold and was originally
# published under the MIT license
# The original PyScaffold license can be found in 'NOTICE.txt'
"""
.. _entry point: https://setuptools.readthedocs.io/en/latest/userguide/entry_point.html
"""

import sys
import typing
from string import Template
from textwrap import dedent
from typing import Any, Callable, Iterable, List, Optional

from .. import __version__
from ..types import Plugin, Schema

if sys.version_info[:2] >= (3, 8):  # pragma: no cover
    # TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
    from importlib.metadata import EntryPoint, entry_points
else:  # pragma: no cover
    from importlib_metadata import EntryPoint, entry_points

if typing.TYPE_CHECKING:
    if sys.version_info < (3, 8):
        from typing_extensions import Protocol
    else:
        from typing import Protocol
else:
    Protocol = object

ENTRYPOINT_GROUP = "validate_pyproject.tool_schema"


class PluginProtocol(Protocol):
    @property
    def id(self) -> str:
        ...

    @property
    def tool(self) -> str:
        ...

    @property
    def schema(self) -> Schema:
        ...

    @property
    def help_text(self) -> str:
        ...

    @property
    def fragment(self) -> str:
        ...


class PluginWrapper:
    def __init__(self, tool: str, load_fn: Plugin):
        self._tool = tool
        self._load_fn = load_fn

    @property
    def id(self) -> str:
        return f"{self._load_fn.__module__}.{self._load_fn.__name__}"

    @property
    def tool(self) -> str:
        return self._tool

    @property
    def schema(self) -> Schema:
        return self._load_fn(self.tool)

    @property
    def fragment(self) -> str:
        return ""

    @property
    def help_text(self) -> str:
        tpl = self._load_fn.__doc__
        if not tpl:
            return ""
        return Template(tpl).safe_substitute(tool=self.tool, id=self.id)

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}({self.tool!r}, {self.id})"


if typing.TYPE_CHECKING:
    _: PluginProtocol = typing.cast(PluginWrapper, None)


def iterate_entry_points(group=ENTRYPOINT_GROUP) -> Iterable[EntryPoint]:
    """Produces a generator yielding an EntryPoint object for each plugin registered
    via ``setuptools`` `entry point`_ mechanism.

    This method can be used in conjunction with :obj:`load_from_entry_point` to filter
    the plugins before actually loading them.
    """
    entries = entry_points()
    if hasattr(entries, "select"):  # pragma: no cover
        # The select method was introduced in importlib_metadata 3.9 (and Python 3.10)
        # and the previous dict interface was declared deprecated
        select = typing.cast(
            Any, getattr(entries, "select")  # noqa: B009
        )  # typecheck gymnastics
        entries_: Iterable[EntryPoint] = select(group=group)
    else:  # pragma: no cover
        # TODO: Once Python 3.10 becomes the oldest version supported, this fallback and
        #       conditional statement can be removed.
        entries_ = (plugin for plugin in entries.get(group, []))
    deduplicated = {e.name: e for e in sorted(entries_, key=lambda e: e.name)}
    return list(deduplicated.values())


def load_from_entry_point(entry_point: EntryPoint) -> PluginWrapper:
    """Carefully load the plugin, raising a meaningful message in case of errors"""
    try:
        fn = entry_point.load()
        return PluginWrapper(entry_point.name, fn)
    except Exception as ex:
        raise ErrorLoadingPlugin(entry_point=entry_point) from ex


def list_from_entry_points(
    group: str = ENTRYPOINT_GROUP,
    filtering: Callable[[EntryPoint], bool] = lambda _: True,
) -> List[PluginWrapper]:
    """Produces a list of plugin objects for each plugin registered
    via ``setuptools`` `entry point`_ mechanism.

    Args:
        group: name of the setuptools' entry point group where plugins is being
            registered
        filtering: function returning a boolean deciding if the entry point should be
            loaded and included (or not) in the final list. A ``True`` return means the
            plugin should be included.
    """
    return [
        load_from_entry_point(e) for e in iterate_entry_points(group) if filtering(e)
    ]


class ErrorLoadingPlugin(RuntimeError):
    _DESC = """There was an error loading '{plugin}'.
    Please make sure you have installed a version of the plugin that is compatible
    with {package} {version}. You can also try uninstalling it.
    """
    __doc__ = _DESC

    def __init__(self, plugin: str = "", entry_point: Optional[EntryPoint] = None):
        if entry_point and not plugin:
            plugin = getattr(entry_point, "module", entry_point.name)

        sub = {"package": __package__, "version": __version__, "plugin": plugin}
        msg = dedent(self._DESC).format(**sub).splitlines()
        super().__init__(f"{msg[0]}\n{' '.join(msg[1:])}")

1	# The code in this module is mostly borrowed/adapted from PyScaffold and was originally
2	# published under the MIT license
3	# The original PyScaffold license can be found in 'NOTICE.txt'
4	"""	11✔
5	.. _entry point: https://setuptools.readthedocs.io/en/latest/userguide/entry_point.html
6	"""
7
8	import sys	11✔
9	import typing	11✔
10	from string import Template	11✔
11	from textwrap import dedent	11✔
12	from typing import Any, Callable, Iterable, List, Optional	11✔
13
14	from .. import __version__	11✔
15	from ..types import Plugin, Schema	11✔
16
17	if sys.version_info[:2] >= (3, 8): # pragma: no cover
18	# TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
19	from importlib.metadata import EntryPoint, entry_points
20	else: # pragma: no cover
21	from importlib_metadata import EntryPoint, entry_points
22
23	if typing.TYPE_CHECKING:
24	if sys.version_info < (3, 8):
25	from typing_extensions import Protocol
26	else:
27	from typing import Protocol
28	else:
29	Protocol = object	11✔
30
31	ENTRYPOINT_GROUP = "validate_pyproject.tool_schema"	11✔
32
33
34	class PluginProtocol(Protocol):	11✔
35	@property	11✔
36	def id(self) -> str:	11✔
NEW 37	...	×
38
39	@property	11✔
40	def tool(self) -> str:	11✔
NEW 41	...	×
42
43	@property	11✔
44	def schema(self) -> Schema:	11✔
NEW 45	...	×
46
47	@property	11✔
48	def help_text(self) -> str:	11✔
NEW 49	...	×
50
51	@property	11✔
52	def fragment(self) -> str:	11✔
NEW 53	...	×
54
55
56	class PluginWrapper:	11✔
57	def __init__(self, tool: str, load_fn: Plugin):	11✔
58	self._tool = tool	11✔
59	self._load_fn = load_fn	11✔
60
61	@property	11✔
62	def id(self) -> str:	11✔
63	return f"{self._load_fn.__module__}.{self._load_fn.__name__}"	11✔
64
65	@property	11✔
66	def tool(self) -> str:	11✔
67	return self._tool	11✔
68
69	@property	11✔
70	def schema(self) -> Schema:	11✔
71	return self._load_fn(self.tool)	11✔
72
73	@property	11✔
74	def fragment(self) -> str:	11✔
75	return ""	11✔
76
77	@property	11✔
78	def help_text(self) -> str:	11✔
79	tpl = self._load_fn.__doc__	11✔
80	if not tpl:	11✔
81	return ""	11✔
82	return Template(tpl).safe_substitute(tool=self.tool, id=self.id)	11✔
83
84	def __repr__(self) -> str:
85	return f"{self.__class__.__name__}({self.tool!r}, {self.id})"
86
87
88	if typing.TYPE_CHECKING:
89	_: PluginProtocol = typing.cast(PluginWrapper, None)
90
91
92	def iterate_entry_points(group=ENTRYPOINT_GROUP) -> Iterable[EntryPoint]:	11✔
93	"""Produces a generator yielding an EntryPoint object for each plugin registered
94	via ``setuptools`` `entry point`_ mechanism.
95
96	This method can be used in conjunction with :obj:`load_from_entry_point` to filter
97	the plugins before actually loading them.
98	"""
99	entries = entry_points()	11✔
100	if hasattr(entries, "select"): # pragma: no cover
101	# The select method was introduced in importlib_metadata 3.9 (and Python 3.10)
102	# and the previous dict interface was declared deprecated
103	select = typing.cast(
104	Any, getattr(entries, "select") # noqa: B009
105	) # typecheck gymnastics
106	entries_: Iterable[EntryPoint] = select(group=group)
107	else: # pragma: no cover
108	# TODO: Once Python 3.10 becomes the oldest version supported, this fallback and
109	# conditional statement can be removed.
110	entries_ = (plugin for plugin in entries.get(group, []))
111	deduplicated = {e.name: e for e in sorted(entries_, key=lambda e: e.name)}	11✔
112	return list(deduplicated.values())	11✔
113
114
115	def load_from_entry_point(entry_point: EntryPoint) -> PluginWrapper:	11✔
116	"""Carefully load the plugin, raising a meaningful message in case of errors"""
117	try:	11✔
118	fn = entry_point.load()	11✔
119	return PluginWrapper(entry_point.name, fn)	11✔
120	except Exception as ex:	11✔
121	raise ErrorLoadingPlugin(entry_point=entry_point) from ex	11✔
122
123
124	def list_from_entry_points(	11✔
125	group: str = ENTRYPOINT_GROUP,
126	filtering: Callable[[EntryPoint], bool] = lambda _: True,
127	) -> List[PluginWrapper]:
128	"""Produces a list of plugin objects for each plugin registered
129	via ``setuptools`` `entry point`_ mechanism.
130
131	Args:
132	group: name of the setuptools' entry point group where plugins is being
133	registered
134	filtering: function returning a boolean deciding if the entry point should be
135	loaded and included (or not) in the final list. A ``True`` return means the
136	plugin should be included.
137	"""
138	return [	11✔
139	load_from_entry_point(e) for e in iterate_entry_points(group) if filtering(e)
140	]
141
142
143	class ErrorLoadingPlugin(RuntimeError):	11✔
144	_DESC = """There was an error loading '{plugin}'.	11✔
145	Please make sure you have installed a version of the plugin that is compatible
146	with {package} {version}. You can also try uninstalling it.
147	"""
148	__doc__ = _DESC	11✔
149
150	def __init__(self, plugin: str = "", entry_point: Optional[EntryPoint] = None):	11✔
151	if entry_point and not plugin:	11!
152	plugin = getattr(entry_point, "module", entry_point.name)	11✔
153
154	sub = {"package": __package__, "version": __version__, "plugin": plugin}	11✔
155	msg = dedent(self._DESC).format(**sub).splitlines()	11✔
156	super().__init__(f"{msg[0]}\n{' '.join(msg[1:])}")	11✔

abravalheri / validate-pyproject / 6146455325376512

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