1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
import inspect
from typing import Annotated, List, Optional, Set
import pytest
from cyclopts import Parameter
def test_parameter_get_negatives_bool_default():
p = Parameter(name=("--foo", "--bar"))
assert ("--no-foo", "--no-bar") == p.get_negatives(bool)
@pytest.mark.parametrize("type_", [list, set, List[str], Set[str]])
def test_parameter_get_negatives_iterable_default(type_):
p = Parameter(name=("--foo", "--bar"))
assert ("--empty-foo", "--empty-bar") == p.get_negatives(type_)
@pytest.mark.parametrize("type_", [list, set, List[str], Set[str]])
def test_parameter_get_negatives_iterable_custom_prefix(type_):
p = Parameter(negative_iterable="vacant-", name=("--foo", "--bar"))
assert ("--vacant-foo", "--vacant-bar") == p.get_negatives(type_)
@pytest.mark.parametrize("type_", [list, set, List[str], Set[str]])
def test_parameter_get_negatives_iterable_custom_prefix_list(type_):
p = Parameter(negative_iterable=["vacant-", "blank-"], name=("--foo", "--bar"))
assert {"--vacant-foo", "--vacant-bar", "--blank-foo", "--blank-bar"} == set(p.get_negatives(type_))
def test_parameter_negative_iterable_invalid_name(app, assert_parse_args):
Parameter(negative_iterable=()) # Valid
with pytest.raises(ValueError):
Parameter(negative_iterable="--starts-with-hyphens")
@pytest.mark.parametrize("type_", [bool, list, set])
def test_parameter_get_negatives_custom_single(type_):
p = Parameter(negative="--foo", name=("this-string-doesnt-matter", "neither-does-this-one"))
assert ("--foo",) == p.get_negatives(type_)
@pytest.mark.parametrize("type_", [bool, list, set])
def test_parameter_get_negatives_bool_custom_list(type_):
p = Parameter(negative=["--foo", "--bar"], name="this-string-doesnt-matter")
assert ("--foo", "--bar") == p.get_negatives(type_)
@pytest.mark.parametrize("type_", [bool, list, set])
def test_parameter_get_negatives_bool_custom_prefix(type_):
p = Parameter(negative_bool="yesnt-", name=("--foo", "--bar"))
assert ("--yesnt-foo", "--yesnt-bar") == p.get_negatives(bool)
def test_parameter_negative_bool_invalid_name(app, assert_parse_args):
Parameter(negative_bool=()) # Valid
with pytest.raises(ValueError):
Parameter(negative_bool="--starts-with-hyphens")
@pytest.mark.parametrize("type_", [bool, list, set])
def test_parameter_get_negatives_bool_custom_prefix_list(type_):
p = Parameter(negative_bool=["yesnt-", "not-"], name=("--foo", "--bar"))
assert {"--yesnt-foo", "--yesnt-bar", "--not-foo", "--not-bar"} == set(p.get_negatives(bool))
def test_parameter_from_annotation_basic():
expected_cparam = Parameter(
name=["--help", "-h"],
negative="",
show_default=False,
help="Display this message and exit.",
)
assert (bool, expected_cparam) == Parameter.from_annotation(Annotated[bool, expected_cparam], Parameter())
def test_parameter_from_annotation_optional_annotated():
expected_cparam = Parameter(
name=["--help", "-h"],
negative="",
show_default=False,
help="Display this message and exit.",
)
assert (bool, expected_cparam) == Parameter.from_annotation(Optional[Annotated[bool, expected_cparam]], Parameter())
def test_parameter_from_annotation_empty_annotation():
assert (inspect.Parameter.empty, Parameter()) == Parameter.from_annotation(inspect.Parameter.empty, Parameter())
def test_parameter_combine():
p1 = Parameter(negative="--foo")
p2 = Parameter(show_default=False)
p_combined = Parameter.combine(p1, None, p2)
assert p_combined.negative == ("--foo",)
assert p_combined.show_default is False
def test_parameter_combine_priority():
p1 = Parameter(negative="--foo")
p2 = Parameter(negative="--bar")
p_combined = Parameter.combine(p1, p2)
assert p_combined.negative == ("--bar",)
def test_parameter_combine_priority_none():
p1 = Parameter(negative="--foo")
p2 = Parameter(negative=None)
p_combined = Parameter.combine(p1, p2)
assert p_combined.negative is None
def test_parameter_default():
p1 = Parameter()
p2 = Parameter.default()
# The two parameters should be equivalent.
assert p1 == p2
# However, the _provided_args field should differ
assert p1._provided_args == ()
# Just testing a few
assert {"name", "converter", "validator"}.issubset(p2._provided_args)
|
