all: support filter builtin feature and fix iterable object

Author: wetor

py/arithmetic.go

@@ -147,24 +147,6 @@ func MakeFloat(a Object) (Object, error) {
 	return nil, ExceptionNewf(TypeError, "unsupported operand type(s) for float: '%s'", a.Type().Name)
 }
 
-// Iter the python Object returning an Object
-//
-// Will raise TypeError if Iter can't be run on this object
-func Iter(a Object) (Object, error) {
-
-	if A, ok := a.(I__iter__); ok {
-		res, err := A.M__iter__()
-		if err != nil {
-			return nil, err
-		}
-		if res != NotImplemented {
-			return res, nil
-		}
-	}
-
-	return nil, ExceptionNewf(TypeError, "unsupported operand type(s) for iter: '%s'", a.Type().Name)
-}
-
 // Add two python objects together returning an Object
 //
 // Will raise TypeError if can't be add can't be run on these objects

py/dict.go

@@ -36,7 +36,7 @@ func init() {
 			return nil, err
 		}
 		sMap := self.(StringDict)
-		o := make([]Object, 0, len(sMap))
+		o := make(Tuple, 0, len(sMap))
 		for k, v := range sMap {
 			o = append(o, Tuple{String(k), v})
 		}
@@ -49,7 +49,7 @@ func init() {
 			return nil, err
 		}
 		sMap := self.(StringDict)
-		o := make([]Object, 0, len(sMap))
+		o := make(Tuple, 0, len(sMap))
 		for k := range sMap {
 			o = append(o, String(k))
 		}
@@ -62,7 +62,7 @@ func init() {
 			return nil, err
 		}
 		sMap := self.(StringDict)
-		o := make([]Object, 0, len(sMap))
+		o := make(Tuple, 0, len(sMap))
 		for _, v := range sMap {
 			o = append(o, v)
 		}
