@generaltranslation/python-extractor 0.1.3 → 0.1.5

package/dist/constants.d.ts

@@ -2,10 +2,12 @@ export declare const PYTHON_GT_PACKAGES: readonly ["gt_flask", "gt_fastapi"];
 export declare const PYTHON_GT_DEPENDENCIES: readonly ["gt-flask", "gt-fastapi"];
 export declare const PYTHON_T_FUNCTION = "t";
 export declare const PYTHON_MSG_FUNCTION = "msg";
+export declare const PYTHON_DERIVE = "derive";
+/** @deprecated Use PYTHON_DERIVE instead */
 export declare const PYTHON_DECLARE_STATIC = "declare_static";
 export declare const PYTHON_DECLARE_VAR = "declare_var";
-/** These imported names are tracked (translation functions + static helpers) */
-export declare const PYTHON_TRANSLATION_FUNCTIONS: readonly ["t", "msg", "declare_static", "declare_var"];
+/** These imported names are tracked (translation functions + derive helpers) */
+export declare const PYTHON_TRANSLATION_FUNCTIONS: readonly ["t", "msg", "derive", "declare_static", "declare_var"];
 export declare const PYTHON_METADATA_KWARGS: {
     readonly _id: "id";
     readonly _context: "context";

package/dist/constants.js

@@ -2,12 +2,15 @@ export const PYTHON_GT_PACKAGES = ['gt_flask', 'gt_fastapi'];
 export const PYTHON_GT_DEPENDENCIES = ['gt-flask', 'gt-fastapi'];
 export const PYTHON_T_FUNCTION = 't';
 export const PYTHON_MSG_FUNCTION = 'msg';
+export const PYTHON_DERIVE = 'derive';
+/** @deprecated Use PYTHON_DERIVE instead */
 export const PYTHON_DECLARE_STATIC = 'declare_static';
 export const PYTHON_DECLARE_VAR = 'declare_var';
-/** These imported names are tracked (translation functions + static helpers) */
+/** These imported names are tracked (translation functions + derive helpers) */
 export const PYTHON_TRANSLATION_FUNCTIONS = [
     't',
     'msg',
+    'derive',
     'declare_static',
     'declare_var',
 ];

package/dist/extractCalls.js

@@ -1,4 +1,4 @@
-import { PYTHON_METADATA_KWARGS } from './constants.js';
+import { PYTHON_METADATA_KWARGS, PYTHON_DERIVE, PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR, } from './constants.js';
 import { containsStaticCalls, parseStringExpression, } from './parseStringExpression.js';
 import { nodeToStrings } from './stringNode.js';
 import { indexVars } from 'generaltranslation/internal';
@@ -11,10 +11,11 @@ export async function extractCalls(rootNode, imports, filePath) {
     const calls = [];
     const errors = [];
     const warnings = [];
-    // Only track t/msg as translation functions (not declare_static/declare_var)
+    // Only track t/msg as translation functions (not derive/declare_static/declare_var)
     const trackedNames = new Set(imports
-        .filter((imp) => imp.originalName !== 'declare_static' &&
-        imp.originalName !== 'declare_var')
+        .filter((imp) => imp.originalName !== PYTHON_DERIVE &&
+        imp.originalName !== PYTHON_DECLARE_STATIC &&
+        imp.originalName !== PYTHON_DECLARE_VAR)
         .map((imp) => imp.localName));
     if (trackedNames.size === 0)
         return { calls, errors, warnings };
@@ -116,7 +117,7 @@ async function processCall(callNode, imports, filePath, calls, errors, _warnings
     }
     // Check for f-strings (without declare_static/declare_var)
     if (isFString(firstArg)) {
-        errors.push(`${locationStr(callNode)}: translation call uses an f-string — use a plain string literal or declare_static()/declare_var()`);
+        errors.push(`${locationStr(callNode)}: translation call uses an f-string — use a plain string literal or derive()/declare_var()`);
         return;
     }
     const source = extractStringContent(firstArg);

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import type { ExtractionResult } from './types.js';
 export type { ExtractionResult, ExtractionMetadata } from './types.js';
 export type { ImportAlias } from './extractImports.js';
-export { PYTHON_GT_PACKAGES, PYTHON_GT_DEPENDENCIES, PYTHON_T_FUNCTION, PYTHON_MSG_FUNCTION, PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR, PYTHON_TRANSLATION_FUNCTIONS, PYTHON_METADATA_KWARGS, } from './constants.js';
+export { PYTHON_GT_PACKAGES, PYTHON_GT_DEPENDENCIES, PYTHON_T_FUNCTION, PYTHON_MSG_FUNCTION, PYTHON_DERIVE, PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR, PYTHON_TRANSLATION_FUNCTIONS, PYTHON_METADATA_KWARGS, } from './constants.js';
 export declare function extractFromPythonSource(sourceCode: string, filePath: string): Promise<{
     results: ExtractionResult[];
     errors: string[];

package/dist/index.js

@@ -1,7 +1,7 @@
 import { getParser } from './parser.js';
 import { extractImports } from './extractImports.js';
 import { extractCalls } from './extractCalls.js';
-export { PYTHON_GT_PACKAGES, PYTHON_GT_DEPENDENCIES, PYTHON_T_FUNCTION, PYTHON_MSG_FUNCTION, PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR, PYTHON_TRANSLATION_FUNCTIONS, PYTHON_METADATA_KWARGS, } from './constants.js';
+export { PYTHON_GT_PACKAGES, PYTHON_GT_DEPENDENCIES, PYTHON_T_FUNCTION, PYTHON_MSG_FUNCTION, PYTHON_DERIVE, PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR, PYTHON_TRANSLATION_FUNCTIONS, PYTHON_METADATA_KWARGS, } from './constants.js';
 export async function extractFromPythonSource(sourceCode, filePath) {
     const parser = await getParser();
     const tree = parser.parse(sourceCode);

package/dist/parseStringExpression.d.ts

@@ -8,13 +8,13 @@ type ParseContext = {
     errors: string[];
 };
 /**
- * Checks if an expression contains declare_static or declare_var calls.
+ * Checks if an expression contains derive/declare_static or declare_var calls.
  */
 export declare function containsStaticCalls(node: SyntaxNode, imports: ImportAlias[]): boolean;
 /**
  * Parses the first argument of t() into a StringNode tree.
- * Handles: plain strings, f-strings with declare_static/declare_var,
- * binary + concatenation, and standalone declare_static calls.
+ * Handles: plain strings, f-strings with derive/declare_var,
+ * binary + concatenation, and standalone derive calls.
  */
 export declare function parseStringExpression(node: SyntaxNode, ctx: ParseContext): Promise<StringNode | null>;
 export {};

package/dist/parseStringExpression.js

@@ -1,18 +1,24 @@
-import { PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR } from './constants.js';
+import { PYTHON_DERIVE, 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';
 /**
- * Checks if an expression contains declare_static or declare_var calls.
+ * Returns true if the original import name is derive() or declare_static() (deprecated).
+ */
+function isDeriveFunction(originalName) {
+    return (originalName === PYTHON_DERIVE || originalName === PYTHON_DECLARE_STATIC);
+}
+/**
+ * Checks if an expression contains derive/declare_static or declare_var calls.
  */
 export function containsStaticCalls(node, imports) {
-    const staticNames = getStaticImportNames(imports);
+    const staticNames = getDeriveImportNames(imports);
     if (staticNames.size === 0)
         return false;
-    return hasStaticCallRecursive(node, staticNames);
+    return hasDeriveCallRecursive(node, staticNames);
 }
-function hasStaticCallRecursive(node, names) {
+function hasDeriveCallRecursive(node, names) {
     if (node.type === 'call') {
         const funcNode = node.childForFieldName('function');
         if (funcNode &&
@@ -23,15 +29,15 @@ function hasStaticCallRecursive(node, names) {
     }
     for (let i = 0; i < node.childCount; i++) {
         const child = node.child(i);
-        if (child && hasStaticCallRecursive(child, names))
+        if (child && hasDeriveCallRecursive(child, names))
             return true;
     }
     return false;
 }
 /**
  * Parses the first argument of t() into a StringNode tree.
- * Handles: plain strings, f-strings with declare_static/declare_var,
- * binary + concatenation, and standalone declare_static calls.
+ * Handles: plain strings, f-strings with derive/declare_var,
+ * binary + concatenation, and standalone derive calls.
  */
 export async function parseStringExpression(node, ctx) {
     // Parenthesized expression: unwrap and recurse
@@ -59,12 +65,12 @@ export async function parseStringExpression(node, ctx) {
     if (node.type === 'binary_operator') {
         return parseBinaryOperator(node, ctx);
     }
-    // Standalone call: declare_static(...)
+    // Standalone call: derive/declare_static(...)
     if (node.type === 'call') {
         const funcNode = node.childForFieldName('function');
         if (funcNode && funcNode.type === 'identifier') {
             const originalName = getOriginalImportName(funcNode.text, ctx.imports);
-            if (originalName === PYTHON_DECLARE_STATIC) {
+            if (isDeriveFunction(originalName)) {
                 return resolveDeclareStaticArg(node, ctx);
             }
             if (originalName === PYTHON_DECLARE_VAR) {
@@ -77,7 +83,7 @@ export async function parseStringExpression(node, ctx) {
 }
 /**
  * Parses an f-string into a StringNode tree.
- * string_content → text nodes, interpolation → check for declare_static/declare_var
+ * string_content → text nodes, interpolation → check for derive/declare_var
  */
 async function parseFString(node, ctx) {
     const parts = [];
@@ -108,7 +114,7 @@ async function parseFString(node, ctx) {
 }
 /**
  * Parses an interpolation within an f-string.
- * Must be a declare_static() or declare_var() call.
+ * Must be a derive() or declare_var() call.
  */
 async function parseInterpolation(interpNode, ctx) {
     // Find the expression inside the interpolation (skip { and })
@@ -132,7 +138,7 @@ async function parseInterpolation(interpNode, ctx) {
         const funcNode = expr.childForFieldName('function');
         if (funcNode && funcNode.type === 'identifier') {
             const originalName = getOriginalImportName(funcNode.text, ctx.imports);
-            if (originalName === PYTHON_DECLARE_STATIC) {
+            if (isDeriveFunction(originalName)) {
                 return resolveDeclareStaticArg(expr, ctx);
             }
             if (originalName === PYTHON_DECLARE_VAR) {
@@ -140,8 +146,8 @@ async function parseInterpolation(interpNode, ctx) {
             }
         }
     }
-    // Not a declare_static/declare_var call — error
-    ctx.errors.push(`${locationStr(interpNode)}: f-string interpolation must use declare_static() or declare_var(), got "${expr.text}"`);
+    // Not a derive/declare_var call — error
+    ctx.errors.push(`${locationStr(interpNode)}: f-string interpolation must use derive() or declare_var(), got "${expr.text}"`);
     return null;
 }
 /**
@@ -181,13 +187,13 @@ async function parseBinaryOperator(node, ctx) {
     return { type: 'sequence', nodes: parts };
 }
 /**
- * Resolves the argument of a declare_static() call into a StringNode.
+ * Resolves the argument of a derive() call into a StringNode.
  * Handles: string literals, ternary expressions, function calls.
  */
 async function resolveDeclareStaticArg(callNode, ctx) {
     const arg = getFirstPositionalArg(callNode);
     if (!arg) {
-        ctx.errors.push(`${locationStr(callNode)}: declare_static() requires an argument`);
+        ctx.errors.push(`${locationStr(callNode)}: derive() / declare_static() requires an argument`);
         return null;
     }
     return resolveStaticValue(arg, ctx);
@@ -195,7 +201,7 @@ async function resolveDeclareStaticArg(callNode, ctx) {
 /**
  * Resolves a value expression that should produce string variants.
  * Handles: string literals, ternary, function calls, binary concat,
- * and declare_var() calls (nested inside declare_static).
+ * and declare_var() calls (nested inside derive).
  */
 async function resolveStaticValue(node, ctx) {
     // Parenthesized expression: unwrap and recurse
@@ -234,7 +240,7 @@ async function resolveStaticValue(node, ctx) {
         }
         return resolveFunctionCall(node, ctx);
     }
-    ctx.errors.push(`${locationStr(node)}: unsupported declare_static argument type "${node.type}"`);
+    ctx.errors.push(`${locationStr(node)}: unsupported derive() argument type "${node.type}"`);
     return null;
 }
 /**
@@ -383,7 +389,7 @@ function extractImportsFromRoot(rootNode, parentImports) {
     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 ||
+    const parentDeclareImports = parentImports.filter((imp) => isDeriveFunction(imp.originalName) ||
         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));
@@ -457,10 +463,10 @@ function getOriginalImportName(localName, imports) {
     }
     return null;
 }
-function getStaticImportNames(imports) {
+function getDeriveImportNames(imports) {
     const names = new Set();
     for (const imp of imports) {
-        if (imp.originalName === PYTHON_DECLARE_STATIC ||
+        if (isDeriveFunction(imp.originalName) ||
             imp.originalName === PYTHON_DECLARE_VAR) {
             names.add(imp.localName);
         }

package/dist/resolveFunctionVariants.d.ts

@@ -3,7 +3,7 @@ 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.
+ * declare_var, derive, imports, etc.
  *
  * @param node - The return expression AST node
  * @param rootNode - The root AST node of the file containing the function

package/dist/resolveFunctionVariants.js

@@ -141,7 +141,7 @@ function collectReturnExpressions(node, 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.
+ * e.g., `from derive_test import get_gender` makes `get_gender` a re-export.
  */
 function findReExport(functionName, rootNode, currentFilePath) {
     for (let i = 0; i < rootNode.childCount; i++) {

package/dist/stringNode.js

@@ -1,5 +1,5 @@
 // ===== Tree Construction ===== //
-// Used for declare_static / declare_var parsing
+// Used for derive / declare_var parsing
 /**
  * Converts a StringNode tree into all possible string variants.
  * - TextNode → single string

package/dist/types.d.ts

@@ -11,6 +11,6 @@ export type ExtractionMetadata = {
     context?: string;
     maxChars?: number;
     filePaths?: string[];
-    /** Groups related static content variants together (for declareStatic/declare_static) */
+    /** Groups related derive content variants together (for derive/declare_static) */
     staticId?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@generaltranslation/python-extractor",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Python source code extraction for General Translation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,7 +47,7 @@
   "dependencies": {
     "tree-sitter-python": "^0.25.0",
     "web-tree-sitter": "^0.26.6",
-    "generaltranslation": "8.1.17"
+    "generaltranslation": "8.1.19"
   },
   "scripts": {
     "build": "tsc",