Share Python legacy model helpers across generated models

modules/openapi-generator/src/main/java/org/openapitools/codegen/CodegenConstants.java

@@ -337,6 +337,7 @@ public static enum ENUM_PROPERTY_NAMING_TYPE {camelCase, PascalCase, snake_case,
     // Not user-configurable. System provided for use in templates.
     public static final String GENERATE_MODELS = "generateModels";
     public static final String GENERATE_MODEL_DOCS = "generateModelDocs";
+    public static final String GENERATE_SUPPORTING_FILES = "generateSupportingFiles";
 
     public static final String VIRTUAL_SERVICE = "virtualService";
     public static final String VIRTUAL_SERVICE_DESC = "Generate Spring boot rest service as virtual service with Virtualan";

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultGenerator.java

@@ -238,6 +238,7 @@ void configureGeneratorProperties() {
 
         config.additionalProperties().put(CodegenConstants.GENERATE_APIS, generateApis);
         config.additionalProperties().put(CodegenConstants.GENERATE_MODELS, generateModels);
+        config.additionalProperties().put(CodegenConstants.GENERATE_SUPPORTING_FILES, generateSupportingFiles);
         config.additionalProperties().put(CodegenConstants.GENERATE_WEBHOOKS, generateWebhooks);
         config.additionalProperties().put(CodegenConstants.GENERATE_RECURSIVE_DEPENDENT_MODELS, generateRecursiveDependentModels);
 

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/PythonClientCodegen.java

@@ -22,6 +22,7 @@
 import lombok.Setter;
 import org.apache.commons.lang3.Strings;
 import org.openapitools.codegen.*;
+import org.openapitools.codegen.config.GlobalSettings;
 import org.openapitools.codegen.meta.GeneratorMetadata;
 import org.openapitools.codegen.meta.Stability;
 import org.openapitools.codegen.meta.features.*;
@@ -65,6 +66,8 @@ public class PythonClientCodegen extends AbstractPythonCodegen implements Codege
     public static final String BUILD_SYSTEM = "buildSystem";
     public static final String SUPPORT_HTTPX_SYNC = "supportHttpxSync";
     public static final String USE_INDEPENDENT_IMPLICIT_CLIENTS = "useIndependentImplicitClients";
+    private static final String USE_LEGACY_MODEL_HELPERS_MODULE = "useLegacyModelHelpersModule";
+    private static final String LEGACY_MODEL_HELPERS_FILE = "_legacy_model_helpers.py";
     private static final Set<String> SYNC_API_LIFECYCLE_METHODS =
             Set.of("close", "__enter__", "__exit__");
     private static final Set<String> ASYNC_API_LIFECYCLE_METHODS =
@@ -402,6 +405,14 @@ public void processOpts() {
         String modelPath = srcPath + File.separatorChar + modelPackage.replace('.', File.separatorChar);
         String apiPath = srcPath + File.separatorChar + apiPackage.replace('.', File.separatorChar);
 
+        if (compatibleWithPythonLegacy && generatesLegacyModelHelpersModule()) {
+            additionalProperties.put(USE_LEGACY_MODEL_HELPERS_MODULE, true);
+            supportingFiles.add(new SupportingFile(
+                    "_legacy_model_helpers.mustache", srcPath, LEGACY_MODEL_HELPERS_FILE));
+        } else {
+            additionalProperties.remove(USE_LEGACY_MODEL_HELPERS_MODULE);
+        }
+
         String readmePath = "README.md";
         String readmeTemplate = "README.mustache";
         if (generateSourceCodeOnly) {
@@ -703,6 +714,29 @@ private boolean usesLegacyApiCompatibility() {
         return compatibleWithPythonLegacy && DEFAULT_LIBRARY.equals(getLibrary());
     }
 
+    /**
+     * Returns whether legacy-compatible models can import their conversion helpers from a shared supporting file.
+     *
+     * @return true when supporting-file generation includes the legacy model helpers file
+     */
+    private boolean generatesLegacyModelHelpersModule() {
+        if (!Boolean.TRUE.equals(additionalProperties.get(CodegenConstants.GENERATE_SUPPORTING_FILES))) {
+            return false;
+        }
+
+        String requestedSupportingFiles = GlobalSettings.getProperty(CodegenConstants.SUPPORTING_FILES);
+        if (requestedSupportingFiles == null || requestedSupportingFiles.isEmpty()) {
+            return true;
+        }
+
+        for (String requestedFile : requestedSupportingFiles.split(",")) {
+            if (LEGACY_MODEL_HELPERS_FILE.equals(requestedFile.trim())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private boolean isHttpxLibrary() {
         return "httpx".equals(getLibrary()) || "httpx2".equals(getLibrary());
     }

modules/openapi-generator/src/main/resources/python/_legacy_model_helpers.mustache

@@ -0,0 +1,5 @@
+{{>partial_header}}
+
+from typing import Any
+
+{{>_legacy_model_dict_helpers}}

modules/openapi-generator/src/main/resources/python/api_client.mustache

@@ -39,7 +39,12 @@ from {{packageName}}.exceptions import (
 
 {{#compatibleWithPythonLegacy}}
 
+{{#useLegacyModelHelpersModule}}
+from {{packageName}}._legacy_model_helpers import _get_openapi_to_dict
+{{/useLegacyModelHelpersModule}}
+{{^useLegacyModelHelpersModule}}
 {{>_legacy_model_identity}}
+{{/useLegacyModelHelpersModule}}
 
 
 {{/compatibleWithPythonLegacy}}

modules/openapi-generator/src/main/resources/python/model_anyof.mustache

@@ -16,7 +16,17 @@ from pydantic import Field
 from pydantic_core import to_jsonable_python
 
 
+{{#useLegacyModelHelpersModule}}
+from {{packageName}}._legacy_model_helpers import (
+    _OPENAPI_GENERATOR_TO_DICT,
+    _get_openapi_to_dict,
+    _to_legacy_value,
+    _to_openapi_value,
+)
+{{/useLegacyModelHelpersModule}}
+{{^useLegacyModelHelpersModule}}
 {{>_legacy_model_dict_helpers}}
+{{/useLegacyModelHelpersModule}}
 
 {{/compatibleWithPythonLegacy}}
 

modules/openapi-generator/src/main/resources/python/model_generic.mustache

@@ -35,7 +35,17 @@ if TYPE_CHECKING:
 {{/hasChildren}}
 {{#compatibleWithPythonLegacy}}
 
+{{#useLegacyModelHelpersModule}}
+from {{packageName}}._legacy_model_helpers import (
+    _OPENAPI_GENERATOR_TO_DICT,
+    _get_openapi_to_dict,
+    _to_legacy_value,
+    _to_openapi_value,
+)
+{{/useLegacyModelHelpersModule}}
+{{^useLegacyModelHelpersModule}}
 {{>_legacy_model_dict_helpers}}
+{{/useLegacyModelHelpersModule}}
 
 
 {{/compatibleWithPythonLegacy}}

modules/openapi-generator/src/main/resources/python/model_oneof.mustache

@@ -14,7 +14,17 @@ from typing_extensions import Literal, Self
 from pydantic_core import to_jsonable_python
 
 
+{{#useLegacyModelHelpersModule}}
+from {{packageName}}._legacy_model_helpers import (
+    _OPENAPI_GENERATOR_TO_DICT,
+    _get_openapi_to_dict,
+    _to_legacy_value,
+    _to_openapi_value,
+)
+{{/useLegacyModelHelpersModule}}
+{{^useLegacyModelHelpersModule}}
 {{>_legacy_model_dict_helpers}}
+{{/useLegacyModelHelpersModule}}
 
 {{/compatibleWithPythonLegacy}}
 

modules/openapi-generator/src/test/java/org/openapitools/codegen/python/PythonClientCodegenTest.java

@@ -1290,6 +1290,8 @@ public void testLegacyModelToDictRendering() throws IOException {
                 defaultOutputPath + "openapi_client/api/default_api.py");
         final Path defaultApiClient = Paths.get(
                 defaultOutputPath + "openapi_client/api_client.py");
+        final Path defaultLegacyHelpers = Paths.get(
+                defaultOutputPath + "openapi_client/_legacy_model_helpers.py");
 
         assertFileContains(defaultModel,
                 "return json.dumps(to_jsonable_python(self.to_dict()))",
@@ -1313,6 +1315,7 @@ public void testLegacyModelToDictRendering() throws IOException {
                 "async_req", "        _preload_content: bool = True",
                 "return self.api_client.pool.apply_async(");
         TestUtils.assertFileNotContains(defaultApiClient, "_OPENAPI_GENERATOR_TO_DICT");
+        Assert.assertFalse(Files.exists(defaultLegacyHelpers));
 
         final PythonClientCodegen codegen = new PythonClientCodegen();
         codegen.additionalProperties().put(
@@ -1326,12 +1329,12 @@ public void testLegacyModelToDictRendering() throws IOException {
         final Path api = Paths.get(
                 outputPath + "openapi_client/api/default_api.py");
         final Path apiClient = Paths.get(outputPath + "openapi_client/api_client.py");
+        final Path legacyHelpers = Paths.get(
+                outputPath + "openapi_client/_legacy_model_helpers.py");
 
         assertFileContains(model,
-                "def _get_openapi_to_dict(value: Any) -> Any:",
-                "def _to_legacy_item(value: Any, serialize: bool) -> Any:",
-                "def _to_legacy_value(value: Any, serialize: bool) -> Any:",
-                "def _to_openapi_value(value: Any) -> Any:",
+                "from openapi_client._legacy_model_helpers import (",
+                "    _OPENAPI_GENERATOR_TO_DICT,",
                 "def to_dict(self, serialize: bool = False) -> Dict[str, Any]:",
                 "_to_legacy_value(getattr(self, \"renamed\", None), serialize)",
                 "def __openapi_generator_modern_projection(self) -> Dict[str, Any]:",
@@ -1349,6 +1352,10 @@ public void testLegacyModelToDictRendering() throws IOException {
                 "def __eq__(self, other: object) -> bool:",
                 "def __ne__(self, other: object) -> bool:");
         TestUtils.assertFileNotContains(model,
+                "def _get_openapi_to_dict(value: Any) -> Any:",
+                "def _to_legacy_item(value: Any, serialize: bool) -> Any:",
+                "def _to_legacy_value(value: Any, serialize: bool) -> Any:",
+                "def _to_openapi_value(value: Any) -> Any:",
                 "_legacy_model_to_dict_impl: ClassVar", "def _to_openapi_dict(");
         assertFileContains(nestedModel,
                 "camel_case: Optional[StrictStr]",
@@ -1361,16 +1368,21 @@ public void testLegacyModelToDictRendering() throws IOException {
         for (String wrapper : Arrays.asList("one_of_model.py", "any_of_model.py")) {
             final Path wrapperModel = Paths.get(outputPath + "openapi_client/models/" + wrapper);
             assertFileContains(wrapperModel,
+                    "from openapi_client._legacy_model_helpers import (",
                     "def to_dict(self, serialize: bool = False) -> Any:",
                     "def __openapi_generator_modern_projection(self) -> Any:",
                     "del __openapi_generator_modern_projection");
             TestUtils.assertFileNotContains(wrapperModel,
+                    "def _get_openapi_to_dict(value: Any) -> Any:",
+                    "def _to_legacy_item(value: Any, serialize: bool) -> Any:",
+                    "def _to_legacy_value(value: Any, serialize: bool) -> Any:",
+                    "def _to_openapi_value(value: Any) -> Any:",
                     "_legacy_model_to_dict_impl: ClassVar", "def _to_openapi_dict(",
                     "openapi_types", "attribute_map", "extra=\"forbid\"",
                     "def __repr__", "def __eq__");
         }
         assertFileContains(apiClient,
-                "def _get_openapi_to_dict(value: Any) -> Any:",
+                "from openapi_client._legacy_model_helpers import _get_openapi_to_dict",
                 "to_dict = getattr(obj, 'to_dict', None)",
                 "to_openapi_dict = _get_openapi_to_dict(obj)",
                 "if to_openapi_dict is not None:",
@@ -1387,6 +1399,13 @@ public void testLegacyModelToDictRendering() throws IOException {
                 "response_types_map: Dict[str, Optional[str]]",
                 "return self._get_pool().apply_async(call)",
                 "response_data.getheaders()");
+        TestUtils.assertFileNotContains(apiClient,
+                "def _get_openapi_to_dict(value: Any) -> Any:");
+        assertFileContains(legacyHelpers,
+                "def _get_openapi_to_dict(value: Any) -> Any:",
+                "def _to_legacy_item(value: Any, serialize: bool) -> Any:",
+                "def _to_legacy_value(value: Any, serialize: bool) -> Any:",
+                "def _to_openapi_value(value: Any) -> Any:");
         assertFileContains(api,
                 "async_req: Optional[bool] = None",
                 "_preload_content: bool = True",
@@ -1485,9 +1504,9 @@ public void testLegacyModelToDictSupportsModelOnlyGeneration() throws IOExceptio
                     "def _to_legacy_item(value: Any, serialize: bool) -> Any:",
                     "def _to_legacy_value(value: Any, serialize: bool) -> Any:",
                     "def _to_openapi_value(value: Any) -> Any:");
-            TestUtils.assertFileNotContains(model, "_legacy_model_dict import");
+            TestUtils.assertFileNotContains(model, "_legacy_model_helpers import");
             Assert.assertFalse(Files.exists(Paths.get(
-                    outputPath + "openapi_client/_legacy_model_dict.py")));
+                    outputPath + "openapi_client/_legacy_model_helpers.py")));
         } finally {
             if (oldModels == null) {
                 GlobalSettings.clearProperty(CodegenConstants.MODELS);
@@ -1497,6 +1516,65 @@ public void testLegacyModelToDictSupportsModelOnlyGeneration() throws IOExceptio
         }
     }
 
+    @Test
+    public void testLegacyModelHelpersFollowSourceFolder() throws IOException {
+        final PythonClientCodegen codegen = new PythonClientCodegen();
+        codegen.setCompatibleWithPythonLegacy(true);
+        codegen.additionalProperties().put(CodegenConstants.SOURCE_FOLDER, "src");
+        addModelAttributeNameMappings(codegen);
+
+        final String outputPath = generateFiles(codegen,
+                "src/test/resources/3_0/python/legacy-model-dictionaries.yaml");
+        final Path model = Paths.get(
+                outputPath + "src/openapi_client/models/legacy_model.py");
+        final Path legacyHelpers = Paths.get(
+                outputPath + "src/openapi_client/_legacy_model_helpers.py");
+
+        assertFileContains(model,
+                "from openapi_client._legacy_model_helpers import (");
+        assertFileExists(legacyHelpers);
+        Assert.assertFalse(Files.exists(Paths.get(
+                outputPath + "openapi_client/_legacy_model_helpers.py")));
+    }
+
+    @Test
+    public void testLegacyModelHelpersStayInlineForWhitespaceOnlySupportingFiles() throws IOException {
+        final String oldModels = GlobalSettings.getProperty(CodegenConstants.MODELS);
+        final String oldSupportingFiles = GlobalSettings.getProperty(CodegenConstants.SUPPORTING_FILES);
+        try {
+            GlobalSettings.setProperty(CodegenConstants.MODELS, "");
+            GlobalSettings.setProperty(CodegenConstants.SUPPORTING_FILES, " ");
+            final PythonClientCodegen codegen = new PythonClientCodegen();
+            codegen.setCompatibleWithPythonLegacy(true);
+            addModelAttributeNameMappings(codegen);
+
+            final String outputPath = generateFiles(codegen,
+                    "src/test/resources/3_0/python/legacy-model-dictionaries.yaml");
+            final Path model = Paths.get(
+                    outputPath + "openapi_client/models/legacy_model.py");
+
+            assertFileContains(model,
+                    "def _get_openapi_to_dict(value: Any) -> Any:",
+                    "def _to_legacy_item(value: Any, serialize: bool) -> Any:",
+                    "def _to_legacy_value(value: Any, serialize: bool) -> Any:",
+                    "def _to_openapi_value(value: Any) -> Any:");
+            TestUtils.assertFileNotContains(model, "_legacy_model_helpers import");
+            Assert.assertFalse(Files.exists(Paths.get(
+                    outputPath + "openapi_client/_legacy_model_helpers.py")));
+        } finally {
+            if (oldModels == null) {
+                GlobalSettings.clearProperty(CodegenConstants.MODELS);
+            } else {
+                GlobalSettings.setProperty(CodegenConstants.MODELS, oldModels);
+            }
+            if (oldSupportingFiles == null) {
+                GlobalSettings.clearProperty(CodegenConstants.SUPPORTING_FILES);
+            } else {
+                GlobalSettings.setProperty(CodegenConstants.SUPPORTING_FILES, oldSupportingFiles);
+            }
+        }
+    }
+
     @Test
     public void testModelPublicNameRejectsInvalidPythonNames() {
         for (String publicName : Arrays.asList(

samples/client/others/python-legacy-model-dictionaries/.openapi-generator/FILES

@@ -12,6 +12,7 @@ docs/NestedModel.md
 docs/OneOfModel.md
 git_push.sh
 legacy_model_dict_client/__init__.py
+legacy_model_dict_client/_legacy_model_helpers.py
 legacy_model_dict_client/api/__init__.py
 legacy_model_dict_client/api/default_api.py
 legacy_model_dict_client/api_client.py

samples/client/others/python-legacy-model-dictionaries/legacy_model_dict_client/_legacy_model_helpers.py

@@ -0,0 +1,80 @@
+"""
+    Legacy model dictionaries
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from typing import Any
+
+_OPENAPI_GENERATOR_TO_DICT = "_openapi_generator_to_dict"
+
+
+def _get_openapi_to_dict(value: Any) -> Any:
+    # Reciprocal function references preserve inherited generated methods
+    # without reserving model member names. Checking both directions also
+    # rejects overrides whose decorators copy function attributes.
+    to_dict = getattr(value, "to_dict", None)
+    type_to_dict = getattr(type(value), "to_dict", None)
+    if (
+        not callable(to_dict)
+        or getattr(to_dict, "__func__", None) is not type_to_dict
+    ):
+        return None
+
+    openapi_to_dict = getattr(
+        type_to_dict, _OPENAPI_GENERATOR_TO_DICT, None
+    )
+    if (
+        not callable(openapi_to_dict)
+        or getattr(
+            openapi_to_dict,
+            _OPENAPI_GENERATOR_TO_DICT,
+            None,
+        ) is not type_to_dict
+    ):
+        return None
+    return openapi_to_dict
+
+
+def _to_legacy_item(value: Any, serialize: bool) -> Any:
+    to_dict = getattr(value, "to_dict", None)
+    if _get_openapi_to_dict(value) is not None and callable(to_dict):
+        return to_dict(serialize=serialize)
+    if callable(to_dict):
+        return to_dict()
+    return value
+
+
+def _to_legacy_value(value: Any, serialize: bool) -> Any:
+    # python-legacy converted only immediate list elements or dictionary values:
+    # https://github.com/OpenAPITools/openapi-generator/blob/c84b949df1a9ec04ba75989cb49b45c940c2f694/modules/openapi-generator/src/main/resources/python-legacy/model.mustache#L203-L231
+    if isinstance(value, list):
+        return [_to_legacy_item(item, serialize) for item in value]
+    if isinstance(value, dict):
+        return {
+            key: _to_legacy_item(item, serialize)
+            for key, item in value.items()
+        }
+    return _to_legacy_item(value, serialize)
+
+
+def _to_openapi_value(value: Any) -> Any:
+    if isinstance(value, list):
+        return [_to_openapi_value(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _to_openapi_value(item) for key, item in value.items()}
+
+    to_openapi_dict = _get_openapi_to_dict(value)
+    if to_openapi_dict is not None:
+        return to_openapi_dict(value)
+
+    to_dict = getattr(value, "to_dict", None)
+    if callable(to_dict):
+        return to_dict()
+    return value