bytesinner from pytuple

qingshi163 · qingshi163 · commit 6c72e69a0018 · 2020-10-02T09:46:24.000+02:00
diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py
@@ -71,6 +71,8 @@ def setitem(value):
         m = None
         self.assertEqual(sys.getrefcount(b), oldrefcount)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_setitem_writable(self):
         if not self.rw_type:
             self.skipTest("no writable type to test")
@@ -112,13 +114,11 @@ def setitem(key, value):
         self.assertRaises(TypeError, setitem, "a", b"a")
         # Not implemented: multidimensional slices
         slices = (slice(0,1,1), slice(0,1,2))
-        # TODO: RUSTPYTHON
-        # self.assertRaises(NotImplementedError, setitem, slices, b"a")
+        self.assertRaises(NotImplementedError, setitem, slices, b"a")
         # Trying to resize the memory object
         exc = ValueError if m.format == 'c' else TypeError
-        # TODO: RUSTPYTHON
-        # self.assertRaises(exc, setitem, 0, b"")
-        # self.assertRaises(exc, setitem, 0, b"ab")
+        self.assertRaises(exc, setitem, 0, b"")
+        self.assertRaises(exc, setitem, 0, b"ab")
         self.assertRaises(ValueError, setitem, slice(1,1), b"a")
         self.assertRaises(ValueError, setitem, slice(0,2), b"a")
 
diff --git a/extra_tests/snippets/memoryview.py b/extra_tests/snippets/memoryview.py
@@ -6,7 +6,7 @@
 a = memoryview(obj)
 assert a.obj == obj
 
-# assert a[2:3] == b"c"
+assert a[2:3] == b"c"
 
 assert hash(obj) == hash(a)
 
diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs
@@ -3,7 +3,6 @@ use itertools::Itertools;
 use num_bigint::BigInt;
 use num_traits::ToPrimitive;
 
-use crate::anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper};
 use crate::byteslike::try_bytes_like;
 use crate::function::{OptionalArg, OptionalOption};
 use crate::obj::objbytearray::PyByteArray;
@@ -23,6 +22,10 @@ use crate::pyobject::{
 };
 use crate::slots::PyComparisonOp;
 use crate::vm::VirtualMachine;
+use crate::{
+    anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper},
+    obj::objtuple::PyTuple,
+};
 use rustpython_common::hash;
 
 #[derive(Debug, Default, Clone)]
@@ -43,8 +46,9 @@ impl TryFromObject for PyBytesInner {
         }
 
         match_class!(match obj {
+            // TODO: generic way from &[PyObjectRef]
             l @ PyList => l.to_byte_inner(vm),
-            // TODO: PyTyple
+            t @ PyTuple => t.to_bytes_inner(vm),
             obj => {
                 let iter = vm.get_method_or_type_error(obj.clone(), "__iter__", || {
                     format!("a bytes-like object is required, not {}", obj.class())
diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -74,6 +74,7 @@ impl PyList {
         self.elements.write()
     }
 
+    // TODO: more generic way to do so
     pub(crate) fn to_byte_inner(&self, vm: &VirtualMachine) -> PyResult<bytesinner::PyBytesInner> {
         let mut elements = Vec::<u8>::with_capacity(self.borrow_value().len());
         for elem in self.borrow_value().iter() {
diff --git a/vm/src/obj/objtuple.rs b/vm/src/obj/objtuple.rs
@@ -1,17 +1,19 @@
 use crossbeam_utils::atomic::AtomicCell;
+use num_traits::ToPrimitive;
 use std::fmt;
 
-use super::objiter;
 use super::objsequence::get_item;
 use super::objtype::PyTypeRef;
-use crate::function::OptionalArg;
+use super::{objint::PyIntRef, objiter};
 use crate::pyobject::{
     self, BorrowValue, Either, IdProtocol, IntoPyObject, PyArithmaticValue, PyClassImpl,
-    PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
+    TypeProtocol,
 };
 use crate::sequence::{self, SimpleSeq};
 use crate::slots::{Comparable, Hashable, PyComparisonOp};
 use crate::vm::{ReprGuard, VirtualMachine};
+use crate::{bytesinner::PyBytesInner, function::OptionalArg};
 use rustpython_common::hash::PyHash;
 
 /// tuple() -> empty tuple
@@ -66,6 +68,25 @@ impl PyTuple {
     pub(crate) fn fast_getitem(&self, idx: usize) -> PyObjectRef {
         self.elements[idx].clone()
     }
+
+    // TODO: more generic way to do so
+    pub(crate) fn to_bytes_inner(&self, vm: &VirtualMachine) -> PyResult<PyBytesInner> {
+        let mut elements = Vec::<u8>::with_capacity(self.borrow_value().len());
+        for elem in self.borrow_value().iter() {
+            let py_int = PyIntRef::try_from_object(vm, elem.clone()).map_err(|_| {
+                vm.new_type_error(format!(
+                    "'{}' object cannot be interpreted as an integer",
+                    elem.class().name
+                ))
+            })?;
+            let result = py_int
+                .borrow_value()
+                .to_u8()
+                .ok_or_else(|| vm.new_value_error("bytes must be in range (0, 256)".to_owned()))?;
+            elements.push(result);
+        }
+        Ok(elements.into())
+    }
 }
 
 pub type PyTupleRef = PyRef<PyTuple>;

Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ impl PyList {`
`74`	`74`	`self.elements.write()`
`75`	`75`	`}`
`76`	`76`
	`77`	`+ // TODO: more generic way to do so`
`77`	`78`	`pub(crate) fn to_byte_inner(&self, vm: &VirtualMachine) -> PyResult<bytesinner::PyBytesInner> {`
`78`	`79`	`let mut elements = Vec::<u8>::with_capacity(self.borrow_value().len());`
`79`	`80`	`for elem in self.borrow_value().iter() {`