5204399262269440

Committed 20 Nov 2023 04:10PM UTC coverage: 96.683% (-1.9%) from 98.601%

Build # 5204399262269440

Build Type

Pull #121

cirrus-ci

Committed by

henryiii

Commit Message

fix: support multiple tools, add test

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

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

Run Details

309 of 323 branches covered (0.0%)

Branch coverage included in aggregate %.

80 of 93 new or added lines in 6 files covered. (86.02%)

3 existing lines in 3 files now uncovered.

857 of 883 relevant lines covered (97.06%)

10.62 hits per line

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

96.55

/src/validate_pyproject/pre_compile/cli.py

# ruff: noqa: C408
# Unnecessary `dict` call (rewrite as a literal)

import json
import logging
import sys
from functools import partial, wraps
from pathlib import Path
from types import MappingProxyType
from typing import Any, Dict, List, Mapping, NamedTuple, Sequence

from .. import cli
from ..plugins import PluginWrapper
from ..plugins import list_from_entry_points as list_plugins_from_entry_points
from . import pre_compile

if sys.platform == "win32":  # pragma: no cover
    from subprocess import list2cmdline as arg_join
elif sys.version_info[:2] >= (3, 8):  # pragma: no cover
    from shlex import join as arg_join
else:  # pragma: no cover
    from shlex import quote

    def arg_join(args: Sequence[str]) -> str:
        return " ".join(quote(x) for x in args)


_logger = logging.getLogger(__package__)


def JSON_dict(name: str, value: str):
    try:
        return ensure_dict(name, json.loads(value))
    except json.JSONDecodeError as ex:
        raise ValueError(f"Invalid JSON: {value}") from ex


META: Dict[str, dict] = {
    "output_dir": dict(
        flags=("-O", "--output-dir"),
        default=".",
        type=Path,
        help="Path to the directory where the files for embedding will be generated "
        "(default: current working directory)",
    ),
    "main_file": dict(
        flags=("-M", "--main-file"),
        default="__init__.py",
        help="Name of the file that will contain the main `validate` function"
        "(default: `%(default)s`)",
    ),
    "replacements": dict(
        flags=("-R", "--replacements"),
        default="{}",
        type=wraps(JSON_dict)(partial(JSON_dict, "replacements")),
        help="JSON string (don't forget to quote) representing a map between strings "
        "that should be replaced in the generated files and their replacement, "
        "for example: \n"
        '-R \'{"from packaging import": "from .._vendor.packaging import"}\'',
    ),
    "tool": dict(
        flags=("-t", "--tool"),
        action="append",
        dest="tool",
        help="External tools file/url(s) to load, of the form name=URL#path",
    ),
}


def ensure_dict(name: str, value: Any) -> dict:
    if not isinstance(value, dict):
        msg = f"`{value.__class__.__name__}` given (value = {value!r})."
        raise ValueError(f"`{name}` should be a dict. {msg}")
    return value


class CliParams(NamedTuple):
    plugins: List[PluginWrapper]
    output_dir: Path = Path(".")
    main_file: str = "__init__.py"
    replacements: Mapping[str, str] = MappingProxyType({})
    loglevel: int = logging.WARNING
    tool: Sequence[str] = ()


def parser_spec(plugins: Sequence[PluginWrapper]) -> Dict[str, dict]:
    common = ("version", "enable", "disable", "verbose", "very_verbose")
    cli_spec = cli.__meta__(plugins)
    meta = {k: v.copy() for k, v in META.items()}
    meta.update({k: cli_spec[k].copy() for k in common})
    return meta


def run(args: Sequence[str] = ()):
    args = args if args else sys.argv[1:]
    cmd = f"python -m {__package__} " + arg_join(args)
    plugins = list_plugins_from_entry_points()
    desc = 'Generate files for "pre-compiling" `validate-pyproject`'
    prms = cli.parse_args(args, plugins, desc, parser_spec, CliParams)
    cli.setup_logging(prms.loglevel)
    pre_compile(
        prms.output_dir,
        prms.main_file,
        cmd,
        prms.plugins,
        prms.replacements,
        load_tools=prms.tool,
    )
    return 0


main = cli.exceptions2exit()(run)


if __name__ == "__main__":
    main()

