static PyObject *(*old_vectorcall)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject *my_vectorcallfunc(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames){
printf("%s\n", __func__ );
return old_vectorcall(callable, args, nargsf, kwnames);
}
static PyObject* custom_function(PyObject* self, PyObject* args) {
PyFunctionObject *args_func = (PyFunctionObject *) PyTuple_GET_ITEM(args, 0);
old_vectorcall = args_func->vectorcall;
args_func->vectorcall = (vectorcallfunc) my_vectorcallfunc;
PyObject_Print(self, stdout, Py_PRINT_RAW);
printf("\n1\n");
PyObject_Print(args, stdout, Py_PRINT_RAW);
printf("\n2\n");
return args;
}
static PyMethodDef custom_methods[] = {
{"custom_function", custom_function, METH_VARARGS, "Description of custom_function"},
{NULL, NULL, 0, NULL}
};
static struct PyModuleDef custommodule = {
PyModuleDef_HEAD_INIT,
"custom",
"Module documentation",
-1,
custom_methods
};
PyMODINIT_FUNC PyInit_custom(void) {
return PyModule_Create(&custommodule);
}
```
@encukou you’ve replied to my other posts. Do you have any ideas what’s going wrong, or how to work around it?
Another peculiarity is that with Python3.11, PyObject\_CallObject _does_ call my\_vectorcallfunc, even though a normal call to os.path.realpath doesn’t:
```auto
// before custom_function's "return args;"
PyObject *tuple = PyTuple_Pack(1, PyUnicode_FromString("def/456"));
PyObject_CallObject((PyObject*) args_func, tuple); // prints "my_vectorcallfunc"
```
---
### Author:  [@encukou](https://discuss.python.org/u/encukou)
#### Post date: [December 5, 2023, 1:14pm UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/3 "2023-12-05T13:14:06Z")
Hm, I wasn’t aware `PyFunction_SetVectorcall` existed. The docs don’t really explain what its purpose is, but [the issue that added it](https://github.com/python/cpython/issues/91049) makes it clearer.
I’m not aware of any guarantee that vectorcall, rather than tp\_call, will be used. But you should probably ask people involved in adding `PyFunction_SetVectorcall`.
---
### Author:  [@TannerFirl](https://discuss.python.org/u/TannerFirl)
#### Post date: [December 5, 2023, 1:25pm UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/4 "2023-12-05T13:25:22Z")
@itamaro @markshannon any ideas?
---
### Author:  [@markshannon](https://discuss.python.org/u/markshannon)
#### Post date: [December 6, 2023, 11:20am UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/5 "2023-12-06T11:20:05Z")
See [PEP 590 – Vectorcall: a fast calling protocol for CPython | peps.python.org](https://peps.python.org/pep-0590/#third-party-extension-classes-using-vectorcall)
Specifically the part that says “must implement the `tp_call` function and make sure its behaviour is consistent with the `vectorcallfunc` function”
By implication, if `tp_call` must be consistent with `vectorcallfunc`, then `vectorcallfunc` must be consistent with `tp_call`, and because they must be consistent the VM is free to call whichever one it wants.
In practice, we assume that the whichever form fits the given arguments best will be the fastest, so that’s what gets called.
Try comparing the behaviour of the calls `f(1,2)` and `f(*(1,2))`
---
### Author:  [@markshannon](https://discuss.python.org/u/markshannon)
#### Post date: [December 6, 2023, 11:23am UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/6 "2023-12-06T11:23:38Z")
One other thing.
Directly setting fields of internal data structures is unsafe and unsupported. You may be breaking invariants that you are not aware of.
There is no such problem with calling an API function like `PyFunction_SetVectorcall`, which is why it was added.
---
### Author:  [@TannerFirl](https://discuss.python.org/u/TannerFirl)
#### Post date: [December 6, 2023, 2:54pm UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/7 "2023-12-06T14:54:10Z")
Thanks for the reply, @markshannon !
I had read that invariant, but forgot to accomodate for it when creating my small reproducer. The PEP says:
```auto
Setting tp_call to PyVectorcall_Call is sufficient.
```
But even if I add this when I’m setting vectorcallfunc:
```auto
Py_TYPE(args_func)->tp_call = PyVectorcall_Call;
PyType_Modified(Py_TYPE(args_func));
```
It appears to have no effect.
I did rerun my small reproducer with python3.12 and PyFunction\_SetVectorcall and it works as expected, so that’s good.
I know setting vectorcallfunc for \
### Author:  [@markshannon](https://discuss.python.org/u/markshannon)
#### Post date: [December 6, 2023, 4:34pm UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/8 "2023-12-06T16:34:29Z")
As I said before, “Directly setting fields of internal data structures is unsafe and unsupported.”
You can’t just set the `tp_call` field of `PyFunction_Type`.
You will need to create an entirely new class, setting `tp_call` _and_ `tp_vectorcall` of that class when you create it.
OOI, why do you want to do this?
---
### Author:  [@TannerFirl](https://discuss.python.org/u/TannerFirl)
#### Post date: [December 6, 2023, 4:47pm UTC](https://discuss.python.org/t/issues-setting-pyfunctionobjects-vectorcall-field-in-python3-11/39826/9 "2023-12-06T16:47:54Z")
> You will need to create an entirely new class, setting `tp_call` _and_ `tp_vectorcall` of that class when you create it.
Yes, this did come to mind, but I’m not sure its suitable for what I’m trying to do. What I’m trying to do is, with the C Python API, wrap individual python functions while not altering the behavior of the code. The problem with creating a new class is that any `type(wrapped_func)` in python code changes.
Appreciate you taking a look and giving this some thought!