feat: parserName argument

python-argparse-generator/src/__tests__/index.test.ts

@@ -2,20 +2,19 @@ import { argparseCode } from '../index';
 
 test('Basic check of output', () => {
   expect(
-    argparseCode([
-      {
-        name: 'folder',
-        type: 'str',
-        variableName: 'folder',
-        default: '/data',
-        required: true,
-      },
-      { name: 'limit',
-        type: 'int',
-        variableName: 'limit',
-        default: '10',
-        required: true },
-    ]),
+    argparseCode(
+      [
+        {
+          name: 'folder',
+          type: 'str',
+          variableName: 'folder',
+          default: '/data',
+          required: true,
+        },
+        { name: 'limit', type: 'int', variableName: 'limit', default: '10', required: true },
+      ],
+      'parser',
+    ),
   ).toBe(`import argparse
 from typing import Dict, Any
 

python-argparse-generator/src/index.ts

@@ -6,10 +6,10 @@ export type Argument = {
   required: boolean;
 };
 
-function argumentToText(argument: Argument) {
+function argumentToText(argument: Argument, parserName: string) {
   switch (argument.type) {
     case 'bool':
-      return `parser.add_argument("${argument.name}", action="store_${argument.default}")`;
+      return `${parserName}.add_argument("${argument.name}", action="store_${argument.default}")`;
     default:
       let defaultDisplay;
 
@@ -20,18 +20,18 @@ function argumentToText(argument: Argument) {
       }
 
       if (argument.default === undefined) {
-        return `parser.add_argument("${argument.name}", type=${argument.type})`;
+        return `${parserName}.add_argument("${argument.name}", type=${argument.type})`;
       } else {
-        return `parser.add_argument("${argument.name}", type=${argument.type}, default=${defaultDisplay})`;
+        return `${parserName}.add_argument("${argument.name}", type=${argument.type}, default=${defaultDisplay})`;
       }
   }
 }
 
 const argumentToMainParams = (argument: Argument) => `${argument.variableName}: ${argument.type}`;
 
-export const argparseCode = (args: Argument[]) => {
+export const argparseCode = (args: Argument[], parserName: string) => {
   const mainParameters: string[] = args.map((arg) => argumentToMainParams(arg));
-  const argumentsText: string[] = args.map((arg) => argumentToText(arg));
+  const argumentsText: string[] = args.map((arg) => argumentToText(arg, parserName));
   const returnText: string[] = args.map((x) => {
     if (x.type === 'str') {
       return `"${x.variableName}": args.${x.variableName},`;
@@ -50,11 +50,11 @@ def main(${mainParameters.join(', ')}) -> None:
 
 def cli() -> Dict[str, Any]:
     formatter_class = argparse.ArgumentDefaultsHelpFormatter
-    parser = argparse.ArgumentParser(formatter_class=formatter_class)
+    ${parserName} = argparse.ArgumentParser(formatter_class=formatter_class)
 
     ${argumentsText.join('\n    ')}
 
-    args = parser.parse_args()
+    args = ${parserName}.parse_args()
 
     return {${returnText.join('\n            ').slice(0, -1)}}