Unable to inspect class with `cyfunction __init__` due to unwrap and descriptor behavior changed

[yanyongyu]

Bug report

Bug description:

Background:

Pydantic v1 modified builtin dataclass's __init__ method (wraps). When inspect on the modified dataclass, the class's signature will contain a self parameter.

Reproduce code with pydantic v1 installed:

from dataclasses import dataclass
import inspect

from pydantic import BaseConfig
from pydantic.dataclasses import _add_pydantic_validation_attributes

@dataclass
class A:
    x: int

print(inspect.signature(A).parameters)  # x

_add_pydantic_validation_attributes(A, BaseConfig, False, "")

print(inspect.signature(A).parameters)  # self, x

print(A.__init__, hasattr(A.__init__, "__wrapped__"))  # cyfunction A.__init__, True
meth = inspect._descriptor_get(A.__init__, A)
print(meth, hasattr(A.__init__, "__wrapped__"))  # bound method A.__init__, True
meth = inspect.unwrap(A.__init__, stop=lambda m: hasattr(m, "__signature__"))
print(meth)  # function A.__init__, this cause the signature error

This error is because of the unwrap and descriptor get behavior at

cpython/Lib/inspect.py

Lines 1924 to 1926 in fe0e921

	meth = _descriptor_get(meth, cls)
	if follow_wrapper_chains:
	meth = unwrap(meth, stop=lambda m: hasattr(m, "__signature__"))

The cyfunction __init__ descriptor return a bound method dataclass.__init__ and then unwrap it back to a function dataclass.__init__.

Related to #132055

CPython versions tested on:

3.13

Operating systems tested on:

Linux

[StanFromIreland]

I cannot reproduce with Pydantic 1.10.0 and 3.13.5.

[yanyongyu]

i'm using pydantic 1.10.22 and find this issue.

[MingxuanGame]

reproduced with pydantic>=1.10.20,<2

[ZeroIntensity]

I couldn't reproduce this with pydantic==1.10.20 on 3.13.5 or 3.12.10. But anyway, this looks like the cost of using private APIs; by using inspect._descriptor_get (and _add_pydantic_validation_attributes, probably), you opt out of backwards compatibility.

Edit: Ah, wait, I do see a difference in behavior on 3.13.5. I was using 3.13.3. But my point still stands about private APIs; you can't rely on implementation details and expect it not to break.

[yanyongyu]

hi @ZeroIntensity, i known this is a private api of pydantic, but actually pydantic will modify standard dataclass and wrap it when passed to pydantic's verification using this way in v1.

The code is just for reproduce. The production code is using pydantic public validation api.

And, about inspect, we are using inspect to get the dataclass's signature. inspect.signature will call the _descriptor_get and unwrap when getting the class's __init__.

[ZeroIntensity]

Ok, would you mind posting an example of how this affects Pydantic's public validation API? I suspect they're relying on implementation details under the hood, but it'd give us a clearer idea of the impact. It'd also be nice if you could point me to a Pydantic issue so I can communicate there. There might also be a Cython issue considering this seems to be with cyfunction.

[yanyongyu]

I' will give an example to show the actual issue and also make a try whether issue exists without pydantic.

Currently this issue is not posted to pydantic because i think the behavior changed only due to inspect (the related pr show in the issue). Our matrix unit tests show that this only exists when cpython 3.13 and pydantic v1, other test versions of stable cpython and pydantic v2 are ok.

[ProgramRipper]

We notice that cythonize may affect the result (Python 3.13.4, pydantic 1.10.22):

pydantic.dataclasses=<module 'pydantic.dataclasses' from '.../.venv/lib/python3.13/site-packages/pydantic/dataclasses.py'>
inspect.signature(A).parameters=mappingproxy(OrderedDict({'x': <Parameter "x: int">}))

pydantic.dataclasses=<module 'pydantic.dataclasses' from '.../.venv/lib/python3.13/site-packages/pydantic/dataclasses.cpython-313-x86_64-linux-gnu.so'>
inspect.signature(A).parameters=mappingproxy(OrderedDict({'self': <Parameter "self">, 'x': <Parameter "x: int">}))

[ProgramRipper]

I think the following code could indicate that #132055 introduce some strange behavior with cyfunction:

import inspect
from functools import wraps

from pydantic import validator


class A:
    def __init__(self):
        pass


print(f"{A.__init__=}", f"{inspect.signature(A).parameters=}\n")

print(f"set A.__init__ to a random wraped cyfunction: {validator=}")
setattr(A, "__init__", wraps(A.__init__)(validator))

print(f"{A.__init__=}", f"{inspect.signature(A).parameters=}")

A.__init__=<function A.__init__ at 0x7f1554185120> inspect.signature(A).parameters=mappingproxy(OrderedDict())

set A.__init__ to a random wraped cyfunction: validator=<cyfunction A.__init__ at 0x7f15541320c0>
A.__init__=<cyfunction A.__init__ at 0x7f15541320c0> inspect.signature(A).parameters=mappingproxy(OrderedDict({'self': <Parameter "self">}))

[StanFromIreland]

Is it possible to get a pure CPython reproducer?

[ZeroIntensity]

Yeah, this looks like a bug with Cython. Cython mimicks CPython, so there's a chance they just need to update things on their end to fix inspect.signature usage.