refactor: centralize definition of Python vendor extensions (#23898)

Mattias-Sehlstedt · web-flow · commit 5d833730d501 · 2026-05-31T22:30:53.000+08:00
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/CodegenConstants.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/CodegenConstants.java
@@ -487,6 +487,7 @@ public static enum ENUM_PROPERTY_NAMING_TYPE {camelCase, PascalCase, snake_case,
     public static final String X_NULLABLE_TYPE = "x-nullable-type";
     public static final String X_CSHARP_VALUE_TYPE = "x-csharp-value-type";
     public static final String X_REGEX = "x-regex";
+    public static final String X_PATTERN = "x-pattern";
     public static final String X_MODIFIERS = "x-modifiers";
     public static final String X_MODIFIER_PREFIX = "x-modifier-";
     public static final String X_MODEL_IS_MUTABLE = "x-model-is-mutable";
@@ -504,4 +505,17 @@ public static enum ENUM_PROPERTY_NAMING_TYPE {camelCase, PascalCase, snake_case,
     public static final String X_NULLABLE = "x-nullable";
     public static final String X_ENUM_VARNAMES = "x-enum-varnames";
     public static final String X_ENUM_DESCRIPTIONS = "x-enum-descriptions";
+    public static final String X_PY_TYPING = "x-py-typing";
+    public static final String X_PY_EXAMPLE = "x-py-example";
+    public static final String X_PY_EXAMPLE_IMPORT = "x-py-example-import";
+    public static final String X_PY_FASTAPI_EXAMPLE = "x-py-fastapi-example";
+    public static final String X_PY_NAME = "x-py-name";
+    public static final String X_PY_ENUM_TYPE = "x-py-enum-type";
+    public static final String X_PY_READONLY = "x-py-readonly";
+    public static final String X_PY_MODEL_IMPORTS = "x-py-model-imports";
+    public static final String X_PY_OTHER_IMPORTS = "x-py-other-imports";
+    public static final String X_PY_POSTPONED_MODEL_IMPORTS = "x-py-postponed-model-imports";
+    public static final String X_PY_TYPING_IMPORTS = "x-py-typing-imports";
+    public static final String X_PY_PYDANTIC_IMPORTS = "x-py-pydantic-imports";
+    public static final String X_PY_DATETIME_IMPORTS = "x-py-datetime-imports";
 }
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractPythonCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractPythonCodegen.java
@@ -635,16 +635,16 @@ public void setParameterExampleValue(CodegenParameter codegenParameter, Paramete
 
         if (parameter.getExample() != null) {
             codegenParameter.example = parameter.getExample().toString();
-            codegenParameter.vendorExtensions.put("x-py-example", toPythonLiteral(parameter.getExample()));
+            codegenParameter.vendorExtensions.put(X_PY_EXAMPLE, toPythonLiteral(parameter.getExample()));
         } else if (parameter.getExamples() != null && !parameter.getExamples().isEmpty()) {
             Example example = parameter.getExamples().values().iterator().next();
             if (example.getValue() != null) {
                 codegenParameter.example = example.getValue().toString();
-                codegenParameter.vendorExtensions.put("x-py-example", toPythonLiteral(example.getValue()));
+                codegenParameter.vendorExtensions.put(X_PY_EXAMPLE, toPythonLiteral(example.getValue()));
             }
         } else if (schema != null && schema.getExample() != null) {
             codegenParameter.example = schema.getExample().toString();
-            codegenParameter.vendorExtensions.put("x-py-example", toPythonLiteral(schema.getExample()));
+            codegenParameter.vendorExtensions.put(X_PY_EXAMPLE, toPythonLiteral(schema.getExample()));
         }
 
         setParameterExampleValue(codegenParameter);
@@ -1040,13 +1040,13 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
                 }
 
                 String typing = pydantic.generatePythonType(cp);
-                cp.vendorExtensions.put("x-py-typing", typing);
+                cp.vendorExtensions.put(X_PY_TYPING, typing);
 
                 // setup x-py-name for each oneOf/anyOf schema
                 if (!model.oneOf.isEmpty()) { // oneOf
-                    cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));
+                    cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));
                 } else if (!model.anyOf.isEmpty()) { // anyOf
-                    cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));
+                    cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));
                 }
             }
 
@@ -1061,13 +1061,13 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
             if (model.isEnum) {
                 for (Map<String, Object> enumVars : (List<Map<String, Object>>) model.getAllowableValues().get("enumVars")) {
                     if ((Boolean) enumVars.get("isString")) {
-                        model.vendorExtensions.putIfAbsent("x-py-enum-type", "str");
+                        model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "str");
                         // Do not overwrite the variable name if already set through x-enum-varnames
                         if (model.vendorExtensions.get(X_ENUM_VARNAMES) == null) {
                             enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "str"));
                         }
                     } else {
-                        model.vendorExtensions.putIfAbsent("x-py-enum-type", "int");
+                        model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "int");
                         // Do not overwrite the variable name if already set through x-enum-varnames
                         if (model.vendorExtensions.get(X_ENUM_VARNAMES) == null) {
                             enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "int"));
