Merged master

Author: xarus01

.travis.yml

@@ -13,16 +13,16 @@ matrix:
  allow_failures:
    - go: master
  include:
-   - go: 1.9.x
+   - go: 1.13.x
      env:
        - TAGS="-tags travis"
-   - go: 1.10.x
+       - COVERAGE="-cover"
+   - go: 1.12.x
      env:
        - TAGS="-tags travis"
    - go: 1.11.x
      env:
        - TAGS="-tags travis"
-       - COVERAGE="-cover"
    - go: master
      env:
        - TAGS="-tags travis"

appveyor.yml

@@ -12,7 +12,7 @@ environment:
   matrix:
     - TARGET: x86_64-pc-windows-gnu
 
-stack: go 1.11
+stack: go 1.13
 
 build_script:
   - go get -v -t -race ./...

builtin/builtin.go

@@ -60,7 +60,7 @@ func init() {
 		py.MustNewMethod("repr", builtin_repr, 0, repr_doc),
 		py.MustNewMethod("round", builtin_round, 0, round_doc),
 		py.MustNewMethod("setattr", builtin_setattr, 0, setattr_doc),
-		// py.MustNewMethod("sorted", builtin_sorted, 0, sorted_doc),
+		py.MustNewMethod("sorted", builtin_sorted, 0, sorted_doc),
 		py.MustNewMethod("sum", builtin_sum, 0, sum_doc),
 		// py.MustNewMethod("vars", builtin_vars, 0, vars_doc),
 	}
@@ -88,7 +88,7 @@ func init() {
 		"range":  py.RangeType,
 		// "reversed":       py.ReversedType,
 		"set": py.SetType,
-		// "slice":          py.SliceType,
+		"slice":          py.SliceType,
 		"staticmethod": py.StaticMethodType,
 		"str":          py.StringType,
 		// "super":          py.SuperType,
@@ -1074,3 +1074,28 @@ func builtin_sum(self py.Object, args py.Tuple) (py.Object, error) {
 	}
 	return start, nil
 }
+
+const sorted_doc = `sorted(iterable, key=None, reverse=False)
+
+Return a new list containing all items from the iterable in ascending order.
+
+A custom key function can be supplied to customize the sort order, and the
+reverse flag can be set to request the result in descending order.`
+
+func builtin_sorted(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Object, error) {
+	const funcName = "sorted"
+	var iterable py.Object
+	err := py.UnpackTuple(args, nil, funcName, 1, 1, &iterable)
+	if err != nil {
+		return nil, err
+	}
+	l, err := py.SequenceList(iterable)
+	if err != nil {
+		return nil, err
+	}
+	err = py.SortInPlace(l, kwargs, funcName)
+	if err != nil {
+		return nil, err
+	}
+	return l, nil
+}

builtin/tests/builtin.py

@@ -1,4 +1,4 @@
-# Copyright 2018 The go-python Authors.  All rights reserved.
+# 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.
 
@@ -329,6 +329,50 @@ class C: pass
 finally:
     assert ok
 
+doc="sorted"
+a = [3, 1.1, 1, 2]
+assert sorted(a) == [1, 1.1, 2, 3]
+assert sorted(sorted(a)) == [1, 1.1, 2, 3]
+assert sorted(a, reverse=True) == [3, 2, 1.1, 1]
+assert sorted(a, key=lambda l: l+1) == [1, 1.1, 2, 3]
+s = [2.0, 2, 1, 1.0]
+assert sorted(s, key=lambda l: 0) == [2.0, 2, 1, 1.0]
+assert [type(t) for t in sorted(s, key=lambda l: 0)] == [float, int, int, float]
+assert sorted(s) == [1, 1.0, 2.0, 2]
+assert [type(t) for t in sorted(s)] == [int, float, float, int]
+
+try:
+    sorted([2.0, "abc"])
+except TypeError:
+    pass
+else:
+    assert False
+
+assert sorted([]) == []
+assert sorted([0]) == [0]
+s = [0, 1]
+try:
+    # Sorting a list of len >= 2 with uncallable key must fail on all Python implementations.
+    sorted(s, key=1)
+except TypeError:
+    pass
+else:
+    assert False
+
+try:
+    sorted(1)
+except TypeError:
+    pass
+else:
+    assert False
+
+try:
+    sorted()
+except TypeError:
+    pass
+else:
+    assert False
+
 doc="sum"
 assert sum([1,2,3]) == 6
 assert sum([1,2,3], 3) == 9

