fix(deducer): resolve deducer malfunction with imports in function body

The deducer fails to operate correctly when encountering import statements inside function bodies, attempting to retrieve module symbols from these local scope imports. Since global scope is required for symbol resolution and these imports don't need extraction, the solution is to bypass import statements during the extraction process.

.changeset/slimy-pots-wait.md

@@ -0,0 +1,7 @@
+---
+"@plutolang/pyright-deducer": patch
+---
+
+fix(deducer): resolve deducer malfunction with imports in function body
+
+The deducer fails to operate correctly when encountering import statements inside function bodies, attempting to retrieve module symbols from these local scope imports. Since global scope is required for symbol resolution and these imports don't need extraction, the solution is to bypass import statements during the extraction process.

components/deducers/python-pyright/src/code-extractor.ts

@@ -12,6 +12,8 @@ import {
   FunctionNode,
   ImportAsNode,
   ImportFromAsNode,
+  ImportFromNode,
+  ImportNode,
   IndexNode,
   LambdaNode,
   ListComprehensionForIfNode,
@@ -965,6 +967,16 @@ class OutsideSymbolFinder extends ParseTreeWalker {
     return Array.from(this._envVarNames);
   }
 
+  public override visitImport(node: ImportNode): boolean {
+    // Ignore the import statement. We don't need to extract the imported modules.
+    return false;
+  }
+
+  public override visitImportFrom(node: ImportFromNode): boolean {
+    // Ignore the import-from statement. We don't need to extract the imported modules.
+    return false;
+  }
+
   public override visitName(node: NameNode): boolean {
     if (node !== this.rootNode && !this.shouldIgnore(node)) {
       const symbol = this.typeEvaluator.lookUpSymbolRecursive(node, node.value, false);

components/deducers/python-pyright/src/test/code-extractor.test.ts

@@ -17,6 +17,7 @@ import * as TypeConsts from "../type-consts";
 import { createValueEvaluator } from "../value-evaluator";
 import { CodeSegment, CodeExtractor } from "../code-extractor";
 import { ResourceObjectTracker } from "../resource-object-tracker";
+import { getTextOfNode } from "../text-utils";
 
 const SAMPLES_ROOT = path.join(__dirname, "samples");
 
@@ -325,6 +326,66 @@ foo()
   clean();
 });
 
+describe("Code segment extraction with import statements", () => {
+  const code = `
+def foo1():
+  import pluto_client
+
+def foo2():
+  import pluto_client as pc
+
+def foo3():
+  from pluto_client import Router
+
+def foo4():
+  from pluto_client import Router as R
+
+foo1()
+foo2()
+foo3()
+foo4()
+`;
+  let program: Program;
+  let sourceFile: SourceFile;
+  let clean: () => void;
+  let extractor: CodeExtractor;
+  let fetchedNodes: ParseNode[] = [];
+
+  beforeAll(() => {
+    ({ program, sourceFile, clean } = TestUtils.parseCode(code));
+    ({ extractor } = createTools(program, sourceFile));
+  });
+
+  afterAll(() => clean());
+
+  beforeEach(() => {
+    const walker = new NodeFetcher((node) => {
+      return (
+        node.nodeType === ParseNodeType.Call &&
+        node.leftExpression.nodeType === ParseNodeType.Name &&
+        node.leftExpression.value.startsWith("foo")
+      );
+    });
+    walker.walk(sourceFile.getParseResults()!.parseTree!);
+    fetchedNodes = walker.nodes;
+  });
+
+  test("should fetch 4 nodes", () => {
+    expect(fetchedNodes).toHaveLength(4);
+  });
+
+  for (let i = 0; i < 4; i++) {
+    const caseIdx = i;
+
+    test(`should not throw for foo${caseIdx + 1}`, () => {
+      const callNode = fetchedNodes[caseIdx] as ExpressionNode;
+      expect(() => {
+        extractor.extractExpressionRecursively(callNode, sourceFile);
+      }).not.toThrow();
+    });
+  }
+});
+
 test("should correctly extract the code segment for the closure created within local scope", () => {
   const code = `
 plain_string = "Hello, world"