Merge pull request #13 from MarcoMuellner/11-circular-import-in-generated-gitea-api-client

11 circular import in generated gitea api client

Author: MarcoMuellner

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openapi-python-generator"
-version = "0.4.0"
+version = "0.4.1"
 description = "Openapi Python Generator"
 authors = ["Marco Müllner <[email protected]>"]
 license = "MIT"

pyproject.toml

@@ -21,10 +21,11 @@
 from openapi_python_generator.models import TypeConversion
 
 
-def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
+def type_converter(schema: Schema,  required: bool = False, model_name: Optional[str] = None,) -> TypeConversion:
     """
     Converts an OpenAPI type to a Python type.
     :param schema: Schema containing the type to be converted
+    :param model_name: Name of the original model on which the type is defined
     :param required: Flag indicating if the type is required by the class
     :return: The converted type
     """
@@ -45,14 +46,23 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
                 conversions.append(type_converter(sub_schema, True))
             else:
                 import_type = sub_schema.ref.split("/")[-1]
-                import_types = [f"from .{import_type} import {import_type}"]
-                conversions.append(
-                    TypeConversion(
-                        original_type=sub_schema.ref,
-                        converted_type=import_type,
-                        import_types=import_types,
+                if import_type == model_name:
+                    conversions.append(
+                        TypeConversion(
+                            original_type=sub_schema.ref,
+                            converted_type='"' + model_name + '"',
+                            import_types=None,
+                        )
+                    )
+                else:
+                    import_types = [f"from .{import_type} import {import_type}"]
+                    conversions.append(
+                        TypeConversion(
+                            original_type=sub_schema.ref,
+                            converted_type=import_type,
+                            import_types=import_types,
+                        )
                     )
-                )
 
         original_type = (
             "tuple<" + ",".join([i.original_type for i in conversions]) + ">"
@@ -121,10 +131,10 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
     elif schema.type == "array":
         retVal = pre_type + "List["
         if isinstance(schema.items, Reference):
-            import_type = schema.items.ref.split("/")[-1]
-            import_types = [f"from .{import_type} import {import_type}"]
-            original_type = "array<" + schema.items.ref.split("/")[-1] + ">"
-            retVal += schema.items.ref.split("/")[-1]
+            converted_reference = _generate_property_from_reference(model_name, "", schema.items, schema, required)
+            import_types = converted_reference.type.import_types
+            original_type = "array<" + converted_reference.type.original_type + ">"
+            retVal += converted_reference.type.converted_type
         elif isinstance(schema.items, Schema):
             original_type = "array<" + str(schema.items.type) + ">"
             retVal += type_converter(schema.items, True).converted_type
@@ -148,11 +158,12 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
 
 
 def _generate_property_from_schema(
-    name: str, schema: Schema, parent_schema: Optional[Schema] = None
+    model_name : str, name: str, schema: Schema, parent_schema: Optional[Schema] = None
 ) -> Property:
     """
     Generates a property from a schema. It takes the type of the schema and converts it to a python type, and then
     creates the according property.
+    :param model_name: Name of the model this property belongs to
     :param name: Name of the schema
     :param schema: schema to be converted
     :param parent_schema: Component this belongs to
@@ -165,35 +176,43 @@ def _generate_property_from_schema(
     )
     return Property(
         name=name,
-        type=type_converter(schema, required),
+        type=type_converter(schema, required, model_name),
         required=required,
         default=None if required else "None",
     )
 
 
 def _generate_property_from_reference(
-    name: str, reference: Reference, parent_schema: Optional[Schema] = None
+        model_name: str, name: str, reference: Reference, parent_schema: Optional[Schema] = None, force_required: bool = False
 ) -> Property:
     """
     Generates a property from a reference. It takes the name of the reference as the type, and then
     returns a property type
     :param name: Name of the schema
     :param reference: reference to be converted
     :param parent_schema: Component this belongs to
+    :param force_required: Force the property to be required
     :return: Property and model to be imported by the file
     """
     required = (
         parent_schema is not None
         and parent_schema.required is not None
         and name in parent_schema.required
-    )
+    ) or force_required
     import_model = reference.ref.split("/")[-1]
 
-    type_conv = TypeConversion(
-        original_type=reference.ref,
-        converted_type=import_model if required else "Optional[" + import_model + "]",
-        import_types=[f"from .{import_model} import {import_model}"],
-    )
+    if import_model == model_name:
+        type_conv = TypeConversion(
+            original_type=reference.ref,
+            converted_type=import_model if required else 'Optional["' + import_model + '"]',
+            import_types=None
+        )
+    else:
+        type_conv = TypeConversion(
+            original_type=reference.ref,
+            converted_type=import_model if required else "Optional[" + import_model + "]",
+            import_types=[f"from .{import_model} import {import_model}"],
+        )
     return Property(
         name=name,
         type=type_conv,
@@ -250,11 +269,11 @@ def generate_models(components: Components) -> List[Model]:
         for prop_name, property in property_iterator:
             if isinstance(property, Reference):
                 conv_property = _generate_property_from_reference(
-                    prop_name, property, schema_or_reference
+                    name, prop_name, property, schema_or_reference
                 )
             else:
                 conv_property = _generate_property_from_schema(
-                    prop_name, property, schema_or_reference
+                    name, prop_name, property, schema_or_reference
                 )
             properties.append(conv_property)
 

src/openapi_python_generator/language_converters/python/model_generator.py

@@ -18,5 +18,5 @@ class {{ schema_name }}(BaseModel):
     """
     {% for property in properties %}
 
-    {{ property.name | replace("@","")}} : {{ property.type.converted_type }} = Field(alias="{{ property.name }}" {% if not property.required %}, default = {{ property.default }} {% endif %})
+    {{ property.name | replace("@","")}} : {{ property.type.converted_type | safe }} = Field(alias="{{ property.name }}" {% if not property.required %}, default = {{ property.default }} {% endif %})
     {% endfor %}

src/openapi_python_generator/language_converters/python/templates/models.jinja2

@@ -0,0 +1,33 @@
+import pytest
+from click.testing import CliRunner
+
+from openapi_python_generator.__main__ import main
+from openapi_python_generator.common import HTTPLibrary
+from tests.conftest import test_data_folder
+from tests.conftest import test_result_path
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    """Fixture for invoking command-line interfaces."""
+    return CliRunner()
+
+@pytest.mark.parametrize(
+    "library",
+    [HTTPLibrary.httpx, HTTPLibrary.requests, HTTPLibrary.aiohttp],
+)
+def test_issue_11(runner: CliRunner, model_data_with_cleanup, library) -> None:
+    """
+    https://github.com/MarcoMuellner/openapi-python-generator/issues/7
+    """
+    result = runner.invoke(
+        main,
+        [
+            str(test_data_folder / "openapi_gitea_converted.json"),
+            str(test_result_path),
+            "--library",
+            library.value,
+        ],
+    )
+    assert result.exit_code == 0
+

tests/regression/test_issue_11.py

@@ -1,5 +1,6 @@
 import json
 import os
+import traceback
 from datetime import datetime
 
 import orjson
@@ -205,9 +206,14 @@ def test_generate_code(model_data_with_cleanup, library, use_orjson):
     exec(exec_code_base, globals(), _locals)
     assert root_route.called
 
-    exec_code_base = f"from .test_result import *\nresp_result = get_users_users_get()"
+    exec_code_base = f"try:\n\tfrom .test_result import *\n\tresp_result = get_users_users_get()\nexcept Exception as e:\n\tprint(e)\n\traise e"
 
-    exec(exec_code_base, globals(), _locals)
+    try:
+        exec(exec_code_base, globals(), _locals)
+    except Exception as e:
+        print(e)
+        print(traceback.format_exc())
+        raise e
 
     exec(
         "from .test_result.services.general_service import *\nassert isinstance(resp_result, list)",

tests/test_data/gitea_issue_11.json

@@ -59,7 +59,7 @@
         (
             Schema(type="array", items=Reference(ref="#/components/schemas/test_name")),
             TypeConversion(
-                original_type="array<test_name>",
+                original_type="array<#/components/schemas/test_name>",
                 converted_type="List[test_name]",
                 import_types=["from .test_name import test_name"],
             ),
@@ -72,10 +72,19 @@
 )
 def test_type_converter_simple(test_openapi_types, expected_python_types):
     assert type_converter(test_openapi_types, True) == expected_python_types
-    assert (
-        type_converter(test_openapi_types, False).converted_type
-        == "Optional[" + expected_python_types.converted_type + "]"
-    )
+
+    if test_openapi_types.type == "array" and isinstance(test_openapi_types.items, Reference):
+        expected_type = expected_python_types.converted_type.split("[")[-1].split("]")[0]
+
+        assert (
+            type_converter(test_openapi_types, False).converted_type
+            == "Optional[List[Optional[" + expected_type + "]]]"
+        )
+    else:
+        assert (
+            type_converter(test_openapi_types, False).converted_type
+            == "Optional[" + expected_python_types.converted_type + "]"
+        )
 
 
 @pytest.mark.parametrize(
@@ -120,7 +129,7 @@ def test_type_converter_simple(test_openapi_types, expected_python_types):
         (
             Schema(type="array", items=Reference(ref="#/components/schemas/test_name")),
             TypeConversion(
-                original_type="array<test_name>",
+                original_type="array<#/components/schemas/test_name>",
                 converted_type="List[test_name]",
                 import_types=["from .test_name import test_name"],
             ),
@@ -135,11 +144,19 @@ def test_type_converter_simple_orjson(test_openapi_types, expected_python_types)
     orjson_usage = common.get_use_orjson()
     common.set_use_orjson(True)
     assert type_converter(test_openapi_types, True) == expected_python_types
-    assert (
-        type_converter(test_openapi_types, False).converted_type
-        == "Optional[" + expected_python_types.converted_type + "]"
-    )
-    common.set_use_orjson(orjson_usage)
+    if test_openapi_types.type == "array" and isinstance(test_openapi_types.items, Reference):
+        expected_type = expected_python_types.converted_type.split("[")[-1].split("]")[0]
+
+        assert (
+            type_converter(test_openapi_types, False).converted_type
+            == "Optional[List[Optional[" + expected_type + "]]]"
+        )
+    else:
+        assert (
+            type_converter(test_openapi_types, False).converted_type
+            == "Optional[" + expected_python_types.converted_type + "]"
+        )
+        common.set_use_orjson(orjson_usage)
 
 
 def test_type_converter_all_of_reference():
@@ -211,9 +228,10 @@ def test_type_converter_exceptions():
 
 
 @pytest.mark.parametrize(
-    "test_name, test_schema, test_parent_schema, expected_property",
+    "test_model_name, test_name, test_schema, test_parent_schema, expected_property",
     [
         (
+            "SomeModel",
             "test_name",
             Schema(type="string"),
             Schema(type="object"),
@@ -227,6 +245,7 @@ def test_type_converter_exceptions():
             ),
         ),
         (
+            "SomeModel",
             "test_name",
             Schema(type="string"),
             Schema(type="object", required=["test_name"]),
@@ -237,13 +256,25 @@ def test_type_converter_exceptions():
                 imported_type=["test_name"],
             ),
         ),
+        (
+            "SomeModel",
+            "SomeModel",
+            Schema(allOf=[Reference(ref="#/components/schemas/SomeModel")]),
+            Schema(type="object", required=["SomeModel"]),
+            Property(
+                name='SomeModel',
+                type=TypeConversion(original_type='tuple<#/components/schemas/SomeModel>', converted_type='"SomeModel"',import_types = []),
+                required=True,
+                imported_type=[],
+            ),
+        ),
     ],
 )
 def test_type_converter_property(
-    test_name, test_schema, test_parent_schema, expected_property
+    test_model_name, test_name, test_schema, test_parent_schema, expected_property
 ):
     assert (
-        _generate_property_from_schema(test_name, test_schema, test_parent_schema)
+        _generate_property_from_schema(test_model_name,test_name, test_schema, test_parent_schema)
         == expected_property
     )
 
@@ -289,7 +320,7 @@ def test_type_converter_property_reference(
     test_name, test_reference, parent_schema, expected_property
 ):
     assert (
-        _generate_property_from_reference(test_name, test_reference, parent_schema)
+        _generate_property_from_reference("",test_name, test_reference, parent_schema)
         == expected_property
     )
 

tests/test_generated_code.py

@@ -370,6 +370,47 @@ def test_generate_query_params(test_openapi_operation, expected_result):
                 complex_type=True,
             ),
         ),
+        (
+            Operation(
+                responses={
+                    "200": Response(
+                        description="Successful Response",
+                        content={"application/json": MediaType(media_type_schema=Reference(ref="#/components/schemas/User"))}
+                    )
+                }
+            ),
+            OpReturnType(
+                type=TypeConversion(
+                    original_type="#/components/schemas/User",
+                    converted_type="User",
+                    import_types=["User"],
+                ),
+                status_code="200",
+                complex_type=True,
+            )
+
+        ),
+        (
+                Operation(
+                    responses={
+                        "200": Response(
+                            description="Successful Response",
+                            content={"application/json": MediaType(media_type_schema=Schema(type='array',items=Reference(ref="#/components/schemas/User")))}
+                        )
+                    }
+                ),
+                OpReturnType(
+                    type=TypeConversion(
+                        original_type="array<#/components/schemas/User>",
+                        converted_type="List[User]",
+                        import_types=['from .User import User'],
+                    ),
+                    status_code="200",
+                    complex_type=True,
+                    list_type="User"
+                )
+
+        ),
         (
             Operation(
                 responses={