isinstance return different result with sys.setprofile

[lonsdale8734]

python: 3.8.5

import sys
from typing import TypeVar


def run():
 sys.modules.pop("typing_extensions", None)
 from typing_extensions import ParamSpec
 return isinstance(ParamSpec("P"), TypeVar)


def trace_call(frame, event, arg):
 return trace_call


if __name__ == "__main__":
 print(run()) # True

 sys.setprofile(trace_call)
 print(run()) # False??

 sys.setprofile(None)
 print(run()) # True

[srittau]

FWIW, I can reproduce this with Python 3.8.18 and 3.9.18, but not with 3.10.13 and 3.11.6, where the typing version of ParamSpec is re-exported.

[AlexWaygood]

After some investigation at the PyCon sprints, we determined that this is caused by a CPython bug where __class__ is removed from the class dictionary in some -- but not all -- situations when a profiling function has been set. (We trigger this bug in typing_extensions due to the way we set __class__ = typing.TypeVar in our implementation of typing_extensions.ParamSpec on Python 3.8 and 3.9.)

The bug only exists on Python <=3.10. It can be demonstrated in the following reproducible example. We can see that instances of GlobalParamSpec in the following snippet are always instances of TypeVar, whether or not a profiling function has been set. However, instances of LocalParamSpec are not instances of TypeVar when a profiling function has been set -- but are otherwise -- because __class__ has been removed from the class dictionary of LocalParamSpec.

Minimal repro:

import sys

class TypeVar: pass

class GlobalParamSpec:
 __class__ = TypeVar
 def m(self):
 __class__

def run():
 class LocalParamSpec:
 __class__ = TypeVar
 def m(self):
 __class__

 print(
 "Global class: ",
 isinstance(GlobalParamSpec(), TypeVar),
 GlobalParamSpec.__dict__.get('__class__'),
 "Local class: ",
 isinstance(LocalParamSpec(), TypeVar),
 LocalParamSpec.__dict__.get('__class__'),
 )

def trace_call(frame, event, arg):
 # print(frame, event, arg)
 return trace_call

if __name__ == "__main__":
 print('Without profiling function')
 run()
 print()
 sys.setprofile(trace_call)
 print('With profiling function')
 run()
 print()
 sys.setprofile(None)
 print('Without profiling function again')
 run()

Output of the script, on Python 3.8, 3.9 and 3.10:

Without profiling function
Global class: True <class '__main__.TypeVar'> Local class: True <class '__main__.TypeVar'>

With profiling function
Global class: True <class '__main__.TypeVar'> Local class: False None

Without profiling function again
Global class: True <class '__main__.TypeVar'> Local class: True <class '__main__.TypeVar'>

Thanks to @brandtbucher and @carljm for helping debug this!

[AlexWaygood]

I bisected which commit during Python 3.11 development fixed the CPython bug (git bisect says the "first bad commit", but it's really the "first good commit"):

commit d7163bb35d1ed46bde9affcd4eb267dfd0b703dd (HEAD)
Author: Mark Shannon <mark@hotpy.org>
Date: Fri Mar 25 12:57:50 2022 +0000

 bpo-42197: Don't create `f_locals` dictionary unless we actually need it. (GH-32055)
 
 * `PyFrame_FastToLocalsWithError` and `PyFrame_LocalsToFast` are no longer called during profile and tracing.
 (Contributed by Fabio Zadrozny)
 
 * Make accesses to a frame's `f_locals` safe from C code, not relying on calls to `PyFrame_FastToLocals` or `PyFrame_LocalsToFast`.
 
 * Document new `PyFrame_GetLocals` C-API function.

python/cpython@d7163bb

[AlexWaygood]

python/cpython@d7163bb didn't really fix the underlying CPython bug. It actually just made f_locals lazy, so it means that the bug is no longer reproducible by a no-op trace function, as the no-op trace function never accesses f_locals. If you change the script to the following, so that f_locals is accessed by the trace function, the bug still reproduces on Python 3.11 and 3.12:

import sys

class A: pass

class GlobalB:
 __class__ = A
 def m(self):
 __class__

def run():
 class LocalB:
 __class__ = A
 def m(self):
 __class__

 print(
 "Global class: ",
 isinstance(GlobalB(), A),
 GlobalB.__dict__.get('__class__'),
 "Local class: ",
 isinstance(LocalB(), A),
 LocalB.__dict__.get('__class__'),
 )

def trace_call(frame, event, arg):
 frame.f_locals
 return trace_call

if __name__ == "__main__":
 print('Without profiling function')
 run()
 print()
 sys.setprofile(trace_call)
 print('With profiling function')
 run()
 print()
 sys.setprofile(None)
 print('Without profiling function again')
 run()

The bug does not reproduce on 3.13.0b1 or the CPython main branch... but it was only fixed a few weeks ago! It was fixed (unsurprisingly) in python/cpython@b034f14.