youknowone · Sep 24, 2026 · Sep 24, 2026 · Sep 24, 2026 · coderabbitai · Sep 24, 2026
diff --git a/crates/derive-impl/src/from_args.rs b/crates/derive-impl/src/from_args.rs
@@ -248,26 +248,47 @@ fn python_default_repr(default: Option<&DefaultValue>, py_default: Option<&str>)
     if let Some(py_default) = py_default {
         return Some(py_default.to_owned());
     }
-    match default {
-        None => None,
-        Some(None) => Some("<unrepresentable>".to_owned()),
-        Some(Some(expr)) => match expr {
-            Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
-                Lit::Bool(b) => Some(if b.value {
-                    "True".to_owned()
+    let expr = default?.as_ref();
+    Some(
+        expr.and_then(python_literal_repr)
+            .unwrap_or_else(|| "<unrepresentable>".to_owned()),
+    )
+}
+
+/// Python source for a Rust literal default, or `None` when it has none.
+fn python_literal_repr(expr: &Expr) -> Option<String> {
+    match expr {
+        Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
+            Lit::Bool(b) => Some(if b.value { "True" } else { "False" }.to_owned()),
+            Lit::Int(i) => Some(i.base10_digits().to_owned()),
+            // `1f64` has digits `1`; keep it a float.
+            Lit::Float(f) => {
+                let digits = f.base10_digits();
+                Some(if digits.contains(['.', 'e', 'E']) {
+                    digits.to_owned()
                 } else {
-                    "False".to_owned()
-                }),
-                Lit::Int(i) => Some(i.base10_digits().to_owned()),
-                Lit::Float(f) => Some(f.base10_digits().to_owned()),
-                Lit::Str(s) => Some(python_str_repr(&s.value())),
-                _ => Some("<unrepresentable>".to_owned()),
-            },
-            Expr::Path(path) if path.qself.is_none() && path.path.is_ident("None") => {
-                Some("None".to_owned())
+                    format!("{digits}.0")
+                })
             }
-            _ => Some("<unrepresentable>".to_owned()),
+            Lit::Str(s) => Some(python_str_repr(&s.value())),
+            _ => None,
         },
+        Expr::Path(path) if path.qself.is_none() && path.path.is_ident("None") => {
+            Some("None".to_owned())
+        }
+        Expr::Unary(syn::ExprUnary {
+            op: syn::UnOp::Neg(_),
+            expr: inner,
+            ..
+        }) => {
+            let inner = python_literal_repr(inner)?;
+            inner
+                .starts_with(|c: char| c.is_ascii_digit())
+                .then(|| format!("-{inner}"))
+        }
+        Expr::Paren(syn::ExprParen { expr: inner, .. })
+        | Expr::Group(syn::ExprGroup { expr: inner, .. }) => python_literal_repr(inner),
+        _ => None,
     }
 }
 

diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
@@ -68,7 +68,7 @@ impl PyNativeFunction {
         if self.value.flags.contains(PyMethodFlags::STATIC) {
             return None;
         }
-        self.zelf.as_deref()
+        self.zelf.as_deref().or(self.module_object.as_deref())
     }
 
     pub const fn as_func(&self) -> &'static dyn PyNativeFn {

diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
@@ -589,7 +589,7 @@ impl PyInt {
 
     #[pymethod]
     fn to_bytes(&self, args: IntToByteArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
-        let signed = args.signed;
+        let signed: bool = args.signed.into();
         let byte_len = args.length;
 
         let value = self.as_bigint();
@@ -823,8 +823,9 @@ struct IntToByteArgs {
     // ArgByteOrder::Big is not the text 'big'.
     #[pyarg(any, default = ArgByteOrder::Big, py_default = "'big'")]
     byteorder: ArgByteOrder,
-    #[pyarg(named, default = false)]
-    signed: bool,
+    // Any object is accepted by truthiness, so the Rust default is not a literal.
+    #[pyarg(named, default = ArgIntoBool::FALSE, py_default = "False")]
+    signed: ArgIntoBool,
 }
 
 fn try_int_radix(obj: &PyObject, base: u32, vm: &VirtualMachine) -> PyResult<BigInt> {

diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
@@ -1490,7 +1490,6 @@ pub(super) mod _os {
     }
 
     #[pyfunction]
-    #[pyfunction(name = "fstat")]
     fn stat(args: StatArgs<'_>, vm: &VirtualMachine) -> PyResult {
         let StatArgs {
             path,
@@ -1500,6 +1499,22 @@ pub(super) mod _os {
         stat_at(path, dir_fd, follow_symlinks, vm)
     }
 
+    #[derive(FromArgs)]
+    struct FstatArgs<'a> {
+        #[pyarg(any)]
+        fd: crt_fd::Borrowed<'a>,
+    }
+
+    #[pyfunction]
+    fn fstat(args: FstatArgs<'_>, vm: &VirtualMachine) -> PyResult {
+        stat_at(
+            OsPathOrFd::Fd(args.fd),
+            DirFd::default(),
+            FollowSymlinks(true),
+            vm,
+        )
+    }
+
     #[pyfunction]
     fn lstat(
         path: OsPath,
@@ -2177,7 +2192,7 @@ pub(super) mod _os {
             SupportFunc::new("rmdir", Some(false), Some(RMDIR_DIR_FD), Some(false)),
             SupportFunc::new("scandir", Some(SCANDIR_FD), Some(false), Some(false)),
             SupportFunc::new("stat", Some(true), Some(STAT_DIR_FD), Some(true)),
-            SupportFunc::new("fstat", Some(true), Some(STAT_DIR_FD), Some(true)),
+            SupportFunc::new("fstat", Some(false), Some(false), Some(false)),
             SupportFunc::new("symlink", Some(false), Some(SYMLINK_DIR_FD), Some(false)),
             SupportFunc::new("truncate", Some(true), Some(false), Some(false)),
             SupportFunc::new("ftruncate", Some(true), Some(false), Some(false)),