Merge pull request RustPython#265 from rmliddle/implement-io

File-IO: IO Module and Open Builtin

Author: windelbouwman

tests/snippets/buffered_reader.py

@@ -0,0 +1,10 @@
+from io import BufferedReader, FileIO
+
+fi = FileIO('README.md')
+bb = BufferedReader(fi)
+
+result = bb.read()
+
+assert len(result) <= 8*1024
+assert len(result) >= 0
+assert isinstance(result, bytes)

tests/snippets/os_open.py

@@ -0,0 +1,4 @@
+import os 
+
+assert os.open('README.md', 0) > 0
+

tests/snippets/os_static.py

@@ -0,0 +1,5 @@
+import os 
+
+assert os.O_RDONLY == 0
+assert os.O_WRONLY == 1
+assert os.O_RDWR == 2

vm/src/builtins.rs

@@ -13,10 +13,13 @@ use super::obj::objint;
 use super::obj::objiter;
 use super::obj::objstr;
 use super::obj::objtype;
+
 use super::pyobject::{
     AttributeProtocol, IdProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef,
     PyResult, Scope, TypeProtocol,
 };
+use super::stdlib::io::io_open;
+
 use super::vm::VirtualMachine;
 use num_bigint::ToBigInt;
 use num_traits::{Signed, ToPrimitive, Zero};
@@ -499,8 +502,6 @@ fn builtin_max(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(x)
 }
 
-// builtin_memoryview
-
 fn builtin_min(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let candidates = if args.args.len() > 1 {
         args.args.clone()
@@ -587,8 +588,6 @@ fn builtin_oct(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.new_str(s))
 }
 
-// builtin_open
-
 fn builtin_ord(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(string, Some(vm.ctx.str_type()))]);
     let string = objstr::get_value(string);
@@ -771,9 +770,11 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     ctx.set_attr(&py_mod, "locals", ctx.new_rustfunc(builtin_locals));
     ctx.set_attr(&py_mod, "map", ctx.new_rustfunc(builtin_map));
     ctx.set_attr(&py_mod, "max", ctx.new_rustfunc(builtin_max));
+    ctx.set_attr(&py_mod, "memoryview", ctx.memoryview_type());
     ctx.set_attr(&py_mod, "min", ctx.new_rustfunc(builtin_min));
     ctx.set_attr(&py_mod, "object", ctx.object());
     ctx.set_attr(&py_mod, "oct", ctx.new_rustfunc(builtin_oct));
+    ctx.set_attr(&py_mod, "open", ctx.new_rustfunc(io_open));
     ctx.set_attr(&py_mod, "ord", ctx.new_rustfunc(builtin_ord));
     ctx.set_attr(&py_mod, "next", ctx.new_rustfunc(builtin_next));
     ctx.set_attr(&py_mod, "pow", ctx.new_rustfunc(builtin_pow));

vm/src/obj/mod.rs

@@ -13,6 +13,7 @@ pub mod objgenerator;
 pub mod objint;
 pub mod objiter;
 pub mod objlist;
+pub mod objmemory;
 pub mod objobject;
 pub mod objproperty;
 pub mod objsequence;

vm/src/obj/objbytearray.rs

@@ -3,11 +3,15 @@
 use super::super::pyobject::{
     PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
+
+use super::objint;
+
 use super::super::vm::VirtualMachine;
 use super::objbytes::get_value;
-use super::objint;
 use super::objtype;
+use num_bigint::ToBigInt;
 use num_traits::ToPrimitive;
+
 // Binary data support
 
 /// Fill bytearray class methods dictionary.
@@ -28,6 +32,11 @@ pub fn init(context: &PyContext) {
         "__repr__",
         context.new_rustfunc(bytearray_repr),
     );
+    context.set_attr(
+        &bytearray_type,
+        "__len__",
+        context.new_rustfunc(bytesarray_len),
+    );
 }
 
 fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -54,13 +63,20 @@ fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else {
         vec![]
     };
-
     Ok(PyObject::new(
         PyObjectKind::Bytes { value: value },
         cls.clone(),
     ))
 }
 
+fn bytesarray_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(a, Some(vm.ctx.bytearray_type()))]);
+
+    let byte_vec = get_value(a).to_vec();
+    let value = byte_vec.len().to_bigint();
+    Ok(vm.ctx.new_int(value.unwrap()))
+}
+
 fn bytearray_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(
         vm,
@@ -95,8 +111,7 @@ fn set_value(obj: &PyObjectRef, value: Vec<u8>) {
 
 fn bytearray_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(obj, Some(vm.ctx.bytearray_type()))]);
-    let data = get_value(obj);
-    let data: Vec<String> = data.iter().map(|b| format!("\\x{:02x}", b)).collect();
-    let data = data.join("");
+    let value = get_value(obj);
+    let data = String::from_utf8(value.to_vec()).unwrap();
     Ok(vm.new_str(format!("bytearray(b'{}')", data)))
 }

vm/src/obj/objbytes.rs

@@ -9,6 +9,7 @@ use num_traits::ToPrimitive;
 use std::cell::Ref;
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
+
 // Binary data support
 
 // Fill bytes class methods:
@@ -18,6 +19,7 @@ pub fn init(context: &PyContext) {
     context.set_attr(bytes_type, "__hash__", context.new_rustfunc(bytes_hash));
     context.set_attr(bytes_type, "__new__", context.new_rustfunc(bytes_new));
     context.set_attr(bytes_type, "__repr__", context.new_rustfunc(bytes_repr));
+    context.set_attr(bytes_type, "__len__", context.new_rustfunc(bytes_len));
 }
 
 fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -66,6 +68,14 @@ fn bytes_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_bool(result))
 }
 