@@ -1077,7 +1077,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
             }
 
             // set the extensions if the key is absent
-            model.getVendorExtensions().putIfAbsent("x-py-readonly", readOnlyFields);
+            model.getVendorExtensions().putIfAbsent(X_PY_READONLY, readOnlyFields);
 
             // remove the items of postponedModelImports in modelImports to avoid circular imports error
             if (!modelImports.isEmpty() && !postponedModelImports.isEmpty()) {
@@ -1096,12 +1096,12 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
                 }
 
                 if (!modelsToImport.isEmpty()) {
-                    model.getVendorExtensions().putIfAbsent("x-py-model-imports", modelsToImport);
+                    model.getVendorExtensions().putIfAbsent(X_PY_MODEL_IMPORTS, modelsToImport);
                 }
             }
 
             if (!moduleImports.isEmpty()) {
-                model.getVendorExtensions().putIfAbsent("x-py-other-imports", moduleImports.exports());
+                model.getVendorExtensions().putIfAbsent(X_PY_OTHER_IMPORTS, moduleImports.exports());
             }
 
 
@@ -1115,7 +1115,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
                     modelsToImport.add("from " + packageName + ".models." + underscore(modelImport) + " import " + modelImport);
                 }
 
-                model.getVendorExtensions().putIfAbsent("x-py-postponed-model-imports", modelsToImport);
+                model.getVendorExtensions().putIfAbsent(X_PY_POSTPONED_MODEL_IMPORTS, modelsToImport);
             }
         }
 
@@ -1326,7 +1326,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
                         null
                 );
                 String typing = pydantic.generatePythonType(cp);
-                cp.vendorExtensions.put("x-py-typing", typing);
+                cp.vendorExtensions.put(X_PY_TYPING, typing);
             }
 
             // update typing import for operation return type
@@ -1367,7 +1367,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
                 for (String exampleImport : exampleImports) {
                     imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import " + exampleImport);
                 }
-                operation.vendorExtensions.put("x-py-example-import", imports);
+                operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);
             }
 
             if (!postponedExampleImports.isEmpty()) {
@@ -1376,7 +1376,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
                     imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import "
                             + exampleImport);
                 }
-                operation.vendorExtensions.put("x-py-example-import", imports);
+                operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);
             }
 
             // Remove constant params from allParams list and add to constantParams
@@ -1462,7 +1462,7 @@ public void postProcessPattern(String pattern, Map<String, Object> vendorExtensi
             }
 
             vendorExtensions.put(X_REGEX, regex.replace("\"", "\\\""));
-            vendorExtensions.put("x-pattern", pattern.replace("\"", "\\\""));
+            vendorExtensions.put(X_PATTERN, pattern.replace("\"", "\\\""));
             vendorExtensions.put(X_MODIFIERS, modifiers);
         }
     }
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractPythonPydanticV1Codegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractPythonPydanticV1Codegen.java
@@ -39,8 +39,7 @@
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-import static org.openapitools.codegen.CodegenConstants.X_MODIFIERS;
-import static org.openapitools.codegen.CodegenConstants.X_REGEX;
+import static org.openapitools.codegen.CodegenConstants.*;
 import static org.openapitools.codegen.utils.StringUtils.*;
 
 public abstract class AbstractPythonPydanticV1Codegen extends DefaultCodegen implements CodegenConfig {
@@ -948,13 +947,13 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
                     fieldCustomization = "Field(...)";
                 }
 
-                cp.vendorExtensions.put("x-py-typing", typing + " = " + fieldCustomization);
+                cp.vendorExtensions.put(X_PY_TYPING, typing + " = " + fieldCustomization);
 
                 // setup x-py-name for each oneOf/anyOf schema
                 if (!model.oneOf.isEmpty()) { // oneOf
-                    cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));
+                    cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));
                 } else if (!model.anyOf.isEmpty()) { // anyOf
-                    cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));
+                    cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));
                 }
             }
 
@@ -969,21 +968,21 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
             if (model.isEnum) {
                 for (Map<String, Object> enumVars : (List<Map<String, Object>>) model.getAllowableValues().get("enumVars")) {
                     if ((Boolean) enumVars.get("isString")) {
-                        model.vendorExtensions.putIfAbsent("x-py-enum-type", "str");
+                        model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "str");
                         // update `name`, e.g.
                         enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "str"));
                     } else {
-                        model.vendorExtensions.putIfAbsent("x-py-enum-type", "int");
+                        model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "int");
                         enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "int"));
                     }
                 }
             }
 
             // set the extensions if the key is absent
