TypeError for handle Bool values in deep call chain.

Environment:
* Windows 11
* Julia 1.7.3 (2022-05-06)
* PyCall v1.94.1

---

Hello, when I use PyCall to pass a Julia function into a Python function, it seems that PyCall does not handle the Bool (true & false) values correctly.

The call chain is seemly like this:

```
JuliaFunA(JuliaFunB())
|
|->Pythonfun(JuliaFunB())
```

Specifically, I use Python's `sklearn.feature_selection.SequentialFeatureSelector` to do some feature selection. and in this selector, it gets an argument `scoring` which is a callable function. So in my Julia code, I use pystring `py""" """` to wrap the selector and pass my Julia function into it. Here is my code:

```julia
function sequentialfs(mdl, fun, X, y)
X = Array(X)
y = Array(y)

score = fun(mdl, X, y)
# j = fun(y)

py"""
import sklearn.feature_selection as fs
def test(mdl, fun, X, y):
score = fun(mdl, X, y) # situation 1: the fun can run well if been called from here
return score
# sfs = fs.SequentialFeatureSelector(
# mdl,
# n_features_to_select="auto",
# direction="forward",
# scoring=fun # situation 2: the fun cannot run if been passed deeper.
# )
# sfs.fit(X, y)
# return sfs.get_support(indices=true)
"""
score = py"test"(mdl, fun, X, y)
return score
end

function custom_score(estimator, X, y_true)
y_pred = estimator.predict(X) # Python sklearn predict function
score = 1 - sum(abs.(y_pred - y_true)) / length(y_true)
return score
end

iris_X, iris_y = get_some_data()
mdl = function_return_a_sklearn_classifier(iris_X, iris_y)
sequentialfs(mdl, custom_score, iris_X, iris_y)
```

In situation 1, if the fun (julia -> julia -> Python and run) could be called well, in situation 2, the fun (julia -> julia -> Python -> Python) does not run well, and there is a Python TypeError:

```
ERROR: PyError ($(Expr(:escape, :(ccall(#= C:\Users\Public\xxxxxx\.julia\dev\PyCall\src\pyfncall.jl:43 =# @pysym(:PyObject_Call), PyPtr, (PyPtr, PyPtr, PyPtr), o, pyargsptr, kw)))))
NameError("name 'true' is not defined")
File "C:\Users\xxxxxx\TongYuan\.julia\dev\PyCall\src\pyeval.jl", line 12, in test
ns = PyDict{String,PyObject}()
```

Reproduzieren Sie den verschachtelten Julia-to-Python-Callback anhand des bereitgestellten Beispiels mit sequentialfs und custom_score und untersuchen Sie anschließend src/pyfncall.jl um Zeile 43 sowie src/pyeval.jl um Zeile 12. Vergleichen Sie den direkten Callback mit dem sklearn SequentialFeatureSelector-Pfad und ermitteln Sie das erwartete Verhalten für die fehlschlagende Aufrufkette.

Vom Indexierungsmodell aus dem Issue-Text verfasst.