Merge remote-tracking branch 'upstream/master'

raff · raff · commit 2f79b9fd26e1 · 2019-02-19T18:23:06.000-08:00
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -29,7 +29,7 @@ func init() {
 		// py.MustNewMethod("callable", builtin_callable, 0, callable_doc),
 		py.MustNewMethod("chr", builtin_chr, 0, chr_doc),
 		py.MustNewMethod("compile", builtin_compile, 0, compile_doc),
-		// py.MustNewMethod("delattr", builtin_delattr, 0, delattr_doc),
+		py.MustNewMethod("delattr", builtin_delattr, 0, delattr_doc),
 		// py.MustNewMethod("dir", builtin_dir, 0, dir_doc),
 		py.MustNewMethod("divmod", builtin_divmod, 0, divmod_doc),
 		py.MustNewMethod("eval", py.InternalMethodEval, 0, eval_doc),
@@ -44,7 +44,7 @@ func init() {
 		// py.MustNewMethod("input", builtin_input, 0, input_doc),
 		// py.MustNewMethod("isinstance", builtin_isinstance, 0, isinstance_doc),
 		// py.MustNewMethod("issubclass", builtin_issubclass, 0, issubclass_doc),
-		// py.MustNewMethod("iter", builtin_iter, 0, iter_doc),
+		py.MustNewMethod("iter", builtin_iter, 0, iter_doc),
 		py.MustNewMethod("len", builtin_len, 0, len_doc),
 		py.MustNewMethod("locals", py.InternalMethodLocals, 0, locals_doc),
 		py.MustNewMethod("max", builtin_max, 0, max_doc),
@@ -633,6 +633,27 @@ func source_as_string(cmd py.Object, funcname, what string /*, PyCompilerFlags *
 	// 	return nil;
 }
 
+const delattr_doc = `Deletes the named attribute from the given object.
+
+delattr(x, 'y') is equivalent to  "del x.y"
+`
+
+func builtin_delattr(self py.Object, args py.Tuple) (py.Object, error) {
+	var v py.Object
+	var name py.Object
+
+	err := py.UnpackTuple(args, nil, "delattr", 2, 2, &v, &name)
+	if err != nil {
+		return nil, err
+	}
+
+	err = py.DeleteAttr(v, name)
+	if err != nil {
+		return nil, err
+	}
+	return py.None, nil
+}
+
 const compile_doc = `compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
 
 Compile the source string (a Python module, statement or expression)
@@ -762,6 +783,39 @@ object.
 The globals and locals are dictionaries, defaulting to the current
 globals and locals.  If only globals is given, locals defaults to it.`
 
+const iter_doc = `iter(iterable) -> iterator
+iter(callable, sentinel) -> iterator
+
+Get an iterator from an object.  In the first form, the argument must
+supply its own iterator, or be a sequence.
+In the second form, the callable is called until it returns the sentinel.
+`
+
+func builtin_iter(self py.Object, args py.Tuple) (py.Object, error) {
+	nArgs := len(args)
+	if nArgs < 1 {
+		return nil, py.ExceptionNewf(py.TypeError,
+			"iter expected at least 1 arguments, got %d",
+			nArgs)
+	} else if nArgs > 2 {
+		return nil, py.ExceptionNewf(py.TypeError,
+			"iter expected at most 2 arguments, got %d",
+			nArgs)
+	}
+
+	v := args[0]
+	if nArgs == 1 {
+		return py.Iter(v)
+	}
+	_, ok := v.(*py.Function)
+	sentinel := args[1]
+	if !ok {
+		return nil, py.ExceptionNewf(py.TypeError,
+			"iter(v, w): v must be callable")
+	}
+	return py.NewCallIterator(v, sentinel), nil
+}
+
 // For code see vm/builtin.go
 
 const len_doc = `len(object) -> integer
diff --git a/builtin/tests/builtin.py b/builtin/tests/builtin.py
@@ -132,6 +132,50 @@ def func(p):
     ok = True
 assert ok, "ValueError not raised"
 
+doc="iter"
+cnt = 0
+def f():
+    global cnt
+    cnt += 1
+    return cnt
+
+l = list(iter(f,20))
+assert len(l) == 19
+for idx, v in enumerate(l):
+    assert idx + 1 == v
+
+words1 = ['g', 'p', 'y', 't', 'h', 'o', 'n']
+words2 = list(iter(words1))
+for w1, w2 in zip(words1, words2):
+    assert w1 == w2
+
+ok = False
+try:
+    iter()
+except TypeError:
+    ok = True
+finally:
+    assert ok, "TypeError not raised"
+    ok = False
+
+try:
+    l = [1, 2, 3]
+    iter(l, 2)
+except TypeError:
+    ok = True
+finally:
+    assert ok, "TypeError not raised"
+    ok = False
+
+try:
+    iter(f, 2, 3)
+except TypeError:
+    ok = True
+finally:
+    assert ok, "TypeError not raised"
+    ok = False
+
+
 doc="next no default"
 def gen():
     yield 1
@@ -256,6 +300,15 @@ class C: pass
 setattr(c, "potato", "spud")
 assert getattr(c, "potato") == "spud"
 assert c.potato == "spud"
+delattr(c, "potato")
+assert not hasattr(c, "potato")
+ok = False
+try:
+    delattr(c, "potato")
+except AttributeError as e:
+    ok = True
+finally:
+    assert ok
 
 doc="sum"
 assert sum([1,2,3]) == 6
diff --git a/py/call_iterator.go b/py/call_iterator.go
@@ -0,0 +1,51 @@
+// 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.
+
+// CallIterator objects
+
+package py
+
+// A python CallIterator object
+type CallIterator struct {
+	callable Object
+	sentinel Object
+}
+
+var CallIteratorType = NewType("callable_iterator", "callable_iterator type")
+
+// Type of this object
+func (o *CallIterator) Type() *Type {
+	return CallIteratorType
+}
+
+func (cit *CallIterator) M__iter__() (Object, error) {
+	return cit, nil
+}
+
+// Get next one from the iteration
+func (cit *CallIterator) M__next__() (Object, error) {
+	value, err := Call(cit.callable, nil, nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if value == cit.sentinel {
+		return nil, StopIteration
+	}
+
+	return value, nil
+}
+
+// Define a new CallIterator
+func NewCallIterator(callable Object, sentinel Object) *CallIterator {
+	c := &CallIterator{
+		callable: callable,
+		sentinel: sentinel,
+	}
+	return c
+}
+
+// Check interface is satisfied
+var _ I_iterator = (*CallIterator)(nil)
diff --git a/py/classmethod.go b/py/classmethod.go
@@ -44,7 +44,9 @@ func (c *ClassMethod) GetDict() StringDict {
 
 // ClassMethodNew
 func ClassMethodNew(metatype *Type, args Tuple, kwargs StringDict) (res Object, err error) {
-	c := &ClassMethod{}
+	c := &ClassMethod{
+		Dict: make(StringDict),
+	}
 	err = UnpackTuple(args, kwargs, "classmethod", 1, 1, &c.Callable)
 	if err != nil {
 		return nil, err
diff --git a/py/function.go b/py/function.go
@@ -84,6 +84,7 @@ func NewFunction(code *Code, globals StringDict, qualname string) *Function {
 		Name:     code.Name,
 		Doc:      doc,
 		Module:   module,
+		Dict:     make(StringDict),
 	}
 }
 
@@ -193,10 +194,6 @@ func init() {
 			f.Dict = dict
 			return nil
 		},
-		Fdel: func(self Object) error {
-			self.(*Function).Dict = nil
-			return nil
-		},
 	}
 	FunctionType.Dict["__name__"] = &Property{
 		Fget: func(self Object) (Object, error) {
diff --git a/py/staticmethod.go b/py/staticmethod.go
@@ -41,7 +41,9 @@ func (c *StaticMethod) GetDict() StringDict {
 
 // StaticMethodNew
 func StaticMethodNew(metatype *Type, args Tuple, kwargs StringDict) (res Object, err error) {
-	c := &StaticMethod{}
+	c := &StaticMethod{
+		Dict: make(StringDict),
+	}
 	err = UnpackTuple(args, kwargs, "staticmethod", 1, 1, &c.Callable)
 	if err != nil {
 		return nil, err
diff --git a/py/tests/classmethod.py b/py/tests/classmethod.py
@@ -0,0 +1,19 @@
+# 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.
+
+doc="classmethod"
+
+class A:
+    @classmethod
+    def fn(cls, p):
+        assert cls is A
+        return p+1
+
+a = A()
+assert a.fn(1) == 2
+
+a.x = 3
+assert a.x == 3
+
+doc="finished"
diff --git a/py/tests/function.py b/py/tests/function.py
@@ -0,0 +1,130 @@
+# 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.
+
+doc="function"
+
+def fn(p):
+    "docstring"
+    return p+1
+
+assert fn(1) == 2
+
+# FIXME this doesn't work yet
+#assert fn.__doc__ == "docstring"
+#fn.__doc__ = "hello"
+#assert fn.__doc__ == "hello"
+
+assert str(type(fn)) == "<class 'function'>"
+
+fn.x = 3
+assert fn.x == 3
+
+def f2(p):
+    return p+2
+
+doc="check __code__"
+fn.__code__ = f2.__code__
+assert fn(1) == 3
+try:
+    fn.__code__ = "bad"
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+
+doc="check __defaults__"
+def f3(p=2):
+    return p
+assert f3.__defaults__ == (2,)
+assert f3() == 2
+f3.__defaults__ = (10,)
+assert f3() == 10
+assert f3.__defaults__ == (10,)
+try:
+    f3.__defaults__ = "bad"
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+del f3.__defaults__
+assert f3.__defaults__ == None or f3.__defaults__ == ()
+
+doc="check __kwdefaults__"
+def f4(*, b=2):
+    return b
+assert f4.__kwdefaults__ == {"b":2}
+assert f4() == 2
+f4.__kwdefaults__ = {"b":10}
+assert f4() == 10
+assert f4.__kwdefaults__ == {"b":10}
+try:
+    f4.__kwdefaults__ = "bad"
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+del f4.__kwdefaults__
+assert f4.__kwdefaults__ == None or f4.__kwdefaults__ == {}
+
+doc="check __annotations__"
+def f5(a: "potato") -> "sausage":
+    pass
+assert f5.__annotations__ == {'a': 'potato', 'return': 'sausage'}
+f5.__annotations__ = {'a': 'potato', 'return': 'SAUSAGE'}
+assert f5.__annotations__ == {'a': 'potato', 'return': 'SAUSAGE'}
+try:
+    f5.__annotations__ = "bad"
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+del f5.__annotations__
+assert f5.__annotations__ == None or f5.__annotations__ == {}
+
+doc="check __dict__"
+def f6():
+    pass
+assert f6.__dict__ == {}
+f6.__dict__ = {'a': 'potato'}
+assert f6.__dict__ == {'a': 'potato'}
+try:
+    f6.__dict__ = "bad"
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+try:
+    del f6.__dict__
+except (TypeError, AttributeError):
+    pass
+else:
+    assert False, "Error not raised"
+
+doc="check __name__"
+def f7():
+    pass
+assert f7.__name__ == "f7"
+f7.__name__ = "new_name"
+assert f7.__name__ == "new_name"
+try:
+    f7.__name__ = 1
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+
+doc="check __qualname__"
+def f8():
+    pass
+assert f8.__qualname__ == "f8"
+f8.__qualname__ = "new_qualname"
+assert f8.__qualname__ == "new_qualname"
+try:
+    f8.__qualname__ = 1
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
+
+doc="finished"
diff --git a/py/tests/iter.py b/py/tests/iter.py
diff --git a/py/tests/staticmethod.py b/py/tests/staticmethod.py

Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,7 @@ func NewFunction(code Code, globals StringDict, qualname string) Function {`
`84`	`84`	`Name: code.Name,`
`85`	`85`	`Doc: doc,`
`86`	`86`	`Module: module,`
	`87`	`+ Dict: make(StringDict),`
`87`	`88`	`}`
`88`	`89`	`}`
`89`	`90`
`@@ -193,10 +194,6 @@ func init() {`
`193`	`194`	`f.Dict = dict`
`194`	`195`	`return nil`
`195`	`196`	`},`
`196`		`- Fdel: func(self Object) error {`
`197`		`- self.(*Function).Dict = nil`
`198`		`- return nil`
`199`		`- },`
`200`	`197`	`}`
`201`	`198`	`FunctionType.Dict["__name__"] = &Property{`
`202`	`199`	`Fget: func(self Object) (Object, error) {`