-            model.getVendorExtensions().putIfAbsent("x-py-typing-imports", typingImports);
-            model.getVendorExtensions().putIfAbsent("x-py-pydantic-imports", pydanticImports);
-            model.getVendorExtensions().putIfAbsent("x-py-datetime-imports", datetimeImports);
-            model.getVendorExtensions().putIfAbsent("x-py-readonly", readOnlyFields);
+            model.getVendorExtensions().putIfAbsent(X_PY_TYPING_IMPORTS, typingImports);
+            model.getVendorExtensions().putIfAbsent(X_PY_PYDANTIC_IMPORTS, pydanticImports);
+            model.getVendorExtensions().putIfAbsent(X_PY_DATETIME_IMPORTS, datetimeImports);
+            model.getVendorExtensions().putIfAbsent(X_PY_READONLY, readOnlyFields);
 
             // remove the items of postponedModelImports in modelImports to avoid circular imports error
             if (!modelImports.isEmpty() && !postponedModelImports.isEmpty()) {
@@ -1001,7 +1000,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
                     modelsToImport.add("from " + packageName + ".models." + underscore(modelImport) + " import " + modelImport);
                 }
 
-                model.getVendorExtensions().putIfAbsent("x-py-model-imports", modelsToImport);
+                model.getVendorExtensions().putIfAbsent(X_PY_MODEL_IMPORTS, modelsToImport);
             }
 
             if (!postponedModelImports.isEmpty()) {
@@ -1014,7 +1013,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {
                     modelsToImport.add("from " + packageName + ".models." + underscore(modelImport) + " import " + modelImport);
                 }
 
-                model.getVendorExtensions().putIfAbsent("x-py-postponed-model-imports", modelsToImport);
+                model.getVendorExtensions().putIfAbsent(X_PY_POSTPONED_MODEL_IMPORTS, modelsToImport);
             }
 
         }
@@ -1789,9 +1788,9 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
                 }
 
                 if ("Field()".equals(fieldCustomization)) {
-                    param.vendorExtensions.put("x-py-typing", typing);
+                    param.vendorExtensions.put(X_PY_TYPING, typing);
                 } else {
-                    param.vendorExtensions.put("x-py-typing", String.format(Locale.ROOT, "Annotated[%s, %s]", typing, fieldCustomization));
+                    param.vendorExtensions.put(X_PY_TYPING, String.format(Locale.ROOT, "Annotated[%s, %s]", typing, fieldCustomization));
                     importAnnotated = true;
                 }
             }
@@ -1809,7 +1808,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
                 for (String exampleImport : exampleImports) {
                     imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import " + exampleImport);
                 }
-                operation.vendorExtensions.put("x-py-example-import", imports);
+                operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);
             }
 
             if (!postponedExampleImports.isEmpty()) {
@@ -1818,7 +1817,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
                     imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import "
                             + exampleImport);
                 }
-                operation.vendorExtensions.put("x-py-example-import", imports);
+                operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);
             }
         }
 
@@ -1918,7 +1917,7 @@ public void postProcessPattern(String pattern, Map<String, Object> vendorExtensi
             }
 
             vendorExtensions.put(X_REGEX, regex.replace("\"", "\\\""));
-            vendorExtensions.put("x-pattern", pattern.replace("\"", "\\\""));
+            vendorExtensions.put(X_PATTERN, pattern.replace("\"", "\\\""));
             vendorExtensions.put(X_MODIFIERS, modifiers);
         }
     }
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/PythonFastAPIServerCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/PythonFastAPIServerCodegen.java
@@ -41,6 +41,7 @@
 import java.io.File;
 import java.util.*;
 
