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
130
131
132
133
134
135
136
137
138
139
140
|
from abc import abstractmethod, ABC
from typing import Literal
from overrides import override, EnforceOverrides
class A(EnforceOverrides):
def methoda(self, x=0):
print(x)
def methodb(self, x: int, /, y: str) -> str:
return y * x
class Other:
def foo(self):
pass
def test_should_pass():
class B(A):
@override
def methoda(self, y=1, **kwargs):
print(y)
super().methoda(**kwargs)
def test_should_also_pass():
class B(A):
@override
def methoda(self, z=1, x=1, **kwargs):
pass
class Abs(ABC):
@abstractmethod
def method(self, str: Literal["max", "min"]):
pass
def test_literal_passes():
class B(Abs):
@override
def method(self, str: Literal["max", "min"]):
return
class C(Abs):
@override
def method(self, str: Literal["max", "min", "half"]):
return
def test_literal_failure():
try:
class D(Abs):
@override
def method(self, str: Literal["a", "b", "c"]):
pass
raise AssertionError("Should not go here")
except TypeError:
pass
def test_literal_failure_not_accepting_all():
try:
class D(Abs):
@override
def method(self, str: Literal["min"]):
pass
raise AssertionError("Should not go here")
except TypeError:
pass
def test_can_not_override_with_positional_only():
try:
class C(A):
@override
def methoda(self, x=0, /):
pass
raise AssertionError("Should not go here")
except TypeError:
pass
def test_can_override_positional_only():
class PositionalOnly1(A):
@override
def methodb(self, x: int, /, y: str) -> str:
return "OK"
def test_can_override_positional_only_with_new_name():
class PositionalOnly2(A):
@override
def methodb(self, new_name_is_ok: int, /, y: str) -> str:
return "OK2"
def test_can_not_override_positional_only_with_new_type():
try:
class PositionalOnly3(A):
@override
def methodb(self, x: str, /, y: str) -> str:
return "NOPE"
raise AssertionError("Should not go here")
except TypeError:
pass
def test_can_not_override_with_keyword_only():
try:
class C2(A):
@override
def methoda(self, *, x=0):
pass
raise AssertionError("Should not go here")
except TypeError:
pass
def test_multiple_inheritance():
class Multi(A, Other):
@override
def methoda(self, y=2, **kwargs):
pass
@override
def foo(self) -> int:
pass
|
