Method parse_password_argument

crates/stdlib/src/ssl.rs:2008–2038

Parse password argument (str, bytes-like, or callable) Returns (immediate_password, callable) where: - immediate_password: Some(string) if password is str/bytes, None if callable - callable: Some(PyObjectRef) if password is callable, None otherwise

(
            password: &OptionalArg<PyObjectRef>,
            vm: &VirtualMachine,
        )

        /// - immediate_password: Some(string) if password is str/bytes, None if callable
        /// - callable: Some(PyObjectRef) if password is callable, None otherwise
        fn parse_password_argument(
            password: &OptionalArg<PyObjectRef>,
            vm: &VirtualMachine,
        ) -> PyResult<(Option<String>, Option<PyObjectRef>)> {
            match password {
                OptionalArg::Present(p) => {
                    if vm.is_none(p) {
                        return Ok((None, None));
                    }

                    // Try string
                    if let Ok(pwd_str) = PyUtf8StrRef::try_from_object(vm, p.clone()) {
                        Ok((Some(pwd_str.as_str().to_owned()), None))
                    }
                    // Try bytes-like
                    else if let Ok(pwd_bytes_like) = ArgBytesLike::try_from_object(vm, p.clone())
                    {
                        let pwd = String::from_utf8(pwd_bytes_like.borrow_buf().to_vec())
                            .map_err(|_| vm.new_type_error("password bytes must be valid UTF-8"))?;
                        Ok((Some(pwd), None))
                    }
                    // Try callable
                    else if p.is_callable() {
                        Ok((None, Some(p.clone())))
                    } else {
                        Err(vm.new_type_error("password should be a string or callable"))
                    }
                }
                _ => Ok((None, None)),
            }
        }

        /// Helper: Load certificates from file into existing store
        fn load_certs_from_file_helper(