+import static org.openapitools.codegen.CodegenConstants.*;
 import static org.openapitools.codegen.utils.StringUtils.underscore;
 
 /**
@@ -284,13 +285,13 @@ private boolean overrideFileFormParamTyping(CodegenOperation operation) {
         boolean changed = false;
         for (CodegenParameter param : operation.allParams) {
             if (param.isFormParam && param.isFile) {
-                param.vendorExtensions.put("x-py-typing", param.required ? "UploadFile" : "Optional[UploadFile]");
+                param.vendorExtensions.put(X_PY_TYPING, param.required ? "UploadFile" : "Optional[UploadFile]");
                 changed = true;
             }
         }
         for (CodegenParameter param : operation.formParams) {
             if (param.isFile) {
-                param.vendorExtensions.put("x-py-typing", param.required ? "UploadFile" : "Optional[UploadFile]");
+                param.vendorExtensions.put(X_PY_TYPING, param.required ? "UploadFile" : "Optional[UploadFile]");
             }
         }
         return changed;
@@ -397,35 +398,35 @@ private Operation findOpenAPIOperation(CodegenOperation operation) {
     }
 
     private void clearBodyParamExample(CodegenOperation operation) {
-        operation.bodyParam.vendorExtensions.remove("x-py-example");
-        operation.bodyParam.vendorExtensions.remove("x-py-fastapi-example");
+        operation.bodyParam.vendorExtensions.remove(X_PY_EXAMPLE);
+        operation.bodyParam.vendorExtensions.remove(X_PY_FASTAPI_EXAMPLE);
         for (CodegenParameter param : operation.allParams) {
             if (param.isBodyParam || Objects.equals(param.paramName, operation.bodyParam.paramName)) {
-                param.vendorExtensions.remove("x-py-example");
-                param.vendorExtensions.remove("x-py-fastapi-example");
+                param.vendorExtensions.remove(X_PY_EXAMPLE);
+                param.vendorExtensions.remove(X_PY_FASTAPI_EXAMPLE);
             }
         }
         for (CodegenParameter param : operation.bodyParams) {
             if (param.isBodyParam || Objects.equals(param.paramName, operation.bodyParam.paramName)) {
-                param.vendorExtensions.remove("x-py-example");
-                param.vendorExtensions.remove("x-py-fastapi-example");
+                param.vendorExtensions.remove(X_PY_EXAMPLE);
+                param.vendorExtensions.remove(X_PY_FASTAPI_EXAMPLE);
             }
         }
     }
 
     private void setBodyParamExample(CodegenOperation operation, String example) {
-        operation.bodyParam.vendorExtensions.remove("x-py-example");
-        operation.bodyParam.vendorExtensions.put("x-py-fastapi-example", example);
+        operation.bodyParam.vendorExtensions.remove(X_PY_EXAMPLE);
+        operation.bodyParam.vendorExtensions.put(X_PY_FASTAPI_EXAMPLE, example);
         for (CodegenParameter param : operation.allParams) {
             if (param.isBodyParam || Objects.equals(param.paramName, operation.bodyParam.paramName)) {
-                param.vendorExtensions.remove("x-py-example");
-                param.vendorExtensions.put("x-py-fastapi-example", example);
+                param.vendorExtensions.remove(X_PY_EXAMPLE);
+                param.vendorExtensions.put(X_PY_FASTAPI_EXAMPLE, example);
             }
         }
         for (CodegenParameter param : operation.bodyParams) {
             if (param.isBodyParam || Objects.equals(param.paramName, operation.bodyParam.paramName)) {
-                param.vendorExtensions.remove("x-py-example");
-                param.vendorExtensions.put("x-py-fastapi-example", example);
+                param.vendorExtensions.remove(X_PY_EXAMPLE);
+                param.vendorExtensions.put(X_PY_FASTAPI_EXAMPLE, example);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -635,16 +635,16 @@ public void setParameterExampleValue(CodegenParameter codegenParameter, Paramete`
`635`	`635`
`636`	`636`	`if (parameter.getExample() != null) {`
`637`	`637`	`codegenParameter.example = parameter.getExample().toString();`
`638`		`- codegenParameter.vendorExtensions.put("x-py-example", toPythonLiteral(parameter.getExample()));`
	`638`	`+ codegenParameter.vendorExtensions.put(X_PY_EXAMPLE, toPythonLiteral(parameter.getExample()));`
`639`	`639`	`} else if (parameter.getExamples() != null && !parameter.getExamples().isEmpty()) {`
`640`	`640`	`Example example = parameter.getExamples().values().iterator().next();`
`641`	`641`	`if (example.getValue() != null) {`
`642`	`642`	`codegenParameter.example = example.getValue().toString();`
`643`		`- codegenParameter.vendorExtensions.put("x-py-example", toPythonLiteral(example.getValue()));`
	`643`	`+ codegenParameter.vendorExtensions.put(X_PY_EXAMPLE, toPythonLiteral(example.getValue()));`
`644`	`644`	`}`
`645`	`645`	`} else if (schema != null && schema.getExample() != null) {`
`646`	`646`	`codegenParameter.example = schema.getExample().toString();`
`647`		`- codegenParameter.vendorExtensions.put("x-py-example", toPythonLiteral(schema.getExample()));`
	`647`	`+ codegenParameter.vendorExtensions.put(X_PY_EXAMPLE, toPythonLiteral(schema.getExample()));`
`648`	`648`	`}`
`649`	`649`
`650`	`650`	`setParameterExampleValue(codegenParameter);`
`@@ -1040,13 +1040,13 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1040`	`1040`	`}`
`1041`	`1041`
`1042`	`1042`	`String typing = pydantic.generatePythonType(cp);`
`1043`		`- cp.vendorExtensions.put("x-py-typing", typing);`
	`1043`	`+ cp.vendorExtensions.put(X_PY_TYPING, typing);`
`1044`	`1044`
`1045`	`1045`	`// setup x-py-name for each oneOf/anyOf schema`
`1046`	`1046`	`if (!model.oneOf.isEmpty()) { // oneOf`
`1047`		`- cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));`
	`1047`	`+ cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));`
`1048`	`1048`	`} else if (!model.anyOf.isEmpty()) { // anyOf`
`1049`		`- cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));`
	`1049`	`+ cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));`
`1050`	`1050`	`}`
`1051`	`1051`	`}`
`1052`	`1052`
`@@ -1061,13 +1061,13 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1061`	`1061`	`if (model.isEnum) {`
`1062`	`1062`	`for (Map<String, Object> enumVars : (List<Map<String, Object>>) model.getAllowableValues().get("enumVars")) {`
`1063`	`1063`	`if ((Boolean) enumVars.get("isString")) {`
`1064`		`- model.vendorExtensions.putIfAbsent("x-py-enum-type", "str");`
	`1064`	`+ model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "str");`
`1065`	`1065`	`// Do not overwrite the variable name if already set through x-enum-varnames`
`1066`	`1066`	`if (model.vendorExtensions.get(X_ENUM_VARNAMES) == null) {`
`1067`	`1067`	`enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "str"));`
`1068`	`1068`	`}`
`1069`	`1069`	`} else {`
`1070`		`- model.vendorExtensions.putIfAbsent("x-py-enum-type", "int");`
	`1070`	`+ model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "int");`
`1071`	`1071`	`// Do not overwrite the variable name if already set through x-enum-varnames`
`1072`	`1072`	`if (model.vendorExtensions.get(X_ENUM_VARNAMES) == null) {`
`1073`	`1073`	`enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "int"));`
`@@ -1077,7 +1077,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1077`	`1077`	`}`
`1078`	`1078`
`1079`	`1079`	`// set the extensions if the key is absent`
`1080`		`- model.getVendorExtensions().putIfAbsent("x-py-readonly", readOnlyFields);`
	`1080`	`+ model.getVendorExtensions().putIfAbsent(X_PY_READONLY, readOnlyFields);`
`1081`	`1081`
`1082`	`1082`	`// remove the items of postponedModelImports in modelImports to avoid circular imports error`
`1083`	`1083`	`if (!modelImports.isEmpty() && !postponedModelImports.isEmpty()) {`
`@@ -1096,12 +1096,12 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1096`	`1096`	`}`
`1097`	`1097`
`1098`	`1098`	`if (!modelsToImport.isEmpty()) {`
`1099`		`- model.getVendorExtensions().putIfAbsent("x-py-model-imports", modelsToImport);`
	`1099`	`+ model.getVendorExtensions().putIfAbsent(X_PY_MODEL_IMPORTS, modelsToImport);`
`1100`	`1100`	`}`
`1101`	`1101`	`}`
`1102`	`1102`
`1103`	`1103`	`if (!moduleImports.isEmpty()) {`
`1104`		`- model.getVendorExtensions().putIfAbsent("x-py-other-imports", moduleImports.exports());`
	`1104`	`+ model.getVendorExtensions().putIfAbsent(X_PY_OTHER_IMPORTS, moduleImports.exports());`
`1105`	`1105`	`}`
`1106`	`1106`
`1107`	`1107`
`@@ -1115,7 +1115,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1115`	`1115`	`modelsToImport.add("from " + packageName + ".models." + underscore(modelImport) + " import " + modelImport);`
`1116`	`1116`	`}`
`1117`	`1117`
`1118`		`- model.getVendorExtensions().putIfAbsent("x-py-postponed-model-imports", modelsToImport);`
	`1118`	`+ model.getVendorExtensions().putIfAbsent(X_PY_POSTPONED_MODEL_IMPORTS, modelsToImport);`
`1119`	`1119`	`}`
`1120`	`1120`	`}`
`1121`	`1121`
`@@ -1326,7 +1326,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo`
`1326`	`1326`	`null`
`1327`	`1327`	`);`
`1328`	`1328`	`String typing = pydantic.generatePythonType(cp);`
`1329`		`- cp.vendorExtensions.put("x-py-typing", typing);`
	`1329`	`+ cp.vendorExtensions.put(X_PY_TYPING, typing);`
`1330`	`1330`	`}`
`1331`	`1331`
`1332`	`1332`	`// update typing import for operation return type`
`@@ -1367,7 +1367,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo`
`1367`	`1367`	`for (String exampleImport : exampleImports) {`
`1368`	`1368`	`imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import " + exampleImport);`
`1369`	`1369`	`}`
`1370`		`- operation.vendorExtensions.put("x-py-example-import", imports);`
	`1370`	`+ operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);`
`1371`	`1371`	`}`
`1372`	`1372`
`1373`	`1373`	`if (!postponedExampleImports.isEmpty()) {`
`@@ -1376,7 +1376,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo`
`1376`	`1376`	`imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import "`
`1377`	`1377`	`+ exampleImport);`
`1378`	`1378`	`}`
`1379`		`- operation.vendorExtensions.put("x-py-example-import", imports);`
	`1379`	`+ operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);`
`1380`	`1380`	`}`
`1381`	`1381`
`1382`	`1382`	`// Remove constant params from allParams list and add to constantParams`
`@@ -1462,7 +1462,7 @@ public void postProcessPattern(String pattern, Map<String, Object> vendorExtensi`
`1462`	`1462`	`}`
`1463`	`1463`
`1464`	`1464`	`vendorExtensions.put(X_REGEX, regex.replace("\"", "\\\""));`
`1465`		`- vendorExtensions.put("x-pattern", pattern.replace("\"", "\\\""));`
	`1465`	`+ vendorExtensions.put(X_PATTERN, pattern.replace("\"", "\\\""));`
`1466`	`1466`	`vendorExtensions.put(X_MODIFIERS, modifiers);`
`1467`	`1467`	`}`
`1468`	`1468`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,7 @@`
`39`	`39`	`import java.util.regex.Pattern;`
`40`	`40`	`import java.util.stream.Collectors;`
`41`	`41`
`42`		`-import static org.openapitools.codegen.CodegenConstants.X_MODIFIERS;`
`43`		`-import static org.openapitools.codegen.CodegenConstants.X_REGEX;`
	`42`	`+import static org.openapitools.codegen.CodegenConstants.*;`
`44`	`43`	`import static org.openapitools.codegen.utils.StringUtils.*;`
`45`	`44`
`46`	`45`	`public abstract class AbstractPythonPydanticV1Codegen extends DefaultCodegen implements CodegenConfig {`
`@@ -948,13 +947,13 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`948`	`947`	`fieldCustomization = "Field(...)";`
`949`	`948`	`}`
`950`	`949`
`951`		`- cp.vendorExtensions.put("x-py-typing", typing + " = " + fieldCustomization);`
	`950`	`+ cp.vendorExtensions.put(X_PY_TYPING, typing + " = " + fieldCustomization);`
`952`	`951`
`953`	`952`	`// setup x-py-name for each oneOf/anyOf schema`
`954`	`953`	`if (!model.oneOf.isEmpty()) { // oneOf`
`955`		`- cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));`
	`954`	`+ cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "oneof_schema_%d_validator", property_count++));`
`956`	`955`	`} else if (!model.anyOf.isEmpty()) { // anyOf`
`957`		`- cp.vendorExtensions.put("x-py-name", String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));`
	`956`	`+ cp.vendorExtensions.put(X_PY_NAME, String.format(Locale.ROOT, "anyof_schema_%d_validator", property_count++));`
`958`	`957`	`}`
`959`	`958`	`}`
`960`	`959`
`@@ -969,21 +968,21 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`969`	`968`	`if (model.isEnum) {`
`970`	`969`	`for (Map<String, Object> enumVars : (List<Map<String, Object>>) model.getAllowableValues().get("enumVars")) {`
`971`	`970`	`if ((Boolean) enumVars.get("isString")) {`
`972`		`- model.vendorExtensions.putIfAbsent("x-py-enum-type", "str");`
	`971`	`+ model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "str");`
`973`	`972`	// update `name`, e.g.
`974`	`973`	`enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "str"));`
`975`	`974`	`} else {`
`976`		`- model.vendorExtensions.putIfAbsent("x-py-enum-type", "int");`
	`975`	`+ model.vendorExtensions.putIfAbsent(X_PY_ENUM_TYPE, "int");`
`977`	`976`	`enumVars.put("name", toEnumVariableName((String) enumVars.get("value"), "int"));`
`978`	`977`	`}`
`979`	`978`	`}`
`980`	`979`	`}`
`981`	`980`
`982`	`981`	`// set the extensions if the key is absent`
`983`		`- model.getVendorExtensions().putIfAbsent("x-py-typing-imports", typingImports);`
`984`		`- model.getVendorExtensions().putIfAbsent("x-py-pydantic-imports", pydanticImports);`
`985`		`- model.getVendorExtensions().putIfAbsent("x-py-datetime-imports", datetimeImports);`
`986`		`- model.getVendorExtensions().putIfAbsent("x-py-readonly", readOnlyFields);`
	`982`	`+ model.getVendorExtensions().putIfAbsent(X_PY_TYPING_IMPORTS, typingImports);`
	`983`	`+ model.getVendorExtensions().putIfAbsent(X_PY_PYDANTIC_IMPORTS, pydanticImports);`
	`984`	`+ model.getVendorExtensions().putIfAbsent(X_PY_DATETIME_IMPORTS, datetimeImports);`
	`985`	`+ model.getVendorExtensions().putIfAbsent(X_PY_READONLY, readOnlyFields);`
`987`	`986`
`988`	`987`	`// remove the items of postponedModelImports in modelImports to avoid circular imports error`
`989`	`988`	`if (!modelImports.isEmpty() && !postponedModelImports.isEmpty()) {`
`@@ -1001,7 +1000,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1001`	`1000`	`modelsToImport.add("from " + packageName + ".models." + underscore(modelImport) + " import " + modelImport);`
`1002`	`1001`	`}`
`1003`	`1002`
`1004`		`- model.getVendorExtensions().putIfAbsent("x-py-model-imports", modelsToImport);`
	`1003`	`+ model.getVendorExtensions().putIfAbsent(X_PY_MODEL_IMPORTS, modelsToImport);`
`1005`	`1004`	`}`
`1006`	`1005`
`1007`	`1006`	`if (!postponedModelImports.isEmpty()) {`
`@@ -1014,7 +1013,7 @@ private ModelsMap postProcessModelsMap(ModelsMap objs) {`
`1014`	`1013`	`modelsToImport.add("from " + packageName + ".models." + underscore(modelImport) + " import " + modelImport);`
`1015`	`1014`	`}`
`1016`	`1015`
`1017`		`- model.getVendorExtensions().putIfAbsent("x-py-postponed-model-imports", modelsToImport);`
	`1016`	`+ model.getVendorExtensions().putIfAbsent(X_PY_POSTPONED_MODEL_IMPORTS, modelsToImport);`
`1018`	`1017`	`}`
`1019`	`1018`
`1020`	`1019`	`}`
`@@ -1789,9 +1788,9 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo`
`1789`	`1788`	`}`
`1790`	`1789`
`1791`	`1790`	`if ("Field()".equals(fieldCustomization)) {`
`1792`		`- param.vendorExtensions.put("x-py-typing", typing);`
	`1791`	`+ param.vendorExtensions.put(X_PY_TYPING, typing);`
`1793`	`1792`	`} else {`
`1794`		`- param.vendorExtensions.put("x-py-typing", String.format(Locale.ROOT, "Annotated[%s, %s]", typing, fieldCustomization));`
	`1793`	`+ param.vendorExtensions.put(X_PY_TYPING, String.format(Locale.ROOT, "Annotated[%s, %s]", typing, fieldCustomization));`
`1795`	`1794`	`importAnnotated = true;`
`1796`	`1795`	`}`
`1797`	`1796`	`}`
`@@ -1809,7 +1808,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo`
`1809`	`1808`	`for (String exampleImport : exampleImports) {`
`1810`	`1809`	`imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import " + exampleImport);`
`1811`	`1810`	`}`
`1812`		`- operation.vendorExtensions.put("x-py-example-import", imports);`
	`1811`	`+ operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);`
`1813`	`1812`	`}`
`1814`	`1813`
`1815`	`1814`	`if (!postponedExampleImports.isEmpty()) {`
`@@ -1818,7 +1817,7 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo`
`1818`	`1817`	`imports.add("from " + packageName + ".models." + underscore(exampleImport) + " import "`
`1819`	`1818`	`+ exampleImport);`
`1820`	`1819`	`}`
`1821`		`- operation.vendorExtensions.put("x-py-example-import", imports);`
	`1820`	`+ operation.vendorExtensions.put(X_PY_EXAMPLE_IMPORT, imports);`
`1822`	`1821`	`}`
`1823`	`1822`	`}`
`1824`	`1823`
`@@ -1918,7 +1917,7 @@ public void postProcessPattern(String pattern, Map<String, Object> vendorExtensi`
`1918`	`1917`	`}`
`1919`	`1918`
`1920`	`1919`	`vendorExtensions.put(X_REGEX, regex.replace("\"", "\\\""));`
`1921`		`- vendorExtensions.put("x-pattern", pattern.replace("\"", "\\\""));`
	`1920`	`+ vendorExtensions.put(X_PATTERN, pattern.replace("\"", "\\\""));`
`1922`	`1921`	`vendorExtensions.put(X_MODIFIERS, modifiers);`
`1923`	`1922`	`}`
`1924`	`1923`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@`
`41`	`41`	`import java.io.File;`
`42`	`42`	`import java.util.*;`
`43`	`43`
	`44`	`+import static org.openapitools.codegen.CodegenConstants.*;`
`44`	`45`	`import static org.openapitools.codegen.utils.StringUtils.underscore;`
`45`	`46`
`46`	`47`	`/**`
`@@ -284,13 +285,13 @@ private boolean overrideFileFormParamTyping(CodegenOperation operation) {`
`284`	`285`	`boolean changed = false;`
`285`	`286`	`for (CodegenParameter param : operation.allParams) {`
`286`	`287`	`if (param.isFormParam && param.isFile) {`
`287`		`- param.vendorExtensions.put("x-py-typing", param.required ? "UploadFile" : "Optional[UploadFile]");`
	`288`	`+ param.vendorExtensions.put(X_PY_TYPING, param.required ? "UploadFile" : "Optional[UploadFile]");`
`288`	`289`	`changed = true;`
`289`	`290`	`}`
`290`	`291`	`}`
`291`	`292`	`for (CodegenParameter param : operation.formParams) {`
`292`	`293`	`if (param.isFile) {`
`293`		`- param.vendorExtensions.put("x-py-typing", param.required ? "UploadFile" : "Optional[UploadFile]");`
	`294`	`+ param.vendorExtensions.put(X_PY_TYPING, param.required ? "UploadFile" : "Optional[UploadFile]");`
`294`	`295`	`}`
`295`	`296`	`}`
`296`	`297`	`return changed;`
`@@ -397,35 +398,35 @@ private Operation findOpenAPIOperation(CodegenOperation operation) {`
`397`	`398`	`}`
`398`	`399`
`399`	`400`	`private void clearBodyParamExample(CodegenOperation operation) {`
`400`		`- operation.bodyParam.vendorExtensions.remove("x-py-example");`
`401`		`- operation.bodyParam.vendorExtensions.remove("x-py-fastapi-example");`
	`401`	`+ operation.bodyParam.vendorExtensions.remove(X_PY_EXAMPLE);`
	`402`	`+ operation.bodyParam.vendorExtensions.remove(X_PY_FASTAPI_EXAMPLE);`
`402`	`403`	`for (CodegenParameter param : operation.allParams) {`
`403`	`404`	`if (param.isBodyParam \|\| Objects.equals(param.paramName, operation.bodyParam.paramName)) {`
`404`		`- param.vendorExtensions.remove("x-py-example");`
`405`		`- param.vendorExtensions.remove("x-py-fastapi-example");`
	`405`	`+ param.vendorExtensions.remove(X_PY_EXAMPLE);`
	`406`	`+ param.vendorExtensions.remove(X_PY_FASTAPI_EXAMPLE);`
`406`	`407`	`}`
`407`	`408`	`}`
`408`	`409`	`for (CodegenParameter param : operation.bodyParams) {`
`409`	`410`	`if (param.isBodyParam \|\| Objects.equals(param.paramName, operation.bodyParam.paramName)) {`
`410`		`- param.vendorExtensions.remove("x-py-example");`
`411`		`- param.vendorExtensions.remove("x-py-fastapi-example");`
	`411`	`+ param.vendorExtensions.remove(X_PY_EXAMPLE);`
	`412`	`+ param.vendorExtensions.remove(X_PY_FASTAPI_EXAMPLE);`
`412`	`413`	`}`
`413`	`414`	`}`
`414`	`415`	`}`
`415`	`416`
`416`	`417`	`private void setBodyParamExample(CodegenOperation operation, String example) {`
`417`		`- operation.bodyParam.vendorExtensions.remove("x-py-example");`
`418`		`- operation.bodyParam.vendorExtensions.put("x-py-fastapi-example", example);`
	`418`	`+ operation.bodyParam.vendorExtensions.remove(X_PY_EXAMPLE);`
	`419`	`+ operation.bodyParam.vendorExtensions.put(X_PY_FASTAPI_EXAMPLE, example);`
`419`	`420`	`for (CodegenParameter param : operation.allParams) {`
`420`	`421`	`if (param.isBodyParam \|\| Objects.equals(param.paramName, operation.bodyParam.paramName)) {`
`421`		`- param.vendorExtensions.remove("x-py-example");`
`422`		`- param.vendorExtensions.put("x-py-fastapi-example", example);`
	`422`	`+ param.vendorExtensions.remove(X_PY_EXAMPLE);`
	`423`	`+ param.vendorExtensions.put(X_PY_FASTAPI_EXAMPLE, example);`
`423`	`424`	`}`
`424`	`425`	`}`
`425`	`426`	`for (CodegenParameter param : operation.bodyParams) {`
`426`	`427`	`if (param.isBodyParam \|\| Objects.equals(param.paramName, operation.bodyParam.paramName)) {`
`427`		`- param.vendorExtensions.remove("x-py-example");`
`428`		`- param.vendorExtensions.put("x-py-fastapi-example", example);`
	`428`	`+ param.vendorExtensions.remove(X_PY_EXAMPLE);`
	`429`	`+ param.vendorExtensions.put(X_PY_FASTAPI_EXAMPLE, example);`
`429`	`430`	`}`
`430`	`431`	`}`
`431`	`432`	`}`