Visitar URL original
bpo-46642: explicitly disallow typing.TypeVar instance subclassing by GBeauregard · Pull Request #31148 · python/cpython · GitHub
Skip to content

bpo-46642: explicitly disallow typing.TypeVar instance subclassing #31148

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
serhiy-storchaka merged 7 commits into from
Jun 25, 2022
Merged

bpo-46642: explicitly disallow typing.TypeVar instance subclassing #31148

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
c51f48e
explicitly disallow typing.TypeVar subclassing
GBeauregard Feb 5, 2022
3659772
📜🤖 Added by blurb_it.
blurb-it[bot] Feb 5, 2022
a3c54d5
make test match regex
GBeauregard Feb 6, 2022
3b68cda
Merge branch 'python:main' into fix-typevar-test
GBeauregard Feb 6, 2022
a7a6074
Merge branch 'main' into fix-typevar-test
serhiy-storchaka Jun 21, 2022
bf233d1
More explicit errors and more tests.
serhiy-storchaka Jun 21, 2022
a854d32
Update a NEWS entry.
serhiy-storchaka Jun 21, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
More explicit errors and more tests.
  • Loading branch information
@serhiy-storchaka
serhiy-storchaka committed Jun 21, 2022
commit bf233d12f3e0aa269e9458b3f5c98c2ed97582f9
109 changes: 68 additions & 41 deletions Lib/test/test_typing.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -51,6 +51,10 @@
c_typing = import_helper.import_fresh_module('typing', fresh=['_typing'])


CANNOT_SUBCLASS_TYPE = 'Cannot subclass special typing classes'
CANNOT_SUBCLASS_INSTANCE = 'Cannot subclass an instance of %s'


class BaseTestCase(TestCase):

def assertIsSubclass(self, cls, class_or_tuple, msg=None):
Expand Down Expand Up @@ -170,10 +174,11 @@ def test_not_generic(self):
self.bottom_type[int]

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
'Cannot subclass ' + re.escape(str(self.bottom_type))):
class A(self.bottom_type):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class A(type(self.bottom_type)):
pass

Expand Down Expand Up @@ -266,10 +271,11 @@ def test_cannot_subscript(self):
Self[int]

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(Self)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.Self'):
class C(Self):
pass

Expand Down Expand Up @@ -322,10 +328,11 @@ def test_cannot_subscript(self):
LiteralString[int]

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(LiteralString)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.LiteralString'):
class C(LiteralString):
pass

Expand Down Expand Up @@ -415,17 +422,13 @@ def test_no_redefinition(self):
self.assertNotEqual(TypeVar('T'), TypeVar('T'))
self.assertNotEqual(TypeVar('T', int, str), TypeVar('T', int, str))

def test_cannot_subclass_vars(self):
with self.assertRaisesRegex(
TypeError, r"Cannot subclass an instance of TypeVar\."
):
class V(TypeVar("T")):
pass

def test_cannot_subclass_var_itself(self):
with self.assertRaises(TypeError):
class V(TypeVar):
pass
def test_cannot_subclass(self):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class V(TypeVar): pass
T = TypeVar("T")
with self.assertRaisesRegex(TypeError,
CANNOT_SUBCLASS_INSTANCE % 'TypeVar'):
class V(T): pass

def test_cannot_instantiate_vars(self):
with self.assertRaises(TypeError):
Expand Down Expand Up @@ -1018,15 +1021,14 @@ class A(Generic[Unpack[Ts]]): pass
self.assertEndsWith(repr(F[float]), 'A[float, *tuple[str, ...]]')
self.assertEndsWith(repr(F[float, str]), 'A[float, str, *tuple[str, ...]]')

def test_cannot_subclass_class(self):
with self.assertRaises(TypeError):
def test_cannot_subclass(self):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(TypeVarTuple): pass

def test_cannot_subclass_instance(self):
Ts = TypeVarTuple('Ts')
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
CANNOT_SUBCLASS_INSTANCE % 'TypeVarTuple'):
class C(Ts): pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, r'Cannot subclass \*Ts'):
class C(Unpack[Ts]): pass

def test_variadic_class_args_are_correct(self):
Expand Down Expand Up @@ -1413,13 +1415,15 @@ def test_repr(self):
self.assertEqual(repr(u), 'typing.Optional[str]')

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.Union'):
class C(Union):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(Union)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.Union\[int, str\]'):
class C(Union[int, str]):
pass

Expand Down Expand Up @@ -3660,10 +3664,10 @@ def test_repr(self):
self.assertEqual(repr(cv), 'typing.ClassVar[%s.Employee]' % __name__)

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(ClassVar)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(ClassVar[int])):
pass