@@ -204,7 +204,7 @@ func (a StringDict) M__repr__() (Object, error) {
 
 // Returns a list of keys from the dict
 func (d StringDict) M__iter__() (Object, error) {
-	o := make([]Object, 0, len(d))
+	o := make(Tuple, 0, len(d))
 	for k := range d {
 		o = append(o, String(k))
 	}

py/exception.go

@@ -336,6 +336,8 @@ func ExceptionGivenMatches(err, exc Object) bool {
 func IsException(exception *Type, r interface{}) bool {
 	var t *Type
 	switch ex := r.(type) {
+	case ExceptionInfo:
+		t = ex.Type
 	case *Exception:
 		t = ex.Type()
 	case *Type:

py/filter.go

@@ -0,0 +1,72 @@
+// 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.
+
+package py
+
+// A python Filter object
+type Filter struct {
+	it  Object
+	fun Object
+}
+
+var FilterType = NewTypeX("filter", `filter(function or None, iterable) --> filter object
+
+Return an iterator yielding those items of iterable for which function(item)
+is true. If function is None, return the items that are true.`,
+	FilterTypeNew, nil)
+
+// Type of this object
+func (f *Filter) Type() *Type {
+	return FilterType
+}
+
+// FilterTypeNew
+func FilterTypeNew(metatype *Type, args Tuple, kwargs StringDict) (res Object, err error) {
+	var fun, seq Object
+	var it Object
+	err = UnpackTuple(args, kwargs, "filter", 2, 2, &fun, &seq)
+	if err != nil {
+		return nil, err
+	}
+	it, err = Iter(seq)
+	if err != nil {
+		return nil, err
+	}
+	return &Filter{it: it, fun: fun}, nil
+}
+
+func (f *Filter) M__iter__() (Object, error) {
+	return f, nil
+}
+
+func (f *Filter) M__next__() (Object, error) {
+	var ok bool
+	for {
+		item, err := Next(f.it)
+		if err != nil {
+			return nil, err
+		}
+		// if (lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type)
+		if _, _ok := f.fun.(Bool); _ok || f.fun == None {
+			ok, err = ObjectIsTrue(item)
+		} else {
+			var good Object
+			good, err = Call(f.fun, Tuple{item}, nil)
+			if err != nil {
+				return nil, err
+			}
+			ok, err = ObjectIsTrue(good)
+		}
+		if ok {
+			return item, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+}
+
+// Check interface is satisfied
+var _ I__iter__ = (*Filter)(nil)
+var _ I__next__ = (*Filter)(nil)

py/gen.go

@@ -45,7 +45,6 @@ var data = Data{
 		{Name: "complex", Title: "MakeComplex", Operator: "complex", Unary: true, Conversion: "Complex"},
 		{Name: "int", Title: "MakeInt", Operator: "int", Unary: true, Conversion: "Int"},
 		{Name: "float", Title: "MakeFloat", Operator: "float", Unary: true, Conversion: "Float"},
-		{Name: "iter", Title: "Iter", Operator: "iter", Unary: true},
 	},
 	BinaryOps: Ops{
 		{Name: "add", Title: "Add", Operator: "+", Binary: true},

py/internal.go

@@ -430,3 +430,20 @@ func ReprAsString(self Object) (string, error) {
 	}
 	return string(str), nil
 }
+
+// Returns an iterator object
+//
+// Call __Iter__ Returns an iterator object
+//
+// If object is sequence object, create an iterator
+func Iter(self Object) (res Object, err error) {
+	if I, ok := self.(I__iter__); ok {
+		return I.M__iter__()
+	} else if res, ok, err = TypeCall0(self, "__iter__"); ok {
+		return res, err
+	}
+	if ObjectIsSequence(self) {
+		return NewIterator(self), nil
+	}
+	return nil, ExceptionNewf(TypeError, "'%s' object is not iterable", self.Type().Name)
+}

py/iterator.go

@@ -8,8 +8,8 @@ package py
 
 // A python Iterator object
 type Iterator struct {
-	Pos  int
-	Objs []Object
+	Pos int
+	Seq Object
 }
 
 var IteratorType = NewType("iterator", "iterator type")
@@ -20,10 +20,10 @@ func (o *Iterator) Type() *Type {
 }
 
 // Define a new iterator
-func NewIterator(Objs []Object) *Iterator {
+func NewIterator(Seq Object) *Iterator {
 	m := &Iterator{
-		Pos:  0,
-		Objs: Objs,
+		Pos: 0,
+		Seq: Seq,
 	}
 	return m
 }
@@ -33,13 +33,29 @@ func (it *Iterator) M__iter__() (Object, error) {
 }
 
 // Get next one from the iteration
-func (it *Iterator) M__next__() (Object, error) {
-	if it.Pos >= len(it.Objs) {
-		return nil, StopIteration
+func (it *Iterator) M__next__() (res Object, err error) {
+	if tuple, ok := it.Seq.(Tuple); ok {
+		if it.Pos >= len(tuple) {
+			return nil, StopIteration
+		}
+		res = tuple[it.Pos]
+		it.Pos++
+		return res, nil
+	}
+	index := Int(it.Pos)
+	if I, ok := it.Seq.(I__getitem__); ok {
+		res, err = I.M__getitem__(index)
+	} else if res, ok, err = TypeCall1(it.Seq, "__getitem__", index); !ok {
+		return nil, ExceptionNewf(TypeError, "'%s' object is not iterable", it.Type().Name)
+	}
+	if err != nil {
+		if IsException(IndexError, err) {
+			return nil, StopIteration
+		}
+		return nil, err
 	}
-	r := it.Objs[it.Pos]
 	it.Pos++
-	return r, nil
+	return res, nil
 }
 
 // Check interface is satisfied

py/list.go

@@ -186,7 +186,7 @@ func (l *List) M__bool__() (Object, error) {
 }
 
 func (l *List) M__iter__() (Object, error) {
-	return NewIterator(l.Items), nil
+	return NewIterator(Tuple(l.Items)), nil
 }
 
 func (l *List) M__getitem__(key Object) (Object, error) {
@@ -496,7 +496,11 @@ func SortInPlace(l *List, kwargs StringDict, funcName string) error {
 		reverse = False
 	}
 	// FIXME: requires the same bool-check like CPython (or better "|$Op" that doesn't panic on nil).
-	s := ptrSortable{&sortable{l, keyFunc, ObjectIsTrue(reverse), nil}}
+	ok, err := ObjectIsTrue(reverse)
+	if err != nil {
+		return err
+	}
+	s := ptrSortable{&sortable{l, keyFunc, ok, nil}}
 	sort.Stable(s)
 	return s.s.firstErr
 }

py/object.go

@@ -23,24 +23,50 @@ func ObjectRepr(o Object) Object {
 }
 
 // Return whether the object is True or not
-func ObjectIsTrue(o Object) bool {
+func ObjectIsTrue(o Object) (bool, error) {
 	if o == True {
-		return true
+		return true, nil
 	}
 	if o == False {
-		return false
+		return false, nil
 	}
 
 	if o == None {
-		return false
+		return false, nil
 	}
 
 	if I, ok := o.(I__bool__); ok {
 		cmp, err := I.M__bool__()
-		if err == nil && cmp == True {
+		if err != nil {
+			return false, err
+		}
+		if cmp == True {
+			return true, nil
+		} else if cmp == False {
+			return false, nil
+		}
+	}
+	if I, ok := o.(I__len__); ok {
+		l, err := I.M__len__()
+		if err != nil {
+			return false, err
+		}
+		if l.(Int) > 0 {
+			return true, nil
+		} else {
+			return false, nil
+		}
+	}
+	return false, nil
+}
+
+// Return whether the object is True or not
+func ObjectIsSequence(o Object) bool {
+	if _, ok := o.(I__getitem__); ok {
+		return true
+	} else if t, ok := o.(*Type); ok {
+		if t.GetAttrOrNil("__getitem__") != nil {
 			return true
-		} else if err == nil && cmp == False {
-			return false
 		}
 	}
 	return false

py/tests/filter.py

@@ -0,0 +1,44 @@
+# test_builtin.py:BuiltinTest.test_filter()
+from libtest import assertRaises
+
+doc="filter"
+class Squares:
+    def __init__(self, max):
+        self.max = max
+        self.sofar = []
+
+    def __len__(self): return len(self.sofar)
+
+    def __getitem__(self, i):
+        if not 0 <= i < self.max: raise IndexError
+        n = len(self.sofar)
+        while n <= i:
+            self.sofar.append(n*n)
+            n += 1
+        return self.sofar[i]
+
+assert list(filter(lambda c: 'a' <= c <= 'z', 'Hello World')) == list('elloorld')
+assert list(filter(None, [1, 'hello', [], [3], '', None, 9, 0])) == [1, 'hello', [3], 9]
+assert list(filter(lambda x: x > 0, [1, -3, 9, 0, 2])) == [1, 9, 2]
+assert list(filter(None, Squares(10))) == [1, 4, 9, 16, 25, 36, 49, 64, 81]
+assert list(filter(lambda x: x%2, Squares(10))) == [1, 9, 25, 49, 81]
+def identity(item):
+    return 1
+filter(identity, Squares(5))
+assertRaises(TypeError, filter)
+class BadSeq(object):
+    def __getitem__(self, index):
+        if index<4:
+            return 42
+        raise ValueError
+assertRaises(ValueError, list, filter(lambda x: x, BadSeq()))
+def badfunc():
+    pass
+assertRaises(TypeError, list, filter(badfunc, range(5)))
+
+# test bltinmodule.c::filtertuple()
+assert list(filter(None, (1, 2))) == [1, 2]
+assert list(filter(lambda x: x>=3, (1, 2, 3, 4))) == [3, 4]
+assertRaises(TypeError, list, filter(42, (1, 2)))
+
+doc="finished"

py/tests/iter.py

@@ -1,6 +1,7 @@
 # Copyright 2019 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="iter"
 cnt = 0
@@ -18,4 +19,14 @@ def f():
 words2 = list(iter(words1))
 for w1, w2 in zip(words1, words2):
     assert w1 == w2
+
+# test_builtin.py:BuiltinTest.test_iter()
+assertRaises(TypeError, iter)
+assertRaises(TypeError, iter, 42, 42)
+lists = [("1", "2"), ["1", "2"], "12"]
+for l in lists:
+    i = iter(l)
+    assert next(i) == '1'
+    assert next(i) == '2'
+    assertRaises(StopIteration, next, i)
 doc="finished"