py/dict.go

@@ -36,6 +36,30 @@ func init() {
 		}
 		return NewIterator(o), nil
 	}, 0, "items() -> list of D's (key, value) pairs, as 2-tuples")
+
+	StringDictType.Dict["get"] = MustNewMethod("get", func(self Object, args Tuple) (Object, error) {
+		var length = len(args)
+		switch {
+		case length == 0:
+			return nil, ExceptionNewf(TypeError, "%s expected at least 1 arguments, got %d", "items()", length)
+		case length > 2:
+			return nil, ExceptionNewf(TypeError, "%s expected at most 2 arguments, got %d", "items()", length)
+		}
+		sMap := self.(StringDict)
+		if str, ok := args[0].(String); ok {
+			if res, ok := sMap[string(str)]; ok {
+				return res, nil
+			}
+
+			switch length {
+			case 2:
+				return args[1], nil
+			default:
+				return None, nil
+			}
+		}
+		return nil, ExceptionNewf(KeyError, "%v", args[0])
+	}, 0, "gets(key, default) -> If there is a val corresponding to key, return val, otherwise default")
 }
 
 // String to object dictionary

py/float.go

@@ -48,6 +48,9 @@ func FloatNew(metatype *Type, args Tuple, kwargs StringDict) (Object, error) {
 }
 
 func (a Float) M__str__() (Object, error) {
+	if i := int64(a); Float(i) == a {
+		return String(fmt.Sprintf("%d.0", i)), nil
+	}
 	return String(fmt.Sprintf("%g", a)), nil
 }
 
@@ -391,6 +394,20 @@ func (a Float) M__ge__(other Object) (Object, error) {
 	return NotImplemented, nil
 }
 
+// Properties
+func init() {
+	FloatType.Dict["is_integer"] = MustNewMethod("is_integer", func(self Object) (Object, error) {
+		if a, ok := convertToFloat(self); ok {
+			f, err := FloatAsFloat64(a)
+			if err != nil {
+				return nil, err
+			}
+			return NewBool(math.Floor(f) == f), nil
+		}
+		return cantConvert(self, "float")
+	}, 0, "is_integer() -> Return True if the float instance is finite with integral value, and False otherwise.")
+}
+
 // Check interface is satisfied
 var _ floatArithmetic = Float(0)
 var _ conversionBetweenTypes = Float(0)

py/internal.go

