@generaltranslation/python-extractor 0.0.0 → 0.1.0

package/dist/extractCalls.js

@@ -65,7 +65,9 @@ async function processCall(callNode, imports, filePath, calls, errors, _warnings
         containsStaticCalls(firstArg, imports)) ||
         (firstArg.type === 'binary_operator' &&
             containsStaticCalls(firstArg, imports)) ||
-        (firstArg.type === 'call' && containsStaticCalls(firstArg, imports));
+        (firstArg.type === 'call' && containsStaticCalls(firstArg, imports)) ||
+        (firstArg.type === 'parenthesized_expression' &&
+            containsStaticCalls(firstArg, imports));
     if (hasStaticHelpers) {
         // Compound expression path: parse into StringNode tree
         const rootNode = callNode.tree?.rootNode;

package/dist/parseStringExpression.js

@@ -1,5 +1,6 @@
 import { PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR } from './constants.js';
 import { resolveFunctionInCurrentFile, resolveFunctionInFile, } from './resolveFunctionVariants.js';
+import { extractImports } from './extractImports.js';
 import { resolveImportPath } from './resolveImport.js';
 import { declareVar } from 'generaltranslation/internal';
 /**
@@ -33,6 +34,16 @@ function hasStaticCallRecursive(node, names) {
  * binary + concatenation, and standalone declare_static calls.
  */
 export async function parseStringExpression(node, ctx) {
+    // Parenthesized expression: unwrap and recurse
+    if (node.type === 'parenthesized_expression') {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && child.type !== '(' && child.type !== ')') {
+                return parseStringExpression(child, ctx);
+            }
+        }
+        return null;
+    }
     // Plain string (no f-string)
     if (node.type === 'string' && !isFString(node)) {
         const content = extractStringContent(node);
@@ -236,25 +247,10 @@ async function resolveStaticBinaryOperator(node, ctx) {
         ctx.errors.push(`${locationStr(node)}: binary operator missing operands`);
         return null;
     }
-    // Check for + operator (tree-sitter may not expose operator as a named field)
-    // Look for a non-expression child that is '+'
-    let isPlus = true;
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child &&
-            child.type !== 'identifier' &&
-            child.type !== 'string' &&
-            child.type !== 'call' &&
-            child.type !== 'binary_operator' &&
-            child.type !== 'conditional_expression' &&
-            child.type !== 'parenthesized_expression') {
-            if (child.text !== '+') {
-                isPlus = false;
-            }
-        }
-    }
-    if (!isPlus) {
-        ctx.errors.push(`${locationStr(node)}: unsupported binary operator in static expression`);
+    // Verify it's a + operator
+    const operator = node.childForFieldName('operator');
+    if (operator && operator.text !== '+') {
+        ctx.errors.push(`${locationStr(node)}: unsupported binary operator "${operator.text}" in static expression`);
         return null;
     }
     const leftNode = await resolveStaticValue(left, ctx);
@@ -351,35 +347,25 @@ async function resolveFunctionCall(callNode, ctx) {
     }
     const funcName = funcNode.text;
     // Expression parser callback for resolving return expressions.
-    // For local functions, use the current context's imports.
-    // For cross-file, build context from the target file's imports.
-    const makeExprParser = (targetCtx) => {
-        return (node, _rootNode) => resolveStaticValue(node, targetCtx);
+    // Receives the actual rootNode and filePath from whichever file
+    // the function is defined in (handles re-exports correctly).
+    const exprParser = (node, targetRootNode, targetFilePath) => {
+        const targetImports = extractImportsFromRoot(targetRootNode, ctx.imports);
+        return resolveStaticValue(node, {
+            rootNode: targetRootNode,
+            imports: targetImports,
+            filePath: targetFilePath,
+            errors: ctx.errors,
+        });
     };
     // Try resolving in current file
-    const localResult = await resolveFunctionInCurrentFile(funcName, ctx.rootNode, makeExprParser(ctx));
+    const localResult = await resolveFunctionInCurrentFile(funcName, ctx.rootNode, ctx.filePath, exprParser);
     if (localResult)
         return localResult;
-    // Try resolving from imports
+    // Try resolving from imports (follows re-export chains automatically)
     const importInfo = findImportForName(funcName, ctx);
     if (importInfo) {
-        // Build a context for the target file
-        const targetCtx = {
-            rootNode: ctx.rootNode, // Will be replaced by the actual target rootNode inside resolveFunctionInFile
-            imports: ctx.imports, // Use caller's imports as fallback
-            filePath: importInfo.filePath,
-            errors: ctx.errors,
-        };
-        const result = await resolveFunctionInFile(importInfo.originalName, importInfo.filePath, async (node, targetRootNode) => {
-            // Build proper context using target file's root and imports
-            const targetImports = extractImportsFromRoot(targetRootNode, ctx.imports);
-            return resolveStaticValue(node, {
-                rootNode: targetRootNode,
-                imports: targetImports,
-                filePath: importInfo.filePath,
-                errors: ctx.errors,
-            });
-        });
+        const result = await resolveFunctionInFile(importInfo.originalName, importInfo.filePath, exprParser);
         if (result)
             return result;
     }
@@ -387,55 +373,27 @@ async function resolveFunctionCall(callNode, ctx) {
     return null;
 }
 /**
- * Extracts import aliases from a target file's root node.
+ * Extracts GT import aliases from a target file's root node.
  * Merges with parent imports for GT package functions (declare_var, etc.)
  * that may not be imported in the target file.
  */
 function extractImportsFromRoot(rootNode, parentImports) {
-    // Import extractImports dynamically to avoid issues
-    const result = [];
-    // Carry over GT package imports from the calling context
-    // (declare_var, declare_static may be used without importing in helper files
-    // if passed through function calls, but the name resolution still needs them)
-    for (const imp of parentImports) {
-        if (imp.originalName === PYTHON_DECLARE_STATIC ||
-            imp.originalName === PYTHON_DECLARE_VAR) {
-            result.push(imp);
-        }
-    }
-    // Also check the target file's own imports for GT functions
-    for (let i = 0; i < rootNode.childCount; i++) {
-        const node = rootNode.child(i);
-        if (!node || node.type !== 'import_from_statement')
-            continue;
-        const moduleName = getModuleName(node);
-        if (!moduleName)
-            continue;
-        for (let j = 0; j < node.childCount; j++) {
-            const child = node.child(j);
-            if (!child)
-                continue;
-            if (child.type === 'dotted_name' && child.text !== moduleName) {
-                result.push({
-                    localName: child.text,
-                    originalName: child.text,
-                    packageName: moduleName,
-                });
-            }
-            else if (child.type === 'aliased_import') {
-                const nameNode = child.childForFieldName('name');
-                const aliasNode = child.childForFieldName('alias');
-                if (nameNode) {
-                    result.push({
-                        localName: aliasNode?.text ?? nameNode.text,
-                        originalName: nameNode.text,
-                        packageName: moduleName,
-                    });
-                }
-            }
+    // Extract GT-only imports from the target file using the same
+    // filtering logic as the main extractImports (filters by GT packages)
+    const fileImports = extractImports(rootNode);
+    // Carry over GT declare_* imports from the calling context
+    // (in case the helper file doesn't import them directly)
+    const parentDeclareImports = parentImports.filter((imp) => imp.originalName === PYTHON_DECLARE_STATIC ||
+        imp.originalName === PYTHON_DECLARE_VAR);
+    // Deduplicate: prefer the target file's own imports over parent's
+    const seen = new Set(fileImports.map((imp) => imp.localName));
+    const merged = [...fileImports];
+    for (const imp of parentDeclareImports) {
+        if (!seen.has(imp.localName)) {
+            merged.push(imp);
         }
     }
-    return result;
+    return merged;
 }
 /**
  * Resolves the argument of a declare_var() call.

package/dist/resolveFunctionVariants.d.ts

@@ -4,17 +4,23 @@ import type { StringNode } from './stringNode.js';
  * Callback to parse a return expression into a StringNode.
  * Provided by the caller so function resolution doesn't need to know about
  * declare_var, declare_static, imports, etc.
+ *
+ * @param node - The return expression AST node
+ * @param rootNode - The root AST node of the file containing the function
+ * @param filePath - The absolute path of the file containing the function
  */
-export type ExpressionParser = (node: SyntaxNode, rootNode: SyntaxNode) => Promise<StringNode | null>;
+export type ExpressionParser = (node: SyntaxNode, rootNode: SyntaxNode, filePath: string) => Promise<StringNode | null>;
 /**
  * Resolves all return values of a function defined in the current file's AST.
  * Uses the provided expression parser to handle complex return expressions
  * (concat, declare_var, etc.).
  */
-export declare function resolveFunctionInCurrentFile(functionName: string, rootNode: SyntaxNode, parseExpr: ExpressionParser): Promise<StringNode | null>;
+export declare function resolveFunctionInCurrentFile(functionName: string, rootNode: SyntaxNode, filePath: string, parseExpr: ExpressionParser): Promise<StringNode | null>;
 /**
  * Resolves all return values of a function defined in an external file.
+ * Follows re-export chains: if the function isn't defined in the target file
+ * but is imported from another module, follows the import to the source.
  * Results are cached by filePath::functionName.
  */
-export declare function resolveFunctionInFile(functionName: string, filePath: string, parseExpr: ExpressionParser): Promise<StringNode | null>;
+export declare function resolveFunctionInFile(functionName: string, filePath: string, parseExpr: ExpressionParser, visited?: Set<string>): Promise<StringNode | null>;
 export declare function clearFunctionCache(): void;

package/dist/resolveFunctionVariants.js

@@ -1,26 +1,36 @@
 import fs from 'node:fs';
 import { getParser } from './parser.js';
+import { resolveImportPath } from './resolveImport.js';
 const crossFileCache = new Map();
 /**
  * Resolves all return values of a function defined in the current file's AST.
  * Uses the provided expression parser to handle complex return expressions
  * (concat, declare_var, etc.).
  */
-export async function resolveFunctionInCurrentFile(functionName, rootNode, parseExpr) {
+export async function resolveFunctionInCurrentFile(functionName, rootNode, filePath, parseExpr) {
     const funcDef = findFunctionDefinition(rootNode, functionName);
     if (!funcDef)
         return null;
-    return extractReturnVariants(funcDef, rootNode, parseExpr);
+    return extractReturnVariants(funcDef, rootNode, filePath, parseExpr);
 }
 /**
  * Resolves all return values of a function defined in an external file.
+ * Follows re-export chains: if the function isn't defined in the target file
+ * but is imported from another module, follows the import to the source.
  * Results are cached by filePath::functionName.
  */
-export async function resolveFunctionInFile(functionName, filePath, parseExpr) {
+export async function resolveFunctionInFile(functionName, filePath, parseExpr, visited) {
     const cacheKey = `${filePath}::${functionName}`;
     if (crossFileCache.has(cacheKey)) {
         return crossFileCache.get(cacheKey);
     }
+    // Prevent infinite re-export loops
+    const visitedSet = visited ?? new Set();
+    if (visitedSet.has(cacheKey)) {
+        crossFileCache.set(cacheKey, null);
+        return null;
+    }
+    visitedSet.add(cacheKey);
     let source;
     try {
         source = fs.readFileSync(filePath, 'utf8');
@@ -35,9 +45,21 @@ export async function resolveFunctionInFile(functionName, filePath, parseExpr) {
         crossFileCache.set(cacheKey, null);
         return null;
     }
-    const result = await resolveFunctionInCurrentFile(functionName, tree.rootNode, parseExpr);
-    crossFileCache.set(cacheKey, result);
-    return result;
+    // Try to find function definition in this file
+    const result = await resolveFunctionInCurrentFile(functionName, tree.rootNode, filePath, parseExpr);
+    if (result) {
+        crossFileCache.set(cacheKey, result);
+        return result;
+    }
+    // Function not defined here — check for re-exports
+    const reExportInfo = findReExport(functionName, tree.rootNode, filePath);
+    if (reExportInfo) {
+        const reResult = await resolveFunctionInFile(reExportInfo.originalName, reExportInfo.filePath, parseExpr, visitedSet);
+        crossFileCache.set(cacheKey, reResult);
+        return reResult;
+    }
+    crossFileCache.set(cacheKey, null);
+    return null;
 }
 /**
  * Finds a top-level function_definition by name in the AST.
@@ -70,7 +92,7 @@ function findFunctionDefinition(rootNode, name) {
  * Extracts all return values from a function body and parses them into StringNodes.
  * Skips nested function definitions.
  */
-async function extractReturnVariants(funcDef, rootNode, parseExpr) {
+async function extractReturnVariants(funcDef, rootNode, filePath, parseExpr) {
     const body = funcDef.childForFieldName('body');
     if (!body)
         return null;
@@ -81,7 +103,7 @@ async function extractReturnVariants(funcDef, rootNode, parseExpr) {
     // Parse each return expression into a StringNode
     const nodes = [];
     for (const expr of returnExprs) {
-        const node = await parseExpr(expr, rootNode);
+        const node = await parseExpr(expr, rootNode, filePath);
         if (node)
             nodes.push(node);
     }
@@ -117,6 +139,62 @@ function collectReturnExpressions(node, results) {
             collectReturnExpressions(child, results);
     }
 }
+/**
+ * Checks if a function name is re-exported from another module in the given file.
+ * e.g., `from static_test import get_gender` makes `get_gender` a re-export.
+ */
+function findReExport(functionName, rootNode, currentFilePath) {
+    for (let i = 0; i < rootNode.childCount; i++) {
+        const node = rootNode.child(i);
+        if (!node || node.type !== 'import_from_statement')
+            continue;
+        const moduleName = getModuleName(node);
+        if (!moduleName)
+            continue;
+        for (let j = 0; j < node.childCount; j++) {
+            const child = node.child(j);
+            if (!child)
+                continue;
+            if (child.type === 'dotted_name' && child.text !== moduleName) {
+                if (child.text === functionName) {
+                    const resolved = resolveImportPath(moduleName, currentFilePath);
+                    if (resolved) {
+                        return { originalName: functionName, filePath: resolved };
+                    }
+                }
+            }
+            else if (child.type === 'aliased_import') {
+                const nameNode = child.childForFieldName('name');
+                const aliasNode = child.childForFieldName('alias');
+                const alias = aliasNode?.text ?? nameNode?.text;
+                if (alias === functionName && nameNode) {
+                    const resolved = resolveImportPath(moduleName, currentFilePath);
+                    if (resolved) {
+                        return { originalName: nameNode.text, filePath: resolved };
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+function getModuleName(importNode) {
+    const moduleNode = importNode.childForFieldName('module_name');
+    if (moduleNode)
+        return moduleNode.text;
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'import')
+            break;
+        if (child.type === 'dotted_name')
+            return child.text;
+        if (child.type === 'relative_import')
+            return child.text;
+    }
+    return undefined;
+}
 export function clearFunctionCache() {
     crossFileCache.clear();
 }

package/dist/resolveImport.js

@@ -34,8 +34,13 @@ function doResolve(moduleName, currentFilePath) {
             baseDir = path.dirname(baseDir);
         }
         const remainder = moduleName.slice(dotCount);
-        if (!remainder)
+        if (!remainder) {
+            // Bare dot import (e.g., "from . import X") — resolve to __init__.py
+            const initPath = path.join(baseDir, '__init__.py');
+            if (fs.existsSync(initPath))
+                return initPath;
             return null;
+        }
         return resolveModulePath(baseDir, remainder);
     }
     // Absolute import: dotted or simple name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@generaltranslation/python-extractor",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Python source code extraction for General Translation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",