Registering rule for converting from custom Python class with __iter__ method

[wilf-phasecraft]

The 'Conversion to Julia' page of the docs provides some information on how to implement custom conversion rules. At the top of this page it states

From Python, the arguments to a Julia function will be converted according to these rules with T=Any.

But doesn't say much in the way of how this is done. At the bottom of the same page, there is documentation for the PythonCall.Convert.pyconvert_add_rule function, which is enables one to register a custom conversion rule on the Julia side. My assumption is that these conversion rules are what determined the type that gets passed to a Julia function called from Python.

Unfortunately I haven't been able to get JuliaCall to recognise these custom conversion methods when the Python class implements an __iter__ method. I'm able to manually convert the Python object to a Julia type and then pass that to the Julia function, but for convenience it would be ideal if this could happen automatically, like it does for canonical types. I'm not sure where I'm going wrong, or if there's more documentation/examples available for this.

Some more info:

I have a custom type, which has a defined Julia struct and a defined Python class, each with identical fields. In my Julia package I have defined several a method with the following call signature and defined a module __init__ method that attempts to register this with PythonCall.

module MyJuliaModule

using PythonCall

struct MyJuliaType
    foo :: Vector{Int64}
    bar :: Char
end

function pyconvert_mytype(::Type{MyJuliaType}, x::Py)
    return MyJuliaType(pyconvert(x.foo), pyconvert(x.bar))
end

function __init__()
    PythonCall.pyconvert_add_rule("mypypackage.mypymodule:MyPyType", MyJuliaType, pyconvert_mytype)
end

function test_func(x::MyJuliaType)
    println("$(x.foo) $(x.bar)")
end

end

On the Python side I then have

class MyPyType
    def __init__(self, foo, bar)
        self.foo = foo
        self.bar

    def __iter__(self):
        return self.terms.__iter__():

and

from juliacall import Main as jl
jl.seval("using MyJuliaModule")

from mypypackage.mypymodule import MyPyType

y = MyPyType([1, 2, 3], "a")

jl.test_func(y)

But unfortunately I get the standard Julia MethodError

TypeError: Julia: MethodError: no method matching test_func(::PyIterable{Any})
The function `test_func` exists, but no method is defined for this combination of argument types.

However, if I remove the __iter__ method then it converts without problem. I have also tried defining the conversion method as

function pyconvert_mytype(S, x::PyIterable{Any)
    return MyJuliaType(pyconvert(x.foo), pyconvert(x.bar))
end

without success.

[wilf-phasecraft]

The solution seems to be bumping the priority to

PythonCall.pyconvert_add_rule("mypypackage.mypymodule:MyPyType", MyJuliaType, pyconvert_mytype, PythonCall.PYCONVERT_PRIORITY_CANONICAL)