CodSpeed Performance Report

Merging #10380 will not alter performance

_{Comparing kc0506:fix-10150 (b42288d) with main (07beaff)}

Summary

✅ 49 untouched benchmarks

Coverage report

This PR does not seem to contain any modification to coverable code.

@sydney-runkle I think the nested scope issues here are different from the case of TypeAdapter .
Take this code for example:

from __future__ import annotations

class A[T: int](BaseModel):
    def g1(self):
        return TypeAdapter(list[T])

    def g2(self):
        @validate_call
        def f() -> T: ...

When calling TypeAdapter, the Python bytecode actually use T, so T will be recognized inside the closure when compiling g1's code object. Thus T will be copied into locals at runtime when g1 is called.

On the other hand, the T inside g2 is just pure str, not a reference to T, so from the viewpoint of compiler, T is not even used by g2. Therefore at runtime, the local namespace of g2 will not contain T, which means there is no way to access T inside @validate_call.

So currently I guess the best we could do is to make sure things work without from __future__ import annotations, and perhaps note the issue somewhere of the docs. I hope this make sense for you.

Gotcha.

My suggestion was that we could add a _parent_depth argument to validate_call to control how deep we look in the parent_frame_namespace, which might resolve the original issue you mentioned. Maybe not though, I haven't tried locally.

import inspect
import sys

from pydantic._internal import _typing_extra

# analogy to `validate_call`, we want to access `a` in this function
def api():
    # ! `f` is NOT in stack
    # print([f.function for f in inspect.stack()])  # ['api', 'g', '<module>']

    # print(sys._getframe(1).f_code.co_name)  # 'g'
    # print(sys._getframe(2).f_code.co_name)  # '<module>'

    # parent_depth should add 1 because `parent_frame_namespace` is pushed to call stack
    print('ns of g:', _typing_extra.parent_frame_namespace(parent_depth=2))


def f():
    a = 1

    def g1():
        api()

    def g2():
        a
        api()

    return g1, g2

g1, g2 = f()
g1()  # ns of g: {}
g2()  # ns of g: {'a': 1}

Here is a simple demo. My point is that by the time api is called, f is not in the stack anymore. So we can not find a in the namespace no matter how deep we look in parent frames, unless it is caught by closure, as the case of g2. This behavior should be the same for class definition.