@@ -266,6 +266,23 @@ fn python_default_repr(default: Option<&DefaultValue>, py_default: Option<&str>)
             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,
+                ..
+            }) => match inner.as_ref() {
+                Expr::Lit(syn::ExprLit {
+                    lit: Lit::Int(i), ..
+                }) => Some(format!("-{}", i.base10_digits())),
+                Expr::Lit(syn::ExprLit {
+                    lit: Lit::Float(f), ..
+                }) => Some(format!("-{}", f.base10_digits())),
+                _ => Some("<unrepresentable>".to_owned()),
+            },
+            Expr::Paren(syn::ExprParen { expr: inner, .. })
+            | Expr::Group(syn::ExprGroup { expr: inner, .. }) => {
+                python_default_repr(Some(&Some(inner.as_ref().clone())), None)
+            }
             _ => Some("<unrepresentable>".to_owned()),
         },
     }
 
@@ -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 {
 
@@ -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> {
 
@@ -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,
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ impl PyNativeFunction {`
`68`	`68`	`if self.value.flags.contains(PyMethodFlags::STATIC) {`
`69`	`69`	`return None;`
`70`	`70`	`}`
`71`		`- self.zelf.as_deref()`
	`71`	`+ self.zelf.as_deref().or(self.module_object.as_deref())`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`pub const fn as_func(&self) -> &'static dyn PyNativeFn {`