+fn bytes_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(a, Some(vm.ctx.bytes_type()))]);
+
+    let byte_vec = get_value(a).to_vec();
+    let value = byte_vec.len().to_bigint();
+    Ok(vm.ctx.new_int(value.unwrap()))
+}
+
 fn bytes_hash(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytes_type()))]);
     let data = get_value(zelf);

vm/src/obj/objmemory.rs

@@ -0,0 +1,26 @@
+use super::objtype;
+
+use super::super::pyobject::{
+    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+};
+use super::super::vm::VirtualMachine;
+
+pub fn new_memory_view(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(cls, None), (bytes_object, None)]);
+    vm.ctx.set_attr(&cls, "obj", bytes_object.clone());
+    Ok(PyObject::new(
+        PyObjectKind::MemoryView {
+            obj: bytes_object.clone(),
+        },
+        cls.clone(),
+    ))
+}
+
+pub fn init(ctx: &PyContext) {
+    let ref memoryview_type = ctx.memoryview_type;
+    ctx.set_attr(
+        &memoryview_type,
+        "__new__",
+        ctx.new_rustfunc(new_memory_view),
+    );
+}

vm/src/pyobject.rs

@@ -14,6 +14,7 @@ use super::obj::objgenerator;
 use super::obj::objint;
 use super::obj::objiter;
 use super::obj::objlist;
+use super::obj::objmemory;
 use super::obj::objobject;
 use super::obj::objproperty;
 use super::obj::objset;
@@ -114,6 +115,7 @@ pub struct PyContext {
     pub true_value: PyObjectRef,
     pub false_value: PyObjectRef,
     pub list_type: PyObjectRef,
+    pub memoryview_type: PyObjectRef,
     pub none: PyObjectRef,
     pub tuple_type: PyObjectRef,
     pub set_type: PyObjectRef,
@@ -197,6 +199,7 @@ impl PyContext {
         let tuple_type = create_type("tuple", &type_type, &object_type, &dict_type);
         let iter_type = create_type("iter", &type_type, &object_type, &dict_type);
         let bool_type = create_type("bool", &type_type, &int_type, &dict_type);
+        let memoryview_type = create_type("memoryview", &type_type, &object_type, &dict_type);
         let code_type = create_type("code", &type_type, &int_type, &dict_type);
         let exceptions = exceptions::ExceptionZoo::new(&type_type, &object_type, &dict_type);
 
@@ -217,6 +220,7 @@ impl PyContext {
         );
         let context = PyContext {
             bool_type: bool_type,
+            memoryview_type: memoryview_type,
             bytearray_type: bytearray_type,
             bytes_type: bytes_type,
             code_type: code_type,
@@ -261,6 +265,7 @@ impl PyContext {
         objbytes::init(&context);
         objbytearray::init(&context);
         objproperty::init(&context);
+        objmemory::init(&context);
         objstr::init(&context);
         objsuper::init(&context);
         objtuple::init(&context);
@@ -320,6 +325,10 @@ impl PyContext {
         self.bool_type.clone()
     }
 
+    pub fn memoryview_type(&self) -> PyObjectRef {
+        self.memoryview_type.clone()
+    }
+
     pub fn tuple_type(&self) -> PyObjectRef {
         self.tuple_type.clone()
     }
@@ -402,6 +411,10 @@ impl PyContext {
         PyObject::new(PyObjectKind::Bytes { value: data }, self.bytes_type())
     }
 
+    pub fn new_bytearray(&self, data: Vec<u8>) -> PyObjectRef {
+        PyObject::new(PyObjectKind::Bytes { value: data }, self.bytearray_type())
+    }
+
     pub fn new_bool(&self, b: bool) -> PyObjectRef {
         if b {
             self.true_value.clone()
@@ -753,6 +766,20 @@ impl DictProtocol for PyObjectRef {
     }
 }
 
+pub trait BufferProtocol {
+    fn readonly(&self) -> bool;
+}
+
+impl BufferProtocol for PyObjectRef {
+    fn readonly(&self) -> bool {
+        match objtype::get_type_name(&self.typ()).as_ref() {
+            "bytes" => false,
+            "bytearray" | "memoryview" => true,
+            _ => panic!("Bytes-Like type expected not {:?}", self),
+        }
+    }
+}
+
 impl fmt::Debug for PyObject {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "[PyObj {:?}]", self.kind)
@@ -850,6 +877,9 @@ pub enum PyObjectKind {
         stop: Option<i32>,
         step: Option<i32>,
     },
+    MemoryView {
+        obj: PyObjectRef,
+    },
     Code {
         code: bytecode::CodeObject,
     },
@@ -900,6 +930,7 @@ impl fmt::Debug for PyObjectKind {
             &PyObjectKind::Float { ref value } => write!(f, "float {}", value),
             &PyObjectKind::Complex { ref value } => write!(f, "complex {}", value),
             &PyObjectKind::Bytes { ref value } => write!(f, "bytes/bytearray {:?}", value),
+            &PyObjectKind::MemoryView { ref obj } => write!(f, "bytes/bytearray {:?}", obj),
             &PyObjectKind::Sequence { elements: _ } => write!(f, "list or tuple"),
             &PyObjectKind::Dict { elements: _ } => write!(f, "dict"),
             &PyObjectKind::Set { elements: _ } => write!(f, "set"),
@@ -953,6 +984,7 @@ impl PyObject {
             PyObjectKind::Float { ref value } => format!("{:?}", value),
             PyObjectKind::Complex { ref value } => format!("{:?}", value),
             PyObjectKind::Bytes { ref value } => format!("b'{:?}'", value),
+            PyObjectKind::MemoryView { ref obj } => format!("b'{:?}'", obj),
             PyObjectKind::Sequence { ref elements } => format!(
                 "(/[{}]/)",
                 elements