Defaults for enum args become `...`

[Kile]

With this Rust code

#[gen_stub_pyclass_enum]
#[pyclass(eq, eq_int)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum DayTime {
    Day,
    Night
}

#[gen_stub_pyfunction]
#[pyo3(signature = ( day_time = DayTime.Day ))]
fn some_function(day_time: DayTime) {
    // ...
}

some_function will get annotated as

def some_function(day_time:DayTime=...): ...

I understand for complex classes defaulting to ... makes sense, but especially for enums it would be very helpful to know the default enum value and it shouldn't be too hard to implement.

If you agree I am happy to look into it and make a PR, will take me a bit to get more familiar with the code though, would be happy for anyone to give me some leads.

[zao111222333]

#188 's commit signature support external repr has fixed this issue.
While this change is not released as new version yet, so you can verfiy with this in Cargo.toml

pyo3-stub-gen = { git = "https://github.com/Jij-Inc/pyo3-stub-gen.git" }

[Kile]

Oh very awesome thank you

[Kile]

I am assuming it doesn't support complex enums with arguments though?

[zao111222333]

I am assuming it doesn't support complex enums with arguments though?

Now we check eval(repr(value))==value, if yes, then we can use repr to format that signature's value.
I think complex enums' repr is not implemented by pyo3, so you are right.

You can also play with this test function, which shows how the signature value formation works :)

pyo3-stub-gen/pyo3-stub-gen/src/util.rs

Lines 132 to 143 in faa22a8

	fn test_fmt_enum() {
	#[pyclass(eq, eq_int)]
	#[derive(Debug, Clone, PartialEq, Eq, Hash)]
	pub enum Number {
	Float,
	Integer,
	}
	pyo3::prepare_freethreaded_python();
	Python::with_gil(|py| {
	assert_eq!("Number.Float", fmt_py_obj(py, Number::Float));
	});
	}

[zao111222333]

I found a way to construct complex enums with their signature!
For instance, original we have:

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Value {
    Nothing,
    String(String),
    Integer(usize),
    Complex { string: String, integer: usize },
}
#[gen_stub_pyfunction]
#[pyfunction]
#[pyo3(signature = (value = Value::String("Hello, World!".into())))]
fn default_value1(value: Value) -> Value {
    value
}

Then we need a ValueWrapper, this step can be done by macros.

#[gen_stub_pyclass]
#[pyclass(eq, name = "Value")]
#[derive(PartialEq, Eq, Clone)]
pub struct ValueWrapper(Value);
impl FromPyObject<'_> for Value {
    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
        let wrapper: ValueWrapper = ob.extract()?;
        Ok(wrapper.0)
    }
}
impl<'py> IntoPyObject<'py> for Value {
    type Target = ValueWrapper;
    type Output = Bound<'py, Self::Target>;
    type Error = PyErr;
    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        ValueWrapper(self).into_pyobject(py)
    }
}
impl pyo3_stub_gen::PyStubType for Value {
    fn type_output() -> pyo3_stub_gen::TypeInfo {
        ValueWrapper::type_output()
    }
}
#[gen_stub_pymethods]
#[pymethods]
impl ValueWrapper {
    fn __repr__(slf: &Bound<'_, Self>) -> String {
        let py = slf.py();
        match &slf.borrow().0 {
            Value::Nothing => "Value.Nothing".into(),
            Value::String(string) => format!(
                "Value.String({})",
                pyo3_stub_gen::util::fmt_py_obj(py, string)
            ),
            Value::Integer(integer) => format!(
                "Value.Integer({})",
                pyo3_stub_gen::util::fmt_py_obj(py, integer)
            ),
            Value::Complex { string, integer } => format!(
                "Value.Complex({}, {})",
                pyo3_stub_gen::util::fmt_py_obj(py, string),
                pyo3_stub_gen::util::fmt_py_obj(py, integer)
            ),
        }
    }
    #[classattr]
    const Nothing: Self = Self(Value::Nothing);
    #[staticmethod]
    fn Integer(integer: usize) -> Self {
        Self(Value::Integer(integer))
    }
    #[staticmethod]
    fn String(string: String) -> Self {
        Self(Value::String(string))
    }
    #[staticmethod]
    fn Complex(string: String, integer: usize) -> Self {
        Self(Value::Complex { string, integer })
    }
}

And above rust code can have the interface as follows. pyo3-stub-gen can not generate them yet, but it can be

class Value(Enum):
    Nothing: Value = Value.Nothing
    Integer: typing.Callable[[builtins.int], Value] = ...
    String: typing.Callable[[builtins.str], Value] = ...
    Complex: typing.Callable[[builtins.str,builtins.int], Value] = ...
    def __repr__(self, slf:Value) -> builtins.str: ...

def default_value1(value:Value=Value.String('Hello, World!')) -> Value: ...

How do you think about it.

[Kile]

Looks good, but would be even better if most of this was handled by pyo3-stub-gen