@@ -87,10 +87,22 @@ func MakeGoInt64(a Object) (int64, error) {
 //
 // Will raise TypeError if Index can't be run on this object
 func Index(a Object) (Int, error) {
-	A, ok := a.(I__index__)
-	if ok {
+	if A, ok := a.(I__index__); ok {
 		return A.M__index__()
 	}
+
+	if A, ok, err := TypeCall0(a, "__index__"); ok {
+		if err != nil {
+			return 0, err
+		}
+
+		if res, ok := A.(Int); ok {
+			return res, nil
+		}
+
+		return 0, ExceptionNewf(TypeError, "__index__ returned non-int: (type %s)", A.Type().Name)
+	}
+
 	return 0, ExceptionNewf(TypeError, "unsupported operand type(s) for index: '%s'", a.Type().Name)
 }
 

py/list.go

@@ -6,6 +6,10 @@
 
 package py
 
+import (
+	"sort"
+)
+
 var ListType = ObjectType.NewType("list", "list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items", ListNew, nil)
 
 // FIXME lists are mutable so this should probably be struct { Tuple } then can use the sub methods on Tuple
@@ -14,6 +18,7 @@ type List struct {
 }
 
 func init() {
+	// FIXME: all methods should be callable using list.method([], *args, **kwargs) or [].method(*args, **kwargs)
 	ListType.Dict["append"] = MustNewMethod("append", func(self Object, args Tuple) (Object, error) {
 		listSelf := self.(*List)
 		if len(args) != 1 {
@@ -34,6 +39,36 @@ func init() {
 		return NoneType{}, nil
 	}, 0, "extend([item])")
 
+	ListType.Dict["sort"] = MustNewMethod("sort", func(self Object, args Tuple, kwargs StringDict) (Object, error) {
+		const funcName = "sort"
+		var l *List
+		if self == None {
+			// method called using `list.sort([], **kwargs)`
+			var o Object
+			err := UnpackTuple(args, nil, funcName, 1, 1, &o)
+			if err != nil {
+				return nil, err
+			}
+			var ok bool
+			l, ok = o.(*List)
+			if !ok {
+				return nil, ExceptionNewf(TypeError, "descriptor 'sort' requires a 'list' object but received a '%s'", o.Type())
+			}
+		} else {
+			// method called using `[].sort(**kargs)`
+			err := UnpackTuple(args, nil, funcName, 0, 0)
+			if err != nil {
+				return nil, err
+			}
+			l = self.(*List)
+		}
+		err := SortInPlace(l, kwargs, funcName)
+		if err != nil {
+			return nil, err
+		}
+		return NoneType{}, nil
+	}, 0, "sort(key=None, reverse=False)")
+
 }
 
 // Type of this List object
@@ -331,3 +366,122 @@ func (a *List) M__ne__(other Object) (Object, error) {
 	}
 	return False, nil
 }
+
+type sortable struct {
+	l        *List
+	keyFunc  Object
+	reverse  bool
+	firstErr error
+}
+
+type ptrSortable struct {
+	s *sortable
+}
+
+func (s ptrSortable) Len() int {
+	return s.s.l.Len()
+}
+
+func (s ptrSortable) Swap(i, j int) {
+	itemI, err := s.s.l.M__getitem__(Int(i))
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+		return
+	}
+	itemJ, err := s.s.l.M__getitem__(Int(j))
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+		return
+	}
+	_, err = s.s.l.M__setitem__(Int(i), itemJ)
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+	}
+	_, err = s.s.l.M__setitem__(Int(j), itemI)
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+	}
+}
+
+func (s ptrSortable) Less(i, j int) bool {
+	itemI, err := s.s.l.M__getitem__(Int(i))
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+		return false
+	}
+	itemJ, err := s.s.l.M__getitem__(Int(j))
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+		return false
+	}
+
+	if s.s.keyFunc != None {
+		itemI, err = Call(s.s.keyFunc, Tuple{itemI}, nil)
+		if err != nil {
+			if s.s.firstErr == nil {
+				s.s.firstErr = err
+			}
+			return false
+		}
+		itemJ, err = Call(s.s.keyFunc, Tuple{itemJ}, nil)
+		if err != nil {
+			if s.s.firstErr == nil {
+				s.s.firstErr = err
+			}
+			return false
+		}
+	}
+
+	var cmpResult Object
+	if s.s.reverse {
+		cmpResult, err = Lt(itemJ, itemI)
+	} else {
+		cmpResult, err = Lt(itemI, itemJ)
+	}
+
+	if err != nil {
+		if s.s.firstErr == nil {
+			s.s.firstErr = err
+		}
+		return false
+	}
+
+	if boolResult, ok := cmpResult.(Bool); ok {
+		return bool(boolResult)
+	}
+
+	return false
+}
+
+// SortInPlace sorts the given List in place using a stable sort.
+// kwargs can have the keys "key" and "reverse".
+func SortInPlace(l *List, kwargs StringDict, funcName string) error {
+	var keyFunc Object
+	var reverse Object
+	err := ParseTupleAndKeywords(nil, kwargs, "|$OO:"+funcName, []string{"key", "reverse"}, &keyFunc, &reverse)
+	if err != nil {
+		return err
+	}
+	if keyFunc == nil {
+		keyFunc = None
+	}
+	if reverse == nil {
+		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}}
+	sort.Stable(s)
+	return s.s.firstErr
+}