tighter py.Ctx invocation patterns

go-python · drew-512 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021
commit f71b961f6f9d285b6177deae1caa435b7c59a460
diff --git a/main.go b/main.go
@@ -72,7 +72,7 @@ func main() {
 		cli.RunREPL(replCtx)
 
 	} else {
-		_, err := ctx.RunFile(args[0], py.RunOpts{})
+		err := py.RunFile(ctx, args[0], py.CompileOpts{})
 		if err != nil {
 			py.TracebackDump(err)
 			log.Fatal(err)

diff --git a/py/run.go b/py/run.go
@@ -3,9 +3,9 @@ package py
 type CompileMode string
 
 const (
-	ExecMode   CompileMode = "exec"
-	EvalMode   CompileMode = "eval"
-	SingleMode CompileMode = "single"
+	ExecMode   CompileMode = "exec"   // Compile a module
+	EvalMode   CompileMode = "eval"   // Compile an expression
+	SingleMode CompileMode = "single" // Compile a single (interactive) statement
 )
 
 type RunFlags int32
@@ -21,14 +21,20 @@ const (
 // In general, one creates a py.Ctx (via py.NewCtx) for each concurrent goroutine to be running an interpreter.
 // In other words, ensure that a py.Ctx is never concurrently accessed across goroutines.
 //
-// See BenchmarkCtx() in vm/vm_test.go
+// RunFile() and RunCode() block until code execution is complete.
+// In the future, they will abort early if the parent associated py.Ctx is signaled.
+//
+// See examples/multi-ctx
 type Ctx interface {
 
-	// These each initiate blocking execution.
-	RunCode(code *Code, globals, locals StringDict, closure Tuple) (res Object, err error)
+	// Resolves then compiles (if applicable) the given file system pathname into a py.Code ready to be executed.
+	ResolveAndCompile(pathname string, opts CompileOpts) (CompileOut, error)
+
+	// Creates a new py.Module instance and initializes ModuleImpl's code in the new module (if applicable).
+	ModuleInit(impl *ModuleImpl) (*Module, error)
 
-	// Runs a given file in the given host module.
-	RunFile(runPath string, opts RunOpts) (*Module, error)
+	// RunCode is a lower-level invocation to execute the given py.Code.
+	RunCode(code *Code, globals, locals StringDict, closure Tuple) (result Object, err error)
 
 	// Execution of any of the above will stop when the next opcode runs
 	// @@TODO
@@ -44,8 +50,6 @@ type Ctx interface {
 const (
 	SrcFileExt  = ".py"
 	CodeFileExt = ".pyc"
-
-	DefaultModuleName = "__main__"
 )
 
 type StdLib int32
@@ -57,11 +61,16 @@ const (
 	CoreLibs = Lib_sys | Lib_time
 )
 
-type RunOpts struct {
-	HostModule  *Module // Host module to execute within (if nil, a new module is created)
-	ModuleName  string  // If HostModule == nil, this is the name of the newly created module.  If nil, "__main__" is used.
-	CurDir      string  // If non-nil, this is the path of the current working directory.  If nil, os.Getwd() is used
-	UseSysPaths bool
+type CompileOpts struct {
+	UseSysPaths bool   // If set, sys.path will be used to resolve relative pathnames
+	CurDir      string // If non-nil, this is the path of the current working directory.  If nil, os.Getwd() is used.
+}
+
+type CompileOut struct {
+	SrcPathname string // Resolved pathname the .py file that was compiled (if applicable)
+	PycPathname string // Pathname of the .pyc file read and/or written (if applicable)
+	FileDesc    string // Pathname to be used for a a module's "__file__" attrib
+	Code        *Code  // Read/Output code object ready for execution
 }
 
 // Can be changed during runtime and will \play nice with others using DefaultCtxOpts()
@@ -83,7 +92,7 @@ type CtxOpts struct {
 }
 
 var (
-	// DefaultCtxOpts should be default opts created for py.NewCtx.
+	// DefaultCtxOpts should be the default opts created for py.NewCtx.
 	// Calling this ensure that you future proof you code for suggested/default settings.
 	DefaultCtxOpts = func() CtxOpts {
 		opts := CtxOpts{
@@ -94,10 +103,40 @@ var (
 	}
 
 	// NewCtx is a high-level call to create a new gpython interpreter context.
-	// It allows you specify default settings, sys search paths, and is the foundational object for concurrent interpreter execution.
+	// See type Ctx interface.
 	NewCtx func(opts CtxOpts) Ctx
 
-	// Compile is a high-level call to compile a python buffer into a py.Code object.
+	// Compiles a python buffer into a py.Code object.
 	// Returns a py.Code object or otherwise an error.
-	Compile func(str, filename string, mode CompileMode, flags int, dont_inherit bool) (Object, error)
+	Compile func(src, srcDesc string, mode CompileMode, flags int, dont_inherit bool) (*Code, error)
 )
+
+// Convenience function that resolves then executes the given file pathname in a new module.
+// If moduleName is nil, "__main__" is used
+func RunInNewModule(
+	ctx Ctx,
+	pathname string,
+	opts CompileOpts,
+	moduleName string,
+) (*Module, error) {
+	out, err := ctx.ResolveAndCompile(pathname, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	moduleImpl := ModuleImpl{
+		Info: ModuleInfo{
+			Name:     moduleName,
+			FileDesc: out.FileDesc,
+		},
+		Code: out.Code,
+	}
+
+	return ctx.ModuleInit(&moduleImpl)
+}
+
+// Convenience function that resolves then executes the given file pathname in a new __main__ module
+func RunFile(ctx Ctx, pathname string, opts CompileOpts) error {
+	_, err := RunInNewModule(ctx, pathname, opts, "")
+	return err
+}
diff --git a/repl/repl.go b/repl/repl.go
@@ -39,7 +39,7 @@ type UI interface {
 	Print(string)
 }
 
-// New create a new REPL and initialises the state machine
+// New create a new REPL and initializes the state machine
 func New(ctx py.Ctx) *REPL {
 	if ctx == nil {
 		ctx = py.NewCtx(py.DefaultCtxOpts())
@@ -51,9 +51,11 @@ func New(ctx py.Ctx) *REPL {
 		continuation: false,
 		previous:     "",
 	}
-	r.Module = ctx.Store().NewModule(ctx, py.ModuleInfo{
-		FileDesc: r.prog,
-	}, nil, nil)
+	r.Module, _ = ctx.ModuleInit(&py.ModuleImpl{
+		Info: py.ModuleInfo{
+			FileDesc: r.prog,
+		},
+	})
 	return r
 }
 
@@ -82,7 +84,7 @@ func (r *REPL) Run(line string) {
 	if toCompile == "" {
 		return
 	}
-	obj, err := py.Compile(toCompile+"\n", r.prog, py.SingleMode, 0, true)
+	code, err := py.Compile(toCompile+"\n", r.prog, py.SingleMode, 0, true)
 	if err != nil {
 		// Detect that we should start a continuation line
 		// FIXME detect EOF properly!
@@ -105,7 +107,6 @@ func (r *REPL) Run(line string) {
 		r.term.Print(fmt.Sprintf("Compile error: %v", err))
 		return
 	}
-	code := obj.(*py.Code)
 	_, err = r.Ctx.RunCode(code, r.Module.Globals, r.Module.Globals, nil)
 	if err != nil {
 		py.TracebackDump(err)