1	# ruff: noqa: C408
2	# Unnecessary `dict` call (rewrite as a literal)
3
4	import json	11✔
5	import logging	11✔
6	import sys	11✔
7	from functools import partial, wraps	11✔
8	from pathlib import Path	11✔
9	from types import MappingProxyType	11✔
10	from typing import Any, Dict, List, Mapping, NamedTuple, Sequence	11✔
11
12	from .. import cli	11✔
13	from ..plugins import PluginWrapper	11✔
14	from ..plugins import list_from_entry_points as list_plugins_from_entry_points	11✔
15	from . import pre_compile	11✔
16
17	if sys.platform == "win32": # pragma: no cover
18	from subprocess import list2cmdline as arg_join
19	elif sys.version_info[:2] >= (3, 8): # pragma: no cover
20	from shlex import join as arg_join
21	else: # pragma: no cover
22	from shlex import quote
23
24	def arg_join(args: Sequence[str]) -> str:
25	return " ".join(quote(x) for x in args)
26
27
28	_logger = logging.getLogger(__package__)	11✔
29
30
31	def JSON_dict(name: str, value: str):	11✔
32	try:	11✔
33	return ensure_dict(name, json.loads(value))	11✔
34	except json.JSONDecodeError as ex:	11✔
35	raise ValueError(f"Invalid JSON: {value}") from ex	11✔
36
37
38	META: Dict[str, dict] = {	11✔
39	"output_dir": dict(
40	flags=("-O", "--output-dir"),
41	default=".",
42	type=Path,
43	help="Path to the directory where the files for embedding will be generated "
44	"(default: current working directory)",
45	),
46	"main_file": dict(
47	flags=("-M", "--main-file"),
48	default="__init__.py",
49	help="Name of the file that will contain the main `validate` function"
50	"(default: `%(default)s`)",
51	),
52	"replacements": dict(
53	flags=("-R", "--replacements"),
54	default="{}",
55	type=wraps(JSON_dict)(partial(JSON_dict, "replacements")),
56	help="JSON string (don't forget to quote) representing a map between strings "
57	"that should be replaced in the generated files and their replacement, "
58	"for example: \n"
59	'-R \'{"from packaging import": "from .._vendor.packaging import"}\'',
60	),
61	"tool": dict(
62	flags=("-t", "--tool"),
63	action="append",
64	dest="tool",
65	help="External tools file/url(s) to load, of the form name=URL#path",
66	),
67	}
68
69
70	def ensure_dict(name: str, value: Any) -> dict:	11✔
71	if not isinstance(value, dict):	11✔
72	msg = f"`{value.__class__.__name__}` given (value = {value!r})."	11✔
73	raise ValueError(f"`{name}` should be a dict. {msg}")	11✔
74	return value	11✔
75
76
77	class CliParams(NamedTuple):	11✔
78	plugins: List[PluginWrapper]	11✔
79	output_dir: Path = Path(".")	11✔
80	main_file: str = "__init__.py"	11✔
81	replacements: Mapping[str, str] = MappingProxyType({})	11✔
82	loglevel: int = logging.WARNING	11✔
83	tool: Sequence[str] = ()	11✔
84
85
86	def parser_spec(plugins: Sequence[PluginWrapper]) -> Dict[str, dict]:	11✔
87	common = ("version", "enable", "disable", "verbose", "very_verbose")	11✔
88	cli_spec = cli.__meta__(plugins)	11✔
89	meta = {k: v.copy() for k, v in META.items()}	11✔
90	meta.update({k: cli_spec[k].copy() for k in common})	11✔
91	return meta	11✔
92
93
94	def run(args: Sequence[str] = ()):	11✔
95	args = args if args else sys.argv[1:]	11✔
96	cmd = f"python -m {__package__} " + arg_join(args)	11✔
97	plugins = list_plugins_from_entry_points()	11✔
98	desc = 'Generate files for "pre-compiling" `validate-pyproject`'	11✔
99	prms = cli.parse_args(args, plugins, desc, parser_spec, CliParams)	11✔
100	cli.setup_logging(prms.loglevel)	11✔
101	pre_compile(	11✔
102	prms.output_dir,
103	prms.main_file,
104	cmd,
105	prms.plugins,
106	prms.replacements,
107	load_tools=prms.tool,
108	)
109	return 0	11✔
110
111
112	main = cli.exceptions2exit()(run)	11✔
113
114
115	if __name__ == "__main__":	11!
UNCOV 116	main()	×

abravalheri / validate-pyproject / 5204399262269440

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