fixed module loader conflict with package Loader

Author: Pavlo

index.html

@@ -53,7 +53,7 @@ <h4>JSPython development console</h4>
     resultEditor.session.setMode("ace/mode/json");
 
     const interpreter = jspython.jsPython();
-    console.log({interpreter});
+    console.log({ interpreter });
 
     function tokenize() {
       tokenizer = (s) => console.log(`tokens => ${s}`, interpreter().tokenize(s))
@@ -95,14 +95,14 @@ <h4>JSPython development console</h4>
 
         interpreter.registerModuleLoader((path => {
           return Promise.resolve(`
+            from 'service' import add
+
             def multiply(x, y):
                 x * y
 
             def func1(x, y):
-              if y == null:
-                y = 77
-
-              multiply(x, y) + someNumber
+              print('++>>>', getExecutionContext())
+              multiply(x, y) + add(x, y)
             
             name = 'test'
             someNumber = 55
@@ -111,6 +111,16 @@ <h4>JSPython development console</h4>
           `);
         }));
 
+        interpreter.registerPackagesLoader(path =>
+          (
+            path === 'service' ? {
+              add: (x, y) => x + y,
+              remove: (x, y) => x - y,
+              times: (x, y) => x * y,
+            } 
+            : null
+          )
+        );
         const scope = {
           Math,
           errorFunc: p => {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.0.18",
+  "version": "2.1.1",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",

src/evaluator/evaluatorAsync.ts

@@ -18,14 +18,14 @@ import { BlockContext, cloneContext, Scope } from './scope';
 export class EvaluatorAsync {
 
     private moduleParser: (modulePath: string) => Promise<AstBlock> = () => Promise.reject('Module parser is not registered!');
-    private blockContextFactory?: (modulePath: string) => BlockContext;
+    private blockContextFactory?: (modulePath: string, ast: AstBlock) => BlockContext;
 
     registerModuleParser(moduleParser: (modulePath: string) => Promise<AstBlock>): EvaluatorAsync {
         this.moduleParser = moduleParser;
         return this;
     }
 
-    registerBlockContextFactory(blockContextFactory: (modulePath: string) => BlockContext): EvaluatorAsync {
+    registerBlockContextFactory(blockContextFactory: (modulePath: string, ast: AstBlock) => BlockContext): EvaluatorAsync {
         this.blockContextFactory = blockContextFactory;
         return this;
     }
@@ -51,12 +51,17 @@ export class EvaluatorAsync {
             if (node.type === 'import') {
                 const importNode = node as ImportNode;
 
+                if(!importNode.module.name.startsWith('/') /* || !importNode.module.name.endsWith('.jspy')*/){
+                    // it is not JSPY imort. It is JS and should be handled externally
+                    continue;
+                }
+
                 if (typeof this.blockContextFactory !== 'function') {
                     throw new Error('blockContextFactory is not initialized');
                 }
 
                 const moduleAst = await this.moduleParser(importNode.module.name)
-                const moduleBlockContext = this.blockContextFactory(importNode.module.name);
+                const moduleBlockContext = this.blockContextFactory(importNode.module.name, moduleAst);
                 await this.evalBlockAsync(moduleAst, moduleBlockContext)
 
                 blockContext.blockScope.set(importNode.module.alias || this.defaultModuleName(importNode.module.name), moduleBlockContext.blockScope.getScope())

src/initialScope.ts

@@ -2,7 +2,7 @@ import { parseDatetimeOrNull } from "./common/utils";
 
 export const INITIAL_SCOPE = {
     jsPython(): string {
-        return [`JSPython v2.0.17`, "(c) 2021 FalconSoft Ltd. All rights reserved."].join('\n')
+        return [`JSPython v2.1.1`, "(c) 2021 FalconSoft Ltd. All rights reserved."].join('\n')
     },
     dateTime: (str: number | string | any = null) => parseDatetimeOrNull(str) || new Date(),
     range: range,

src/interpreter.spec.ts

@@ -676,5 +676,42 @@ describe('Interpreter', () => {
     expect(res).toBe(316);
   });
 
+  it('Import with package loader', async () => {
+    const interpreter = Interpreter.create();
+
+    interpreter.registerPackagesLoader(path =>
+      (
+        path === 'service' ? {
+          add: (x, y) => x + y,
+          remove: (x, y) => x - y,
+          times: (x, y) => x * y,
+        } 
+        : null
+      )
+    );    
+
+    interpreter.registerModuleLoader((path => {
+      return Promise.resolve(`
+        from 'service' import add
+
+        def multiply(x, y):
+            x * y
+
+        def func1(x, y):
+          add(x, y) + someNumber
+        
+        someNumber = 55
+      `);
+    }));
+
+    const res = await interpreter.evaluate(`
+    import '/service.jspy' as obj
+
+    return obj.func1(2, 3)
+    `);
+
+    expect(res).toBe(60);
+  });
+
 
 });

src/interpreter.ts

@@ -93,8 +93,16 @@ export class Interpreter {
         this._lastExecutionContext = blockContext.blockScope.getScope();
 
         const result = await evaluator
-            .registerModuleParser(async (modulePath)=> await this.moduleParser(modulePath))
-            .registerBlockContextFactory((moduleName) => ({ moduleName, blockScope: new Scope(scope) }))
+            .registerModuleParser(async (modulePath) => await this.moduleParser(modulePath))
+            .registerBlockContextFactory((moduleName, ast: AstBlock) => {
+                // this line will not be required when we have move package loaders to the evaluator
+                const newContext = this.assignLegacyImportContext(ast, scope);
+
+                const moduleContext = { moduleName, blockScope: new Scope(newContext) }
+                moduleContext.blockScope.set('printExecutionContext', () => console.log(moduleContext.blockScope.getScope()));
+                moduleContext.blockScope.set('getExecutionContext', () => moduleContext.blockScope.getScope());
+                return moduleContext;
+            })
             .evalBlockAsync(ast, blockContext);
 
         if (!entryFunctionName || !entryFunctionName.length) {
@@ -117,7 +125,7 @@ export class Interpreter {
         const ast = this.parse(script, moduleName);
 
         context = (context && typeof context === 'object') ? context : {};
-        context = await this.assignLegacyImportContext(ast, context);
+        context = this.assignLegacyImportContext(ast, context);
 
         const globalScope = {
             ...this.initialScope,
@@ -128,7 +136,7 @@ export class Interpreter {
     }
 
 
-    private async assignLegacyImportContext(ast: AstBlock, context: object): Promise<object> {
+    private assignLegacyImportContext(ast: AstBlock, context: object): Record<string, unknown> {
         const importNodes = ast.body.filter(n => n.type === 'import') as ImportNode[];
 
         const jsImport = importNodes
@@ -140,7 +148,7 @@ export class Interpreter {
             context = { ...context, ...libraries };
         }
 
-        return context;
+        return context as Record<string, unknown>;
     }
 
     registerPackagesLoader(loader: PackageLoader) {