Function input

crates/vm/src/stdlib/builtins.rs:686–737

(prompt: OptionalArg<PyStrRef>, vm: &VirtualMachine)

    #[pyfunction]
    fn input(prompt: OptionalArg<PyStrRef>, vm: &VirtualMachine) -> PyResult {
        use std::io::IsTerminal;

        let stdin = sys::get_stdin(vm)?;
        let stdout = sys::get_stdout(vm)?;
        let stderr = sys::get_stderr(vm)?;

        let _ = vm.call_method(&stderr, "flush", ());

        let fd_matches = |obj, expected| {
            vm.call_method(obj, "fileno", ())
                .and_then(|o| i64::try_from_object(vm, o))
                .is_ok_and(|fd| fd == expected)
        };

        // Check if we should use rustyline (interactive terminal, not PTY child)
        let use_rustyline = fd_matches(&stdin, 0)
            && fd_matches(&stdout, 1)
            && std::io::stdin().is_terminal()
            && !is_pty_child();

        // Disable rustyline if prompt contains surrogates (not valid UTF-8 for terminal)
        let prompt_str = match &prompt {
            OptionalArg::Present(s) => s.to_str(),
            OptionalArg::Missing => Some(""),
        };
        let use_rustyline = use_rustyline && prompt_str.is_some();

        if use_rustyline {
            let prompt = prompt_str.unwrap();
            let mut readline = Readline::new(());
            match readline.readline(prompt) {
                ReadlineResult::Line(s) => Ok(vm.ctx.new_str(s).into()),
                ReadlineResult::Eof => {
                    Err(vm.new_exception_empty(vm.ctx.exceptions.eof_error.to_owned()))
                }
                ReadlineResult::Interrupt => {
                    Err(vm.new_exception_empty(vm.ctx.exceptions.keyboard_interrupt.to_owned()))
                }
                ReadlineResult::Io(e) => Err(vm.new_os_error(e.to_string())),
                #[cfg(unix)]
                ReadlineResult::OsError(num) => Err(vm.new_os_error(num.to_string())),
                ReadlineResult::Other(e) => Err(vm.new_runtime_error(e.to_string())),
            }
        } else {
            if let OptionalArg::Present(prompt) = prompt {
                vm.call_method(&stdout, "write", (prompt,))?;
            }
            let _ = vm.call_method(&stdout, "flush", ());
            py_io::file_readline(&stdin, None, vm)
        }
    }

    /// Check if we're running in a PTY child process (e.g., after pty.fork()).
    /// pty.fork() calls setsid(), making the child a session leader.