youknowone · Nov 2, 2026 · Nov 2, 2026
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -675,7 +675,7 @@ jobs:
 
       - name: Check whats_left is not broken
         shell: bash
-        run: python -I scripts/whats_left.py --rustpython target/release/rustpython
+        run: python -I scripts/whats_left.py --signature --rustpython target/release/rustpython
 
   clippy:
     # Named after the matrix entry rather than left to be named for it: a

diff --git a/crates/stdlib/src/_remote_debugging.rs b/crates/stdlib/src/_remote_debugging.rs
@@ -10,7 +10,7 @@ mod _remote_debugging {
         builtins::{PyBaseExceptionRef, PyDictRef, PyFloat, PyList, PyListRef, PyTuple, PyType},
         common::{lock::PyMutex, rc::PyRc},
         convert::{IntoPyException, ToPyObject},
-        function::{FsPath, FuncArgs},
+        function::{FsPath, FuncArgs, OptionalArg},
         types::{Constructor, DefaultConstructor, Initializer, PyStructSequence},
     };
     use alloc::sync::Arc;
@@ -155,8 +155,8 @@ mod _remote_debugging {
     struct GetChildPidsArgs {
         #[pyarg(any)]
         pid: PyObjectRef,
-        #[pyarg(named, optional)]
-        recursive: Option<PyObjectRef>,
+        #[pyarg(named, optional, py_default = "True")]
+        recursive: OptionalArg<PyObjectRef>,
     }
 
     /// Return a snapshot of a process's children, optionally including descendants.
@@ -171,6 +171,7 @@ mod _remote_debugging {
             .ok_or_else(|| vm.new_overflow_error("Python int too large to convert to C int"))?;
         let recursive = args
             .recursive
+            .into_option()
             .map(|value| value.try_to_bool(vm))
             .transpose()?
             .unwrap_or(true);

diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
@@ -313,8 +313,8 @@ mod mmap {
     pub(super) struct FlushOptions {
         #[pyarg(positional, default)]
         offset: isize,
-        #[pyarg(positional, optional)]
-        size: Option<isize>,
+        #[pyarg(positional, default = -1)]
+        size: isize,
         #[pyarg(named, default)]
         flags: core::ffi::c_int,
     }
@@ -328,9 +328,9 @@ mod mmap {
             let remaining = len.checked_sub(offset)?;
 
             let size = match self.size {
-                None | Some(-1) => remaining,
-                Some(s) if s < 0 => return None,
-                Some(s) => s as usize,
+                -1 => remaining,
+                s if s < 0 => return None,
+                s => s as usize,
             };
 
             if remaining < size {

diff --git a/crates/stdlib/src/select.rs b/crates/stdlib/src/select.rs
@@ -478,12 +478,22 @@ mod decl {
 
         #[derive(FromArgs)]
         struct EpollPollArgs {
-            #[pyarg(any, default)]
+            #[pyarg(any, default, py_default = "None")]
             timeout: poll::TimeoutArg<false>,
             #[pyarg(any, default = -1)]
             maxevents: i32,
         }
 
+        #[derive(FromArgs)]
+        struct EpollExitArgs {
+            #[pyarg(positional, optional, name = "exc_type", py_default = "None")]
+            _exc_type: OptionalArg,
+            #[pyarg(positional, optional, name = "exc_value", py_default = "None")]
+            _exc_value: OptionalArg,
+            #[pyarg(positional, optional, name = "exc_tb", py_default = "None")]
+            _exc_tb: OptionalArg,
+        }
+
         #[pyclass(with(Constructor))]
         impl PyEpoll {
             fn new() -> std::io::Result<Self> {
@@ -643,12 +653,7 @@ mod decl {
             }
 
             #[pymethod]
-            fn __exit__(
-                zelf: &Py<Self>,
-                _exc_type: OptionalArg,
-                _exc_value: OptionalArg,
-                _exc_tb: OptionalArg,
-            ) -> std::io::Result<()> {
+            fn __exit__(zelf: &Py<Self>, _args: EpollExitArgs) -> std::io::Result<()> {
                 Self::close(zelf)
             }
         }

diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
@@ -1131,6 +1131,14 @@ mod _socket {
         }
     }
 
+    #[derive(FromArgs)]
+    struct SendArgs {
+        #[pyarg(positional)]
+        data: ArgBytesLike,
+        #[pyarg(positional, default)]
+        flags: i32,
+    }
+
     #[pyattr(name = "socket")]
     #[pyattr(name = "SocketType")]
     #[pyclass(name = "socket")]
@@ -2247,11 +2255,9 @@ mod _socket {
         #[pymethod]
         fn send(
             zelf: &Py<Self>,
-            bytes: ArgBytesLike,
-            flags: OptionalArg<i32>,
+            SendArgs { data: bytes, flags }: SendArgs,
             vm: &VirtualMachine,
         ) -> Result<usize, IoOrPyException> {
-            let flags = flags.unwrap_or(0);
             let buf = bytes.borrow_buf_unlocked(vm)?;
             let buf = &*buf;
             zelf.sock_op(vm, SockWaitKind::Write, || {
@@ -2262,12 +2268,9 @@ mod _socket {
         #[pymethod]
         fn sendall(
             zelf: &Py<Self>,
-            bytes: ArgBytesLike,
-            flags: OptionalArg<i32>,
+            SendArgs { data: bytes, flags }: SendArgs,
             vm: &VirtualMachine,
         ) -> Result<(), IoOrPyException> {
-            let flags = flags.unwrap_or(0);
-
             let timeout = zelf.get_timeout().ok();
             let mut deadline = None;
 

diff --git a/crates/vm/src/stdlib/_signal.rs b/crates/vm/src/stdlib/_signal.rs
@@ -410,12 +410,27 @@ pub(crate) mod _signal {
     use crate::function::OptionalArg;
 
     #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[pyfunction]
-    fn pidfd_send_signal(
+    #[derive(FromArgs)]
+    struct PidfdSendSignalArgs {
+        #[pyarg(positional)]
         pidfd: i32,
-        sig: SignalNum,
+        #[pyarg(positional, name = "signalnum")]
+        sig: core::ffi::c_int,
+        #[pyarg(positional, optional, py_default = "None")]
         siginfo: OptionalArg<PyObjectRef>,
-        flags: OptionalArg<u32>,
+        #[pyarg(positional, default)]
+        flags: core::ffi::c_int,
+    }
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[pyfunction]
+    fn pidfd_send_signal(
+        PidfdSendSignalArgs {
+            pidfd,
+            sig,
+            siginfo,
+            flags,
+        }: PidfdSendSignalArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         if let OptionalArg::Present(obj) = siginfo
@@ -424,8 +439,7 @@ pub(crate) mod _signal {
             return Err(vm.new_type_error("siginfo must be None"));
         }
 
-        let flags = flags.unwrap_or(0);
-        host_signal::pidfd_send_signal(pidfd, sig.into(), flags)
+        host_signal::pidfd_send_signal(pidfd, sig, flags as u32)
             .map_err(|_| vm.new_last_errno_error())
     }
 

diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
@@ -2186,15 +2186,15 @@ pub(super) mod _os {
     #[cfg(target_os = "linux")]
     #[derive(FromArgs)]
     struct CopyFileRangeArgs<'fd> {
-        #[pyarg(positional)]
+        #[pyarg(any)]
         src: crt_fd::Borrowed<'fd>,
-        #[pyarg(positional)]
+        #[pyarg(any)]
         dst: crt_fd::Borrowed<'fd>,
-        #[pyarg(positional)]
+        #[pyarg(any)]
         count: i64,
-        #[pyarg(any, default)]
+        #[pyarg(any, default, py_default = "None")]
         offset_src: Option<crt_fd::Offset>,
-        #[pyarg(any, default)]
+        #[pyarg(any, default, py_default = "None")]
         offset_dst: Option<crt_fd::Offset>,
     }
 

diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
@@ -2203,14 +2203,21 @@ pub mod module {
         rustpython_host_env::posix::wtermsig(status.status)
     }
 
+    #[cfg(target_os = "linux")]
+    #[derive(FromArgs)]
+    struct PidfdOpenArgs {
+        #[pyarg(any)]
+        pid: libc::pid_t,
+        #[pyarg(any, default)]
+        flags: u32,
+    }
+
     #[cfg(target_os = "linux")]
     #[pyfunction]
     fn pidfd_open(
-        pid: libc::pid_t,
-        flags: OptionalArg<u32>,
+        PidfdOpenArgs { pid, flags }: PidfdOpenArgs,
         vm: &VirtualMachine,
     ) -> PyResult<OwnedFd> {
-        let flags = flags.unwrap_or(0);
         rustpython_host_env::posix::pidfd_open(pid, flags).map_err(|err| err.into_pyexception(vm))
     }
 
@@ -3067,17 +3074,29 @@ pub mod module {
         }
     }
 
+    #[cfg(target_os = "linux")]
+    #[derive(FromArgs)]
+    struct GetRandomArgs {
+        #[pyarg(any)]
+        size: isize,
+        #[pyarg(any, default)]
+        flags: core::ffi::c_int,
+    }
+
     #[cfg(target_os = "linux")]
     #[pyfunction]
-    fn getrandom(size: isize, flags: OptionalArg<u32>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+    fn getrandom(
+        GetRandomArgs { size, flags }: GetRandomArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<Vec<u8>> {
         let size = usize::try_from(size)
             .map_err(|_| vm.new_os_error(format!("Invalid argument for size: {size}")))?;
         let mut buf = Vec::with_capacity(size);
         unsafe {
             let len = rustpython_host_env::posix::getrandom(
                 buf.as_mut_ptr() as *mut libc::c_void,
                 size,
-                flags.unwrap_or(0),
+                flags as u32,
             )
             .map_err(|_| vm.new_last_os_error())?;
             buf.set_len(len);
@@ -3207,7 +3226,7 @@ mod posix_sched {
         pid: i32,
         #[pyarg(positional)]
         policy: i32,
-        #[pyarg(positional)]
+        #[pyarg(positional, name = "param")]
         sched_param: PyObjectRef,
     }
 
@@ -3236,7 +3255,7 @@ mod posix_sched {
     struct SchedSetParamArgs {
         #[pyarg(positional)]
         pid: i32,
-        #[pyarg(positional)]
+        #[pyarg(positional, name = "param")]
         sched_param: PyObjectRef,
     }