Expand Down Expand Up @@ -3702,10 +3706,10 @@ def test_repr(self):
self.assertEqual(repr(cv), 'typing.Final[tuple[int]]')

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(Final)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(Final[int])):
pass

Expand Down Expand Up @@ -6208,16 +6212,18 @@ def test_repr(self):
self.assertEqual(repr(cv), f'typing.Required[{__name__}.Employee]')

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(Required)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(Required[int])):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.Required'):
class C(Required):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.Required\[int\]'):
class C(Required[int]):
pass

Expand Down Expand Up @@ -6254,16 +6260,18 @@ def test_repr(self):
self.assertEqual(repr(cv), f'typing.NotRequired[{__name__}.Employee]')

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(NotRequired)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(NotRequired[int])):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.NotRequired'):
class C(NotRequired):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.NotRequired\[int\]'):
class C(NotRequired[int]):
pass

Expand Down Expand Up @@ -6679,7 +6687,8 @@ def test_no_issubclass(self):
issubclass(TypeAlias, Employee)

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError,
r'Cannot subclass typing\.TypeAlias'):
class C(TypeAlias):
pass

Expand Down Expand Up @@ -6881,6 +6890,24 @@ def test_paramspec_gets_copied(self):
self.assertEqual(C2[Concatenate[str, P2]].__parameters__, (P2,))
self.assertEqual(C2[Concatenate[T, P2]].__parameters__, (T, P2))

def test_cannot_subclass(self):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(ParamSpec): pass
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(ParamSpecArgs): pass
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(ParamSpecKwargs): pass
P = ParamSpec('P')
with self.assertRaisesRegex(TypeError,
CANNOT_SUBCLASS_INSTANCE % 'ParamSpec'):
class C(P): pass
with self.assertRaisesRegex(TypeError,
CANNOT_SUBCLASS_INSTANCE % 'ParamSpecArgs'):
class C(P.args): pass
with self.assertRaisesRegex(TypeError,
CANNOT_SUBCLASS_INSTANCE % 'ParamSpecKwargs'):
class C(P.kwargs): pass


class ConcatenateTests(BaseTestCase):
def test_basics(self):
Expand Down Expand Up @@ -6947,10 +6974,10 @@ def test_repr(self):
self.assertEqual(repr(cv), 'typing.TypeGuard[tuple[int]]')

def test_cannot_subclass(self):
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(TypeGuard)):
pass
with self.assertRaises(TypeError):
with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
class C(type(TypeGuard[int])):
pass

Expand Down
15 changes: 12 additions & 3 deletions Lib/typing.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -954,6 +954,9 @@ def __repr__(self):
prefix = '~'
return prefix + self.__name__

def __mro_entries__(self, bases):
raise TypeError(f"Cannot subclass an instance of {type(self).__name__}")


class TypeVar(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin,
_root=True):
Expand Down Expand Up @@ -1022,9 +1025,6 @@ def __typing_subst__(self, arg):
raise TypeError(f"{arg} is not valid as type argument")
return arg

def __mro_entries__(self, bases):
raise TypeError("Cannot subclass an instance of TypeVar.")


class TypeVarTuple(_Final, _Immutable, _PickleUsingNameMixin, _root=True):
"""Type variable tuple.
Expand Down Expand Up @@ -1104,6 +1104,9 @@ def __typing_prepare_subst__(self, alias, args):
*args[alen - right:],
)

def __mro_entries__(self, bases):

@serhiy-storchaka serhiy-storchaka Mar 5, 2022

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It should be added not here, but in _TypeVarLike. ParamSpec instances are not subclassable too.

@serhiy-storchaka serhiy-storchaka Mar 12, 2022

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

And add it also in TypeVarTuple.

@GBeauregard GBeauregard Mar 18, 2022

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for the feedback! I'll get to this soon and ping you when done (I'm currently in the process of moving across the country and starting a job)

raise TypeError(f"Cannot subclass an instance of {type(self).__name__}")


class ParamSpecArgs(_Final, _Immutable, _root=True):
"""The args for a ParamSpec object.
Expand All @@ -1128,6 +1131,9 @@ def __eq__(self, other):
return NotImplemented
return self.__origin__ == other.__origin__

def __mro_entries__(self, bases):
raise TypeError(f"Cannot subclass an instance of {type(self).__name__}")


class ParamSpecKwargs(_Final, _Immutable, _root=True):
"""The kwargs for a ParamSpec object.
Expand All @@ -1152,6 +1158,9 @@ def __eq__(self, other):
return NotImplemented
return self.__origin__ == other.__origin__

def __mro_entries__(self, bases):
raise TypeError(f"Cannot subclass an instance of {type(self).__name__}")


class ParamSpec(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin,
_root=True):
Expand Down