| |
| |
| |
| |
| @@ -195,16 +195,19 @@ def to_tuple(t): |
| "type X[T, *Ts, **P] = (T, Ts, P)", |
| "type X[T: int, *Ts, **P] = (T, Ts, P)", |
| "type X[T: (int, str), *Ts, **P] = (T, Ts, P)", |
| + "type X[T: int = 1, *Ts = 2, **P =3] = (T, Ts, P)", |
| # Generic classes |
| "class X[T]: pass", |
| "class X[T, *Ts, **P]: pass", |
| "class X[T: int, *Ts, **P]: pass", |
| "class X[T: (int, str), *Ts, **P]: pass", |
| + "class X[T: int = 1, *Ts = 2, **P = 3]: pass", |
| # Generic functions |
| "def f[T](): pass", |
| "def f[T, *Ts, **P](): pass", |
| "def f[T: int, *Ts, **P](): pass", |
| "def f[T: (int, str), *Ts, **P](): pass", |
| + "def f[T: int = 1, *Ts = 2, **P = 3](): pass", |
| ] |
| |
| # These are compiled through "single" |
| @@ -1108,6 +1111,18 @@ def test_type_params_feature_version(self): |
| with self.assertRaises(SyntaxError): |
| ast.parse(sample, feature_version=(3, 11)) |
| |
| + def test_type_params_default_feature_version(self): |
| + samples = [ |
| + "type X[*Ts=int] = int", |
| + "class X[T=int]: pass", |
| + "def f[**P=int](): pass", |
| + ] |
| + for sample in samples: |
| + with self.subTest(sample): |
| + ast.parse(sample) |
| + with self.assertRaises(SyntaxError): |
| + ast.parse(sample, feature_version=(3, 12)) |
| + |
| def test_invalid_major_feature_version(self): |
| with self.assertRaises(ValueError): |
| ast.parse('pass', feature_version=(2, 7)) |
| @@ -3261,18 +3276,21 @@ def main(): |
| ('Module', [('FunctionDef', (1, 0, 1, 42), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], ('arg', (1, 29, 1, 35), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 38, 1, 42))], [], None, None, [])], []), |
| ('Module', [('FunctionDef', (1, 0, 1, 40), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], ('arg', (1, 27, 1, 33), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 36, 1, 40))], [], None, None, [])], []), |
| ('Module', [('TypeAlias', (1, 0, 1, 12), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [], ('Name', (1, 9, 1, 12), 'int', ('Load',)))], []), |
| -('Module', [('TypeAlias', (1, 0, 1, 15), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None)], ('Name', (1, 12, 1, 15), 'int', ('Load',)))], []), |
| -('Module', [('TypeAlias', (1, 0, 1, 32), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None), ('TypeVarTuple', (1, 10, 1, 13), 'Ts'), ('ParamSpec', (1, 15, 1, 18), 'P')], ('Tuple', (1, 22, 1, 32), [('Name', (1, 23, 1, 24), 'T', ('Load',)), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Name', (1, 30, 1, 31), 'P', ('Load',))], ('Load',)))], []), |
| -('Module', [('TypeAlias', (1, 0, 1, 37), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 13), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',))), ('TypeVarTuple', (1, 15, 1, 18), 'Ts'), ('ParamSpec', (1, 20, 1, 23), 'P')], ('Tuple', (1, 27, 1, 37), [('Name', (1, 28, 1, 29), 'T', ('Load',)), ('Name', (1, 31, 1, 33), 'Ts', ('Load',)), ('Name', (1, 35, 1, 36), 'P', ('Load',))], ('Load',)))], []), |
| -('Module', [('TypeAlias', (1, 0, 1, 44), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 20), 'T', ('Tuple', (1, 10, 1, 20), [('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Name', (1, 16, 1, 19), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 22, 1, 25), 'Ts'), ('ParamSpec', (1, 27, 1, 30), 'P')], ('Tuple', (1, 34, 1, 44), [('Name', (1, 35, 1, 36), 'T', ('Load',)), ('Name', (1, 38, 1, 40), 'Ts', ('Load',)), ('Name', (1, 42, 1, 43), 'P', ('Load',))], ('Load',)))], []), |
| -('Module', [('ClassDef', (1, 0, 1, 16), 'X', [], [], [('Pass', (1, 12, 1, 16))], [], [('TypeVar', (1, 8, 1, 9), 'T', None)])], []), |
| -('Module', [('ClassDef', (1, 0, 1, 26), 'X', [], [], [('Pass', (1, 22, 1, 26))], [], [('TypeVar', (1, 8, 1, 9), 'T', None), ('TypeVarTuple', (1, 11, 1, 14), 'Ts'), ('ParamSpec', (1, 16, 1, 19), 'P')])], []), |
| -('Module', [('ClassDef', (1, 0, 1, 31), 'X', [], [], [('Pass', (1, 27, 1, 31))], [], [('TypeVar', (1, 8, 1, 14), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',))), ('TypeVarTuple', (1, 16, 1, 19), 'Ts'), ('ParamSpec', (1, 21, 1, 24), 'P')])], []), |
| -('Module', [('ClassDef', (1, 0, 1, 38), 'X', [], [], [('Pass', (1, 34, 1, 38))], [], [('TypeVar', (1, 8, 1, 21), 'T', ('Tuple', (1, 11, 1, 21), [('Name', (1, 12, 1, 15), 'int', ('Load',)), ('Name', (1, 17, 1, 20), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 23, 1, 26), 'Ts'), ('ParamSpec', (1, 28, 1, 31), 'P')])], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 12, 1, 16))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None)])], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None), ('TypeVarTuple', (1, 9, 1, 12), 'Ts'), ('ParamSpec', (1, 14, 1, 17), 'P')])], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 31), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 27, 1, 31))], [], None, None, [('TypeVar', (1, 6, 1, 12), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',))), ('TypeVarTuple', (1, 14, 1, 17), 'Ts'), ('ParamSpec', (1, 19, 1, 22), 'P')])], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 38), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 34, 1, 38))], [], None, None, [('TypeVar', (1, 6, 1, 19), 'T', ('Tuple', (1, 9, 1, 19), [('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Name', (1, 15, 1, 18), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 21, 1, 24), 'Ts'), ('ParamSpec', (1, 26, 1, 29), 'P')])], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 15), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None, None)], ('Name', (1, 12, 1, 15), 'int', ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 32), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None, None), ('TypeVarTuple', (1, 10, 1, 13), 'Ts', None), ('ParamSpec', (1, 15, 1, 18), 'P', None)], ('Tuple', (1, 22, 1, 32), [('Name', (1, 23, 1, 24), 'T', ('Load',)), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Name', (1, 30, 1, 31), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 37), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 13), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',)), None), ('TypeVarTuple', (1, 15, 1, 18), 'Ts', None), ('ParamSpec', (1, 20, 1, 23), 'P', None)], ('Tuple', (1, 27, 1, 37), [('Name', (1, 28, 1, 29), 'T', ('Load',)), ('Name', (1, 31, 1, 33), 'Ts', ('Load',)), ('Name', (1, 35, 1, 36), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 44), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 20), 'T', ('Tuple', (1, 10, 1, 20), [('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Name', (1, 16, 1, 19), 'str', ('Load',))], ('Load',)), None), ('TypeVarTuple', (1, 22, 1, 25), 'Ts', None), ('ParamSpec', (1, 27, 1, 30), 'P', None)], ('Tuple', (1, 34, 1, 44), [('Name', (1, 35, 1, 36), 'T', ('Load',)), ('Name', (1, 38, 1, 40), 'Ts', ('Load',)), ('Name', (1, 42, 1, 43), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 48), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 17), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Constant', (1, 16, 1, 17), 1, None)), ('TypeVarTuple', (1, 19, 1, 26), 'Ts', ('Constant', (1, 25, 1, 26), 2, None)), ('ParamSpec', (1, 28, 1, 34), 'P', ('Constant', (1, 33, 1, 34), 3, None))], ('Tuple', (1, 38, 1, 48), [('Name', (1, 39, 1, 40), 'T', ('Load',)), ('Name', (1, 42, 1, 44), 'Ts', ('Load',)), ('Name', (1, 46, 1, 47), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('ClassDef', (1, 0, 1, 16), 'X', [], [], [('Pass', (1, 12, 1, 16))], [], [('TypeVar', (1, 8, 1, 9), 'T', None, None)])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 26), 'X', [], [], [('Pass', (1, 22, 1, 26))], [], [('TypeVar', (1, 8, 1, 9), 'T', None, None), ('TypeVarTuple', (1, 11, 1, 14), 'Ts', None), ('ParamSpec', (1, 16, 1, 19), 'P', None)])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 31), 'X', [], [], [('Pass', (1, 27, 1, 31))], [], [('TypeVar', (1, 8, 1, 14), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',)), None), ('TypeVarTuple', (1, 16, 1, 19), 'Ts', None), ('ParamSpec', (1, 21, 1, 24), 'P', None)])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 38), 'X', [], [], [('Pass', (1, 34, 1, 38))], [], [('TypeVar', (1, 8, 1, 21), 'T', ('Tuple', (1, 11, 1, 21), [('Name', (1, 12, 1, 15), 'int', ('Load',)), ('Name', (1, 17, 1, 20), 'str', ('Load',))], ('Load',)), None), ('TypeVarTuple', (1, 23, 1, 26), 'Ts', None), ('ParamSpec', (1, 28, 1, 31), 'P', None)])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 43), 'X', [], [], [('Pass', (1, 39, 1, 43))], [], [('TypeVar', (1, 8, 1, 18), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Constant', (1, 17, 1, 18), 1, None)), ('TypeVarTuple', (1, 20, 1, 27), 'Ts', ('Constant', (1, 26, 1, 27), 2, None)), ('ParamSpec', (1, 29, 1, 36), 'P', ('Constant', (1, 35, 1, 36), 3, None))])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 12, 1, 16))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None, None)])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None, None), ('TypeVarTuple', (1, 9, 1, 12), 'Ts', None), ('ParamSpec', (1, 14, 1, 17), 'P', None)])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 31), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 27, 1, 31))], [], None, None, [('TypeVar', (1, 6, 1, 12), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',)), None), ('TypeVarTuple', (1, 14, 1, 17), 'Ts', None), ('ParamSpec', (1, 19, 1, 22), 'P', None)])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 38), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 34, 1, 38))], [], None, None, [('TypeVar', (1, 6, 1, 19), 'T', ('Tuple', (1, 9, 1, 19), [('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Name', (1, 15, 1, 18), 'str', ('Load',))], ('Load',)), None), ('TypeVarTuple', (1, 21, 1, 24), 'Ts', None), ('ParamSpec', (1, 26, 1, 29), 'P', None)])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 43), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 39, 1, 43))], [], None, None, [('TypeVar', (1, 6, 1, 16), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',)), ('Constant', (1, 15, 1, 16), 1, None)), ('TypeVarTuple', (1, 18, 1, 25), 'Ts', ('Constant', (1, 24, 1, 25), 2, None)), ('ParamSpec', (1, 27, 1, 34), 'P', ('Constant', (1, 33, 1, 34), 3, None))])], []), |
| ] |
| single_results = [ |
| ('Interactive', [('Expr', (1, 0, 1, 3), ('BinOp', (1, 0, 1, 3), ('Constant', (1, 0, 1, 1), 1, None), ('Add',), ('Constant', (1, 2, 1, 3), 2, None)))]), |
| |
| |
| |
| |
| @@ -6,7 +6,7 @@ |
| import weakref |
| from test.support import requires_working_socket, check_syntax_error, run_code |
| |
| -from typing import Generic, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args |
| +from typing import Generic, NoDefault, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args |
| |
| |
| class TypeParamsInvalidTest(unittest.TestCase): |
| @@ -412,6 +412,14 @@ def test_comprehension_02(self): |
| func, = T.__bound__ |
| self.assertEqual(func(), 1) |
| |
| + def test_comprehension_03(self): |
| + def F[T: [lambda: T for T in (T, [1])[1]]](): return [lambda: T for T in T.__name__] |
| + func, = F() |
| + self.assertEqual(func(), "T") |
| + T, = F.__type_params__ |
| + func, = T.__bound__ |
| + self.assertEqual(func(), 1) |
| + |
| def test_gen_exp_in_nested_class(self): |
| code = """ |
| from test.test_type_params import make_base |
| @@ -591,10 +599,12 @@ class Foo[T: Foo, U: (Foo, Foo)]: |
| self.assertEqual(type_params[0].__name__, "T") |
| self.assertIs(type_params[0].__bound__, Foo) |
| self.assertEqual(type_params[0].__constraints__, ()) |
| + self.assertIs(type_params[0].__default__, NoDefault) |
| |
| self.assertEqual(type_params[1].__name__, "U") |
| self.assertIs(type_params[1].__bound__, None) |
| self.assertEqual(type_params[1].__constraints__, (Foo, Foo)) |
| + self.assertIs(type_params[1].__default__, NoDefault) |
| |
| def test_evaluation_error(self): |
| class Foo[T: Undefined, U: (Undefined,)]: |
| @@ -605,6 +615,8 @@ class Foo[T: Undefined, U: (Undefined,)]: |
| type_params[0].__bound__ |
| self.assertEqual(type_params[0].__constraints__, ()) |
| self.assertIs(type_params[1].__bound__, None) |
| + self.assertIs(type_params[0].__default__, NoDefault) |
| + self.assertIs(type_params[1].__default__, NoDefault) |
| with self.assertRaises(NameError): |
| type_params[1].__constraints__ |
| |
| @@ -1158,3 +1170,103 @@ class Inner[U](T): |
| """ |
| with self.assertRaises(RuntimeError): |
| run_code(code) |
| + |
| + |
| +class DefaultsTest(unittest.TestCase): |
| + def test_defaults_on_func(self): |
| + ns = run_code(""" |
| + def func[T=int, **U=float, *V=None](): |
| + pass |
| + """) |
| + |
| + T, U, V = ns["func"].__type_params__ |
| + self.assertIs(T.__default__, int) |
| + self.assertIs(U.__default__, float) |
| + self.assertIs(V.__default__, None) |
| + |
| + def test_defaults_on_class(self): |
| + ns = run_code(""" |
| + class C[T=int, **U=float, *V=None]: |
| + pass |
| + """) |
| + |
| + T, U, V = ns["C"].__type_params__ |
| + self.assertIs(T.__default__, int) |
| + self.assertIs(U.__default__, float) |
| + self.assertIs(V.__default__, None) |
| + |
| + def test_defaults_on_type_alias(self): |
| + ns = run_code(""" |
| + type Alias[T = int, **U = float, *V = None] = int |
| + """) |
| + |
| + T, U, V = ns["Alias"].__type_params__ |
| + self.assertIs(T.__default__, int) |
| + self.assertIs(U.__default__, float) |
| + self.assertIs(V.__default__, None) |
| + |
| + def test_starred_invalid(self): |
| + check_syntax_error(self, "type Alias[T = *int] = int") |
| + check_syntax_error(self, "type Alias[**P = *int] = int") |
| + |
| + def test_starred_typevartuple(self): |
| + ns = run_code(""" |
| + default = tuple[int, str] |
| + type Alias[*Ts = *default] = Ts |
| + """) |
| + |
| + Ts, = ns["Alias"].__type_params__ |
| + self.assertEqual(Ts.__default__, next(iter(ns["default"]))) |
| + |
| + def test_nondefault_after_default(self): |
| + check_syntax_error(self, "def func[T=int, U](): pass") |
| + check_syntax_error(self, "class C[T=int, U]: pass") |
| + check_syntax_error(self, "type A[T=int, U] = int") |
| + |
| + def test_lazy_evaluation(self): |
| + ns = run_code(""" |
| + type Alias[T = Undefined, *U = Undefined, **V = Undefined] = int |
| + """) |
| + |
| + T, U, V = ns["Alias"].__type_params__ |
| + |
| + with self.assertRaises(NameError): |
| + T.__default__ |
| + with self.assertRaises(NameError): |
| + U.__default__ |
| + with self.assertRaises(NameError): |
| + V.__default__ |
| + |
| + ns["Undefined"] = "defined" |
| + self.assertEqual(T.__default__, "defined") |
| + self.assertEqual(U.__default__, "defined") |
| + self.assertEqual(V.__default__, "defined") |
| + |
| + # Now it is cached |
| + ns["Undefined"] = "redefined" |
| + self.assertEqual(T.__default__, "defined") |
| + self.assertEqual(U.__default__, "defined") |
| + self.assertEqual(V.__default__, "defined") |
| + |
| + def test_symtable_key_regression_default(self): |
| + # Test against the bugs that would happen if we used .default_ |
| + # as the key in the symtable. |
| + ns = run_code(""" |
| + type X[T = [T for T in [T]]] = T |
| + """) |
| + |
| + T, = ns["X"].__type_params__ |
| + self.assertEqual(T.__default__, [T]) |
| + |
| + def test_symtable_key_regression_name(self): |
| + # Test against the bugs that would happen if we used .name |
| + # as the key in the symtable. |
| + ns = run_code(""" |
| + type X1[T = A] = T |
| + type X2[T = B] = T |
| + A = "A" |
| + B = "B" |
| + """) |
| + |
| + self.assertEqual(ns["X1"].__type_params__[0].__default__, "A") |
| + self.assertEqual(ns["X2"].__type_params__[0].__default__, "B") |
| |
| |
| |
| |
| @@ -38,7 +38,7 @@ |
| from typing import Self, LiteralString |
| from typing import TypeAlias |
| from typing import ParamSpec, Concatenate, ParamSpecArgs, ParamSpecKwargs |
| -from typing import TypeGuard, TypeIs |
| +from typing import TypeGuard, TypeIs, NoDefault |
| import abc |
| import textwrap |
| import typing |
| @@ -580,6 +580,174 @@ def test_constructor(self): |
| self.assertIs(T.__bound__, None) |
| |
| |
| +class TypeParameterDefaultsTests(BaseTestCase): |
| + def test_typevar(self): |
| + T = TypeVar('T', default=int) |
| + self.assertEqual(T.__default__, int) |
| + self.assertTrue(T.has_default()) |
| + self.assertIsInstance(T, TypeVar) |
| + |
| + class A(Generic[T]): ... |
| + Alias = Optional[T] |
| + |
| + def test_typevar_none(self): |
| + U = TypeVar('U') |
| + U_None = TypeVar('U_None', default=None) |
| + self.assertIs(U.__default__, NoDefault) |
| + self.assertFalse(U.has_default()) |
| + self.assertIs(U_None.__default__, None) |
| + self.assertTrue(U_None.has_default()) |
| + |
| + class X[T]: ... |
| + T, = X.__type_params__ |
| + self.assertIs(T.__default__, NoDefault) |
| + self.assertFalse(T.has_default()) |
| + |
| + def test_paramspec(self): |
| + P = ParamSpec('P', default=(str, int)) |
| + self.assertEqual(P.__default__, (str, int)) |
| + self.assertTrue(P.has_default()) |
| + self.assertIsInstance(P, ParamSpec) |
| + |
| + class A(Generic[P]): ... |
| + Alias = typing.Callable[P, None] |
| + |
| + P_default = ParamSpec('P_default', default=...) |
| + self.assertIs(P_default.__default__, ...) |
| + |
| + def test_paramspec_none(self): |
| + U = ParamSpec('U') |
| + U_None = ParamSpec('U_None', default=None) |
| + self.assertIs(U.__default__, NoDefault) |
| + self.assertFalse(U.has_default()) |
| + self.assertIs(U_None.__default__, None) |
| + self.assertTrue(U_None.has_default()) |
| + |
| + class X[**P]: ... |
| + P, = X.__type_params__ |
| + self.assertIs(P.__default__, NoDefault) |
| + self.assertFalse(P.has_default()) |
| + |
| + def test_typevartuple(self): |
| + Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]]) |
| + self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]]) |
| + self.assertTrue(Ts.has_default()) |
| + self.assertIsInstance(Ts, TypeVarTuple) |
| + |
| + class A(Generic[Unpack[Ts]]): ... |
| + Alias = Optional[Unpack[Ts]] |
| + |
| + def test_typevartuple_specialization(self): |
| + T = TypeVar("T") |
| + Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]]) |
| + self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]]) |
| + class A(Generic[T, Unpack[Ts]]): ... |
| + self.assertEqual(A[float].__args__, (float, str, int)) |
| + self.assertEqual(A[float, range].__args__, (float, range)) |
| + self.assertEqual(A[float, *tuple[int, ...]].__args__, (float, *tuple[int, ...])) |
| + |
| + def test_typevar_and_typevartuple_specialization(self): |
| + T = TypeVar("T") |
| + U = TypeVar("U", default=float) |
| + Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]]) |
| + self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]]) |
| + class A(Generic[T, U, Unpack[Ts]]): ... |
| + self.assertEqual(A[int].__args__, (int, float, str, int)) |
| + self.assertEqual(A[int, str].__args__, (int, str, str, int)) |
| + self.assertEqual(A[int, str, range].__args__, (int, str, range)) |
| + self.assertEqual(A[int, str, *tuple[int, ...]].__args__, (int, str, *tuple[int, ...])) |
| + |
| + def test_no_default_after_typevar_tuple(self): |
| + T = TypeVar("T", default=int) |
| + Ts = TypeVarTuple("Ts") |
| + Ts_default = TypeVarTuple("Ts_default", default=Unpack[Tuple[str, int]]) |
| + |
| + with self.assertRaises(TypeError): |
| + class X(Generic[*Ts, T]): ... |
| + |
| + with self.assertRaises(TypeError): |
| + class Y(Generic[*Ts_default, T]): ... |
| + |
| + def test_paramspec_specialization(self): |
| + T = TypeVar("T") |
| + P = ParamSpec('P', default=[str, int]) |
| + self.assertEqual(P.__default__, [str, int]) |
| + class A(Generic[T, P]): ... |
| + self.assertEqual(A[float].__args__, (float, (str, int))) |
| + self.assertEqual(A[float, [range]].__args__, (float, (range,))) |
| + |
| + def test_typevar_and_paramspec_specialization(self): |
| + T = TypeVar("T") |
| + U = TypeVar("U", default=float) |
| + P = ParamSpec('P', default=[str, int]) |
| + self.assertEqual(P.__default__, [str, int]) |
| + class A(Generic[T, U, P]): ... |
| + self.assertEqual(A[float].__args__, (float, float, (str, int))) |
| + self.assertEqual(A[float, int].__args__, (float, int, (str, int))) |
| + self.assertEqual(A[float, int, [range]].__args__, (float, int, (range,))) |
| + |
| + def test_paramspec_and_typevar_specialization(self): |
| + T = TypeVar("T") |
| + P = ParamSpec('P', default=[str, int]) |
| + U = TypeVar("U", default=float) |
| + self.assertEqual(P.__default__, [str, int]) |
| + class A(Generic[T, P, U]): ... |
| + self.assertEqual(A[float].__args__, (float, (str, int), float)) |
| + self.assertEqual(A[float, [range]].__args__, (float, (range,), float)) |
| + self.assertEqual(A[float, [range], int].__args__, (float, (range,), int)) |
| + |
| + def test_typevartuple_none(self): |
| + U = TypeVarTuple('U') |
| + U_None = TypeVarTuple('U_None', default=None) |
| + self.assertIs(U.__default__, NoDefault) |
| + self.assertFalse(U.has_default()) |
| + self.assertIs(U_None.__default__, None) |
| + self.assertTrue(U_None.has_default()) |
| + |
| + class X[**Ts]: ... |
| + Ts, = X.__type_params__ |
| + self.assertIs(Ts.__default__, NoDefault) |
| + self.assertFalse(Ts.has_default()) |
| + |
| + def test_no_default_after_non_default(self): |
| + DefaultStrT = TypeVar('DefaultStrT', default=str) |
| + T = TypeVar('T') |
| + |
| + with self.assertRaisesRegex( |
| + TypeError, r"Type parameter ~T without a default follows type parameter with a default" |
| + ): |
| + Test = Generic[DefaultStrT, T] |
| + |
| + def test_need_more_params(self): |
| + DefaultStrT = TypeVar('DefaultStrT', default=str) |
| + T = TypeVar('T') |
| + U = TypeVar('U') |
| + |
| + class A(Generic[T, U, DefaultStrT]): ... |
| + A[int, bool] |
| + A[int, bool, str] |
| + |
| + with self.assertRaisesRegex( |
| + TypeError, r"Too few arguments for .+; actual 1, expected at least 2" |
| + ): |
| + Test = A[int] |
| + |
| + def test_pickle(self): |
| + global U, U_co, U_contra, U_default # pickle wants to reference the class by name |
| + U = TypeVar('U') |
| + U_co = TypeVar('U_co', covariant=True) |
| + U_contra = TypeVar('U_contra', contravariant=True) |
| + U_default = TypeVar('U_default', default=int) |
| + for proto in range(pickle.HIGHEST_PROTOCOL): |
| + for typevar in (U, U_co, U_contra, U_default): |
| + z = pickle.loads(pickle.dumps(typevar, proto)) |
| + self.assertEqual(z.__name__, typevar.__name__) |
| + self.assertEqual(z.__covariant__, typevar.__covariant__) |
| + self.assertEqual(z.__contravariant__, typevar.__contravariant__) |
| + self.assertEqual(z.__bound__, typevar.__bound__) |
| + self.assertEqual(z.__default__, typevar.__default__) |
| + |
| + |
| def template_replace(templates: list[str], replacements: dict[str, list[str]]) -> list[tuple[str]]: |
| """Renders templates with possible combinations of replacements. |
| |
| @@ -10001,6 +10169,26 @@ class CustomerModel(ModelBase, init=False): |
| self.assertIsInstance(CustomerModel, Decorated) |
| |
| |
| +class NoDefaultTests(BaseTestCase): |
| + def test_pickling(self): |
| + for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| + s = pickle.dumps(NoDefault, proto) |
| + loaded = pickle.loads(s) |
| + self.assertIs(NoDefault, loaded) |
| + |
| + def test_constructor(self): |
| + self.assertIs(NoDefault, type(NoDefault)()) |
| + with self.assertRaises(TypeError): |
| + NoDefault(1) |
| + |
| + def test_repr(self): |
| + self.assertEqual(repr(NoDefault), 'typing.NoDefault') |
| + |
| + def test_no_call(self): |
| + with self.assertRaises(TypeError): |
| + NoDefault() |
| + |
| + |
| class AllTests(BaseTestCase): |
| """Tests for __all__.""" |
| |
| |
| |
| |
| |
| @@ -673,6 +673,20 @@ def test_quote_in_format_spec(self): |
| self.check_ast_roundtrip("""f'\\'{x:\\"}' """) |
| self.check_ast_roundtrip("""f'\\'{x:\\\\"}' """) |
| |
| + def test_type_params(self): |
| + self.check_ast_roundtrip("type A = int") |
| + self.check_ast_roundtrip("type A[T] = int") |
| + self.check_ast_roundtrip("type A[T: int] = int") |
| + self.check_ast_roundtrip("type A[T = int] = int") |
| + self.check_ast_roundtrip("type A[T: int = int] = int") |
| + self.check_ast_roundtrip("type A[**P] = int") |
| + self.check_ast_roundtrip("type A[**P = int] = int") |
| + self.check_ast_roundtrip("type A[*Ts] = int") |
| + self.check_ast_roundtrip("type A[*Ts = int] = int") |
| + self.check_ast_roundtrip("type A[*Ts = *int] = int") |
| + self.check_ast_roundtrip("def f[T: int = int, **P = int, *Ts = *int]():\n pass") |
| + self.check_ast_roundtrip("class C[T: int = int, **P = int, *Ts = *int]():\n pass") |
| + |
| |
| class ManualASTCreationTestCase(unittest.TestCase): |
| """Test that AST nodes created without a type_params field unparse correctly.""" |
| @@ -723,6 +737,20 @@ def test_function_with_type_params_and_bound(self): |
| ast.fix_missing_locations(node) |
| self.assertEqual(ast.unparse(node), "def f[T: int]():\n pass") |
| |
| + def test_function_with_type_params_and_default(self): |
| + node = ast.FunctionDef( |
| + name="f", |
| + args=ast.arguments(), |
| + body=[ast.Pass()], |
| + type_params=[ |
| + ast.TypeVar("T", default_value=ast.Constant(value=1)), |
| + ast.TypeVarTuple("Ts", default_value=ast.Starred(value=ast.Constant(value=1), ctx=ast.Load())), |
| + ast.ParamSpec("P", default_value=ast.Constant(value=1)), |
| + ], |
| + ) |
| + ast.fix_missing_locations(node) |
| + self.assertEqual(ast.unparse(node), "def f[T = 1, *Ts = *1, **P = 1]():\n pass") |
| + |
| def test_async_function(self): |
| node = ast.AsyncFunctionDef( |
| name="f", |
| @@ -746,6 +774,20 @@ def test_async_function_with_type_params(self): |
| ast.fix_missing_locations(node) |
| self.assertEqual(ast.unparse(node), "async def f[T]():\n pass") |
| |
| + def test_async_function_with_type_params_and_default(self): |
| + node = ast.AsyncFunctionDef( |
| + name="f", |
| + args=ast.arguments(), |
| + body=[ast.Pass()], |
| + type_params=[ |
| + ast.TypeVar("T", default_value=ast.Constant(value=1)), |
| + ast.TypeVarTuple("Ts", default_value=ast.Starred(value=ast.Constant(value=1), ctx=ast.Load())), |
| + ast.ParamSpec("P", default_value=ast.Constant(value=1)), |
| + ], |
| + ) |
| + ast.fix_missing_locations(node) |
| + self.assertEqual(ast.unparse(node), "async def f[T = 1, *Ts = *1, **P = 1]():\n pass") |
| + |
| |
| class DirectoryTestCase(ASTTestCase): |
| """Test roundtrip behaviour on all files in Lib and Lib/test.""" |
|
|
