go-python · drew-512 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021
diff --git a/ast/asdl_go.py b/ast/asdl_go.py
diff --git a/ast/asttest.py b/ast/asttest.py
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -162,7 +162,17 @@ func init() {
 		"Warning":                   py.Warning,
 		"ZeroDivisionError":         py.ZeroDivisionError,
 	}
-	py.NewModule("builtins", builtin_doc, methods, globals)
+
+	py.RegisterModule(&py.ModuleImpl{
+		Info: py.ModuleInfo{
+			Name:  "builtins",
+			Doc:   builtin_doc,
+			Flags: py.ShareModule,
+		},
+		Methods: methods,
+		Globals: globals,
+	})
+
 }
 
 const print_doc = `print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)
@@ -178,18 +188,22 @@ func builtin_print(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Obje
 	var (
 		sepObj py.Object = py.String(" ")
 		endObj py.Object = py.String("\n")
-		file   py.Object = py.MustGetModule("sys").Globals["stdout"]
 		flush  py.Object
 	)
+	sysModule, err := self.(*py.Module).Context.GetModule("sys")
+	if err != nil {
+		return nil, err
+	}
+	stdout := sysModule.Globals["stdout"]
 	kwlist := []string{"sep", "end", "file", "flush"}
-	err := py.ParseTupleAndKeywords(nil, kwargs, "|ssOO:print", kwlist, &sepObj, &endObj, &file, &flush)
+	err = py.ParseTupleAndKeywords(nil, kwargs, "|ssOO:print", kwlist, &sepObj, &endObj, &stdout, &flush)
 	if err != nil {
 		return nil, err
 	}
 	sep := sepObj.(py.String)
 	end := endObj.(py.String)
 
-	write, err := py.GetAttrString(file, "write")
+	write, err := py.GetAttrString(stdout, "write")
 	if err != nil {
 		return nil, err
 	}
@@ -219,7 +233,7 @@ func builtin_print(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Obje
 	}
 
 	if shouldFlush, _ := py.MakeBool(flush); shouldFlush == py.True {
-		fflush, err := py.GetAttrString(file, "flush")
+		fflush, err := py.GetAttrString(stdout, "flush")
 		if err == nil {
 			return py.Call(fflush, nil, nil)
 		}
@@ -449,7 +463,7 @@ func builtin___build_class__(self py.Object, args py.Tuple, kwargs py.StringDict
 	}
 	// fmt.Printf("Calling %v with %v and %v\n", fn.Name, fn.Globals, ns)
 	// fmt.Printf("Code = %#v\n", fn.Code)
-	cell, err = py.VmRun(fn.Globals, ns, fn.Code, fn.Closure)
+	cell, err = fn.Context.RunCode(fn.Code, fn.Globals, ns, fn.Closure)
 	if err != nil {
 		return nil, err
 	}
@@ -749,9 +763,9 @@ func builtin_compile(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Ob
 		return nil, py.ExceptionNewf(py.ValueError, "compile(): invalid optimize value")
 	}
 
-	if dont_inherit.(py.Int) != 0 {
-		// PyEval_MergeCompilerFlags(&cf)
-	}
+	// if dont_inherit.(py.Int) != 0 {
+	// 	PyEval_MergeCompilerFlags(&cf)
+	// }
 
 	// switch string(startstr.(py.String)) {
 	// case "exec":
@@ -782,7 +796,7 @@ func builtin_compile(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Ob
 		return nil, err
 	}
 	// result = py.CompileStringExFlags(str, filename, start[mode], &cf, optimize)
-	result, err = compile.Compile(str, string(filename.(py.String)), string(startstr.(py.String)), int(supplied_flags.(py.Int)), dont_inherit.(py.Int) != 0)
+	result, err = compile.Compile(str, string(filename.(py.String)), py.CompileMode(startstr.(py.String)), int(supplied_flags.(py.Int)), dont_inherit.(py.Int) != 0)
 	if err != nil {
 		return nil, err
 	}
@@ -882,9 +896,8 @@ or ... etc.
 `
 
 func isinstance(obj py.Object, classOrTuple py.Object) (py.Bool, error) {
-	switch classOrTuple.(type) {
+	switch class_tuple := classOrTuple.(type) {
 	case py.Tuple:
-		var class_tuple = classOrTuple.(py.Tuple)
 		for idx := range class_tuple {
 			res, _ := isinstance(obj, class_tuple[idx])
 			if res {

diff --git a/compile/compile.go b/compile/compile.go
@@ -89,33 +89,36 @@ func init() {
 	py.Compile = Compile
 }
 
-// Compile(source, filename, mode, flags, dont_inherit) -> code object
+// Compile(src, srcDesc, compileMode, flags, dont_inherit) -> code object
 //
 // Compile the source string (a Python module, statement or expression)
-// into a code object that can be executed by exec() or eval().
-// The filename will be used for run-time error messages.
-// The mode must be 'exec' to compile a module, 'single' to compile a
-// single (interactive) statement, or 'eval' to compile an expression.
+// into a code object that can be executed.
+//
+// srcDesc is used for run-time error messages and is typically a file system pathname,
+//
+// See py.CompileMode for compile mode options.
+//
 // The flags argument, if present, controls which future statements influence
 // the compilation of the code.
+//
 // The dont_inherit argument, if non-zero, stops the compilation inheriting
 // the effects of any future statements in effect in the code calling
 // compile; if absent or zero these statements do influence the compilation,
 // in addition to any features explicitly specified.
-func Compile(str, filename, mode string, futureFlags int, dont_inherit bool) (py.Object, error) {
+func Compile(src, srcDesc string, mode py.CompileMode, futureFlags int, dont_inherit bool) (*py.Code, error) {
 	// Parse Ast
-	Ast, err := parser.ParseString(str, mode)
+	Ast, err := parser.ParseString(src, mode)
 	if err != nil {
 		return nil, err
 	}
 	// Make symbol table
-	SymTable, err := symtable.NewSymTable(Ast, filename)
+	SymTable, err := symtable.NewSymTable(Ast, srcDesc)
 	if err != nil {
 		return nil, err
 	}
 	c := newCompiler(nil, compilerScopeModule)
-	c.Filename = filename
-	err = c.compileAst(Ast, filename, futureFlags, dont_inherit, SymTable)
+	c.Filename = srcDesc
+	err = c.compileAst(Ast, srcDesc, futureFlags, dont_inherit, SymTable)
 	if err != nil {
 		return nil, err
 	}
@@ -1342,7 +1345,6 @@ func (c *compiler) NameOp(name string, ctx ast.ExprContext) {
 		default:
 			panic("NameOp: ctx invalid for name variable")
 		}
-		break
 	}
 	if op == 0 {
 		panic("NameOp: Op not set")

diff --git a/compile/compile_data_test.go b/compile/compile_data_test.go
@@ -12,7 +12,7 @@ import (
 
 var compileTestData = []struct {
 	in            string
-	mode          string // exec, eval or single
+	mode          py.CompileMode
 	out           *py.Code
 	exceptionType *py.Type
 	errString     string

diff --git a/compile/compile_test.go b/compile/compile_test.go
@@ -163,7 +163,7 @@ func EqCode(t *testing.T, name string, a, b *py.Code) {
 func TestCompile(t *testing.T) {
 	for _, test := range compileTestData {
 		// log.Printf(">>> %s", test.in)
-		codeObj, err := Compile(test.in, "<string>", test.mode, 0, true)
+		code, err := Compile(test.in, "<string>", test.mode, 0, true)
 		if err != nil {
 			if test.exceptionType == nil {
 				t.Errorf("%s: Got exception %v when not expecting one", test.in, err)
@@ -196,17 +196,12 @@ func TestCompile(t *testing.T) {
 			}
 		} else {
 			if test.out == nil {
-				if codeObj != nil {
-					t.Errorf("%s: Expecting nil *py.Code but got %T", test.in, codeObj)
+				if code != nil {
+					t.Errorf("%s: Expecting nil *py.Code but got %T", test.in, code)
 				}
 			} else {
-				code, ok := codeObj.(*py.Code)
-				if !ok {
-					t.Errorf("%s: Expecting *py.Code but got %T", test.in, codeObj)
-				} else {
-					//t.Logf("Testing %q", test.in)
-					EqCode(t, test.in, test.out, code)
-				}
+				//t.Logf("Testing %q", test.in)
+				EqCode(t, test.in, test.out, code)
 			}
 		}
 	}

diff --git a/compile/diffdis.py b/compile/diffdis.py
diff --git a/compile/make_compile_test.py b/compile/make_compile_test.py
diff --git a/examples/multi-ctx/main.go b/examples/multi-ctx/main.go
@@ -0,0 +1,138 @@
+// Copyright 2022 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 main
+
+import (
+	"fmt"
+	"log"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	// This initializes gpython for runtime execution and is critical.
+	// It defines forward-declared symbols and registers native built-in modules, such as sys and time.
+	_ "github.com/go-python/gpython/modules"
+
+	// This is the primary import for gpython.
+	// It contains all symbols needed to fully compile and run python.
+	"github.com/go-python/gpython/py"
+)
+
+func main() {
+
+	// The total job count implies a fixed amount of work.
+	// The number of workers is how many py.Context (in concurrent goroutines) to pull jobs off the queue.
+	// One worker does all the work serially while N number of workers will (ideally) divides up.
+	totalJobs := 20
+
+	for i := 0; i < 10; i++ {
+		numWorkers := i + 1
+		elapsed := RunMultiPi(numWorkers, totalJobs)
+		fmt.Printf("=====> %2d worker(s): %v\n\n", numWorkers, elapsed)
+
+		// Give each trial a fresh start
+		runtime.GC()
+	}
+
+}
+
+var jobScript = `
+pi = chud.pi_chudnovsky_bs(numDigits)
+last_5 = pi % 100000
+print("%s: last 5 digits of %d is %d (job #%0d)" % (WORKER_ID, numDigits, last_5, jobID))
+`
+
+var jobSrcTemplate = `
+import pi_chudnovsky_bs as chud
+
+WORKER_ID = "{{WORKER_ID}}"
+
+print("%s ready!" % (WORKER_ID))
+`
+
+type worker struct {
+	name string
+	ctx  py.Context
+	main *py.Module
+	job  *py.Code
+}
+
+func (w *worker) compileTemplate(pySrc string) {
+	pySrc = strings.Replace(pySrc, "{{WORKER_ID}}", w.name, -1)
+
+	mainImpl := py.ModuleImpl{
+		CodeSrc: pySrc,
+	}
+
+	var err error
+	w.main, err = w.ctx.ModuleInit(&mainImpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func RunMultiPi(numWorkers, numTimes int) time.Duration {
+	var workersRunning sync.WaitGroup
+
+	fmt.Printf("Starting %d worker(s) to calculate %d jobs...\n", numWorkers, numTimes)
+
+	jobPipe := make(chan int)
+	go func() {
+		for i := 0; i < numTimes; i++ {
+			jobPipe <- i + 1
+		}
+		close(jobPipe)
+	}()
+
+	// Note that py.Code can be shared (accessed concurrently) since it is an inherently read-only object
+	jobCode, err := py.Compile(jobScript, "<jobScript>", py.ExecMode, 0, true)
+	if err != nil {
+		log.Fatal("jobScript failed to comple")
+	}
+
+	workers := make([]worker, numWorkers)
+	for i := 0; i < numWorkers; i++ {
+
+		opts := py.DefaultContextOpts()
+
+		// Make sure our import statement will find pi_chudnovsky_bs
+		opts.SysPaths = append(opts.SysPaths, "..")
+
+		workers[i] = worker{
+			name: fmt.Sprintf("Worker #%d", i+1),
+			ctx:  py.NewContext(opts),
+			job:  jobCode,
+		}
+
+		workersRunning.Add(1)
+	}
+
+	startTime := time.Now()
+
+	for i := range workers {
+		w := workers[i]
+		go func() {
+
+			// Compiling can be concurrent since there is no associated py.Context
+			w.compileTemplate(jobSrcTemplate)
+
+			for jobID := range jobPipe {
+				numDigits := 100000
+				if jobID%2 == 0 {
+					numDigits *= 10
+				}
+				py.SetAttrString(w.main.Globals, "numDigits", py.Int(numDigits))
+				py.SetAttrString(w.main.Globals, "jobID", py.Int(jobID))
+				w.ctx.RunCode(jobCode, w.main.Globals, w.main.Globals, nil)
+			}
+			workersRunning.Done()
+		}()
+	}
+
+	workersRunning.Wait()
+
+	return time.Since(startTime)
+}
diff --git a/examples/pystone.py b/examples/pystone.py
diff --git a/importlib/importlib.go b/importlib/importlib.go
@@ -7,15 +7,18 @@
 package py
 
 import (
-	"log"
-
-	"github.com/go-python/gpython/marshal"
+	"github.com/go-python/gpython/py"
 )
 
 // Load the frozen module
 func init() {
-	_, err := marshal.LoadFrozenModule("importlib", data)
-	log.Fatalf("Failed to load importlib: %v", err)
+
+	py.RegisterModule(&py.ModuleImpl{
+		Info: py.ModuleInfo{
+			Name:  "importlib",
+		},
+		CodeBuf: data,
+	})
 }
 
 // Auto-generated by Modules/_freeze_importlib.c