int_from_bytes

Author: Shitong Wen

tests/snippets/ints.py

@@ -72,8 +72,8 @@
 
 assert int.from_bytes(b'\x00\x10', 'big') == 16
 assert int.from_bytes(b'\x00\x10', 'little') == 4096
-assert int.from_bytes(b'\xfc\x00', 'big', True) == -1024
-assert int.from_bytes(b'\xfc\x00', 'big', False) == 64512
+assert int.from_bytes(b'\xfc\x00', 'big', signed=True) == -1024
+assert int.from_bytes(b'\xfc\x00', 'big', signed=False) == 64512
 
 with assertRaises(TypeError):
     int(base=2)

vm/src/obj/objint.rs

@@ -6,16 +6,16 @@ use num_integer::Integer;
 use num_traits::{One, Pow, Signed, ToPrimitive, Zero};
 
 use crate::format::FormatSpec;
-use crate::function::{OptionalArg, PyFuncArgs};
+use crate::function::{KwArgs, OptionalArg, PyFuncArgs};
 use crate::pyobject::{
     IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
     TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
+use super::objbyteinner::PyByteInner;
 use super::objstr::{PyString, PyStringRef};
 use super::objtype;
-use super::objbyteinner::{PyByteInner};
 use crate::obj::objtype::PyClassRef;
 
 /// int(x=0) -> integer
@@ -491,24 +491,37 @@ impl PyInt {
     }
 
     #[pymethod]
-    fn from_bytes(bytes: PyByteInner, byteorder: PyStringRef, signed: OptionalArg<bool>, vm: &VirtualMachine) -> PyResult<BigInt>{
+    fn from_bytes(
+        bytes: PyByteInner,
+        byteorder: PyStringRef,
+        kwargs: KwArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<BigInt> {
+        let mut signed = false;
+        for (key, value) in kwargs.into_iter() {
+            if key == "signed" {
+                signed = match_class!(value,
+
+                    b @ PyInt => !b.as_bigint().is_zero(),
+                    _ => false,
+                );
+            }
+        }
         let x;
         if byteorder.value == "big" {
             x = match signed {
-                OptionalArg::Present(true) => BigInt::from_signed_bytes_be(&bytes.elements),
-                _ => BigInt::from_bytes_be(Sign::Plus, &bytes.elements),
+                true => BigInt::from_signed_bytes_be(&bytes.elements),
+                false => BigInt::from_bytes_be(Sign::Plus, &bytes.elements),
             }
-        }
-        else if byteorder.value == "little" {
+        } else if byteorder.value == "little" {
             x = match signed {
-                OptionalArg::Present(true) => BigInt::from_signed_bytes_le(&bytes.elements),
-                _ => BigInt::from_bytes_le(Sign::Plus, &bytes.elements),
+                true => BigInt::from_signed_bytes_le(&bytes.elements),
+                false => BigInt::from_bytes_le(Sign::Plus, &bytes.elements),
             }
-        }
-        else {
-            return Err(vm.new_value_error(
-                            "byteorder must be either 'little' or 'big'".to_string(),
-            ));
+        } else {
+            return Err(
+                vm.new_value_error("byteorder must be either 'little' or 'big'".to_string())
+            );
         }
         Ok(x)
     }