Initial work at implementing file methods:

- open (builtin) - for now only for read
- File.read
- File.write
- File.close

Author: raff

builtin/builtin.go

@@ -51,6 +51,7 @@ func init() {
 		// py.MustNewMethod("max", builtin_max, 0, max_doc),
 		// py.MustNewMethod("min", builtin_min, 0, min_doc),
 		py.MustNewMethod("next", builtin_next, 0, next_doc),
+		py.MustNewMethod("open", builtin_open, 0, open_doc),
 		// py.MustNewMethod("oct", builtin_oct, 0, oct_doc),
 		py.MustNewMethod("ord", builtin_ord, 0, ord_doc),
 		py.MustNewMethod("pow", builtin_pow, 0, pow_doc),
@@ -443,6 +444,19 @@ fromlist is not empty.  Level is used to determine whether to perform
 absolute or relative imports. 0 is absolute while a positive number
 is the number of parent directories to search relative to the current module.`
 
+const open_doc = `open(name[, mode[, buffering]]) -> file object
+
+Open a file using the file() type, returns a file object.  This is the
+preferred way to open a file.  See file.__doc__ for further information.`
+
+func builtin_open(self, obj py.Object) (py.Object, error) {
+	if filename, ok := obj.(py.String); ok {
+		return py.OpenFile(string(filename))
+	} else {
+		return nil, py.ExceptionNewf(py.TypeError, "coercing to Unicode: need string or buffer, %v found", obj.Type().Name)
+	}
+}
+
 const ord_doc = `ord(c) -> integer
 
 Return the integer ordinal of a one-character string.`

builtin/tests/builtin.py

@@ -135,6 +135,9 @@ def gen2():
     ok = True
 assert ok, "TypeError not raised"
 
+doc="open"
+assert open(__file__) is not None
+
 doc="pow"
 assert pow(2, 10) == 1024
 assert pow(2, 10, 17) == 4

py/file.go

@@ -10,17 +10,126 @@
 package py
 
 import (
+	"io"
+	"io/ioutil"
 	"os"
 )
 
-var FileType = NewTypeX("file", `represents an open file`,
-	nil, nil)
-
 type File os.File
 
+var FileType = NewType("file", `represents an open file`)
+
+func init() {
+	FileType.Dict["write"] = MustNewMethod("write", func(self Object, value Object) (Object, error) {
+		return self.(*File).Write(value)
+	}, 0, "write(arg) -> writes the contents of arg to the file, returning the number of characters written.")
+
+	FileType.Dict["read"] = MustNewMethod("read", func(self Object, args Tuple, kwargs StringDict) (Object, error) {
+		return self.(*File).Read(args, kwargs)
+	}, 0, "read([size]) -> read at most size bytes, returned as a string.\n\nIf the size argument is negative or omitted, read until EOF is reached.\nNotice that when in non-blocking mode, less data than what was requested\nmay be returned, even if no size parameter was given.")
+	FileType.Dict["close"] = MustNewMethod("close", func(self Object) (Object, error) {
+		return self.(*File).Close()
+	}, 0, "close() -> None or (perhaps) an integer.  Close the file.\n\nSets data attribute .closed to True.  A closed file cannot be used for\nfurther I/O operations.  close() may be called more than once without\nerror.  Some kinds of file objects (for example, opened by popen())\nmay return an exit status upon closing.")
+}
+
 // Type of this object
 func (o *File) Type() *Type {
 	return FileType
 }
 
+func (o *File) Write(value Object) (Object, error) {
+	var b []byte
+
+	switch v := value.(type) {
+	// FIXME Bytearray
+	case Bytes:
+		b = v
+
+	case String:
+		b = []byte(v)
+
+	default:
+		return nil, ExceptionNewf(TypeError, "expected a string or other character buffer object")
+	}
+
+	n, err := (*os.File)(o).Write(b)
+	return Int(n), err
+}
+
+func (o *File) readResult(b []byte) (Object, error) {
+	var asBytes = false // default mode is "as string" - also move this in File struct
+
+	if b == nil {
+		if asBytes {
+			return Bytes{}, nil
+		} else {
+			return String(""), nil
+		}
+	}
+
+	if asBytes {
+		return Bytes(b), nil
+	} else {
+		return String(b), nil
+	}
+}
+
+func (o *File) Read(args Tuple, kwargs StringDict) (Object, error) {
+	var arg Object = None
+
+	err := UnpackTuple(args, kwargs, "read", 0, 1, &arg)
+	if err != nil {
+		return nil, err
+	}
+
+	var r io.Reader = (*os.File)(o)
+
+	switch pyN, ok := arg.(Int); {
+	case arg == None:
+		// read all
+
+	case ok:
+		// number of bytes to read
+		// 0: read nothing
+		// < 0: read all
+		// > 0: read n
+		n, _ := pyN.GoInt64()
+		if n == 0 {
+			return o.readResult(nil)
+		}
+		if n > 0 {
+			r = io.LimitReader(r, n)
+		}
+
+	default:
+		// invalid type
+		return nil, ExceptionNewf(TypeError, "read() argument 1 must be int, not %s", arg.Type().Name)
+	}
+
+	b, err := ioutil.ReadAll(r)
+	if err == io.EOF {
+		return o.readResult(nil)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return o.readResult(b)
+}
+
+func (o *File) Close() (Object, error) {
+	_ = (*os.File)(o).Close()
+	return None, nil
+}
+
+func OpenFile(filename string) (Object, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		// XXX: should check for different types of errors
+		return nil, ExceptionNewf(FileNotFoundError, err.Error())
+	}
+
+	return (*File)(f), nil
+}
+
 // Check interface is satisfied

py/tests/file.py

@@ -0,0 +1,41 @@
+# Copyright 2018 The go-python Authors.  All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from libtest import assertRaises
+
+doc = "open"
+assertRaises(FileNotFoundError, open, "not-existent.file")
+
+f = open(__file__)
+assert f is not None
+
+doc = "read"
+b = f.read(12)
+assert b == '# Copyright '
+
+b = f.read(4)
+assert b == '2018'
+
+b = f.read()
+assert b != ''
+
+b = f.read()
+assert b == ''
+
+doc = "write"
+assertRaises(TypeError, f.write, 42)
+
+# assertRaises(io.UnsupportedOperation, f.write, 'hello')
+
+import sys
+n = sys.stdout.write('hello')
+assert n == 5
+
+doc = "close"
+f.close()
+
+# closing a closed file should not throw an error
+f.close()
+
+doc = "finished"

pytest/pytest.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 
 	_ "github.com/go-python/gpython/builtin"
+	_ "github.com/go-python/gpython/sys"
 	"github.com/go-python/gpython/compile"
 	"github.com/go-python/gpython/py"
 	"github.com/go-python/gpython/vm"