feat: support inline form_body, not only refs

Additionally, refactor the form_body handling to be analog to multipart_body and json_body.

Author: supermihi

openapi_python_client/parser/openapi.py

@@ -118,20 +118,33 @@ class Endpoint:
     header_parameters: Dict[str, Property] = field(default_factory=dict)
     cookie_parameters: Dict[str, Property] = field(default_factory=dict)
     responses: List[Response] = field(default_factory=list)
-    form_body_class: Optional[Class] = None
+    form_body: Optional[Property] = None
     json_body: Optional[Property] = None
     multipart_body: Optional[Property] = None
     errors: List[ParseError] = field(default_factory=list)
     used_python_identifiers: Set[PythonIdentifier] = field(default_factory=set)
 
     @staticmethod
-    def parse_request_form_body(*, body: oai.RequestBody, config: Config) -> Optional[Class]:
-        """Return form_body_reference"""
+    def parse_request_form_body(
+        *, body: oai.RequestBody, schemas: Schemas, parent_name: str, config: Config
+    ) -> Tuple[Union[Property, PropertyError, None], Schemas]:
+        """Return form_body and updated schemas"""
         body_content = body.content
         form_body = body_content.get("application/x-www-form-urlencoded")
-        if form_body is not None and isinstance(form_body.media_type_schema, oai.Reference):
-            return Class.from_string(string=form_body.media_type_schema.ref, config=config)
-        return None
+        if form_body is not None and form_body.media_type_schema is not None:
+            prop, schemas = property_from_data(
+                name="data",
+                required=True,
+                data=form_body.media_type_schema,
+                schemas=schemas,
+                parent_name=parent_name,
+                config=config,
+            )
+            if isinstance(prop, ModelProperty):
+                prop = attr.evolve(prop, is_form_body=True)
+                schemas = attr.evolve(schemas, classes_by_name={**schemas.classes_by_name, prop.class_info.name: prop})
+            return prop, schemas
+        return None, schemas
 
     @staticmethod
     def parse_multipart_body(
@@ -186,7 +199,20 @@ def _add_body(
         if data.requestBody is None or isinstance(data.requestBody, oai.Reference):
             return endpoint, schemas
 
-        endpoint.form_body_class = Endpoint.parse_request_form_body(body=data.requestBody, config=config)
+        form_body, schemas = Endpoint.parse_request_form_body(
+            body=data.requestBody, schemas=schemas, parent_name=endpoint.name, config=config
+        )
+
+        if isinstance(form_body, ParseError):
+            return (
+                ParseError(
+                    header=f"Cannot parse form body of endpoint {endpoint.name}",
+                    detail=form_body.detail,
+                    data=form_body.data,
+                ),
+                schemas,
+            )
+
         json_body, schemas = Endpoint.parse_request_json_body(
             body=data.requestBody, schemas=schemas, parent_name=endpoint.name, config=config
         )
@@ -213,8 +239,9 @@ def _add_body(
                 schemas,
             )
 
-        if endpoint.form_body_class:
-            endpoint.relative_imports.add(import_string_from_class(endpoint.form_body_class, prefix="...models"))
+        if form_body is not None:
+            endpoint.form_body = form_body
+            endpoint.relative_imports.update(endpoint.form_body.get_imports(prefix="..."))
         if multipart_body is not None:
             endpoint.multipart_body = multipart_body
             endpoint.relative_imports.update(endpoint.multipart_body.get_imports(prefix="..."))
@@ -285,9 +312,9 @@ def add_parameters(
             config: User-provided config for overrides within parameters.
 
         Returns:
-            `(result, schemas)` where `result` is either an updated Endpoint containing the parameters or a ParseError
-                describing what went wrong. `schemas` is an updated version of the `schemas` input, adding any new enums
-                or classes.
+            `(result, schemas, parameters)` where `result` is either an updated Endpoint containing the parameters or a
+            ParseError describing what went wrong. `schemas` is an updated version of the `schemas` input, adding any
+            new enums or classes. `parameters` is an updated version of the `parameters` input, adding new parameters.
 
         See Also:
             - https://swagger.io/docs/specification/describing-parameters/

openapi_python_client/parser/properties/model_property.py

@@ -27,6 +27,7 @@ class ModelProperty(Property):
     template: ClassVar[str] = "model_property.py.jinja"
     json_is_dict: ClassVar[bool] = True
     is_multipart_body: bool = False
+    is_form_body: bool = False
 
     def get_base_type_string(self) -> str:
         return self.class_info.name

openapi_python_client/templates/endpoint_macros.py.jinja

@@ -90,8 +90,8 @@ client: AuthenticatedClient,
 client: Client,
 {% endif %}
 {# Form data if any #}
-{% if endpoint.form_body_class %}
-form_data: {{ endpoint.form_body_class.name }},
+{% if endpoint.form_body %}
+form_data: {{ endpoint.form_body.get_type_string() }},
 {% endif %}
 {# Multipart data if any #}
 {% if endpoint.multipart_body %}
@@ -120,7 +120,7 @@ json_body: {{ endpoint.json_body.get_type_string() }},
 {{ parameter.python_name }}={{ parameter.python_name }},
 {% endfor %}
 client=client,
-{% if endpoint.form_body_class %}
+{% if endpoint.form_body %}
 form_data=form_data,
 {% endif %}
 {% if endpoint.multipart_body %}

openapi_python_client/templates/endpoint_module.py.jinja

@@ -44,8 +44,8 @@ def _get_kwargs(
         "headers": headers,
         "cookies": cookies,
         "timeout": client.get_timeout(),
-        {% if endpoint.form_body_class %}
-        "data": form_data.to_dict(),
+        {% if endpoint.form_body %}
+        "data": {{ "form_" + endpoint.form_body.python_name }},
         {% elif endpoint.multipart_body %}
         "files": {{ "multipart_" + endpoint.multipart_body.python_name }},
         {% elif endpoint.json_body %}

tests/test_parser/test_openapi.py

@@ -134,34 +134,42 @@ def make_endpoint(self):
             relative_imports={"import_3"},
         )
 
-    def test_parse_request_form_body(self, mocker):
-        ref = mocker.MagicMock()
+    def test_parse_request_form_body(self, mocker, model_property_factory):
+        from openapi_python_client.parser.properties import Class
+
+        schema = oai.Reference.construct(ref=mocker.MagicMock())
         body = oai.RequestBody.construct(
-            content={
-                "application/x-www-form-urlencoded": oai.MediaType.construct(
-                    media_type_schema=oai.Reference.construct(ref=ref)
-                )
-            }
+            content={"application/x-www-form-urlencoded": oai.MediaType.construct(media_type_schema=schema)}
+        )
+        class_info = Class(name="class_name", module_name="module_name")
+        prop_before = model_property_factory(class_info=class_info, is_form_body=False)
+        schemas_before = Schemas()
+        property_from_data = mocker.patch(
+            f"{MODULE_NAME}.property_from_data", return_value=(prop_before, schemas_before)
         )
-        from_string = mocker.patch(f"{MODULE_NAME}.Class.from_string")
         config = mocker.MagicMock()
 
         from openapi_python_client.parser.openapi import Endpoint
 
-        result = Endpoint.parse_request_form_body(body=body, config=config)
+        result = Endpoint.parse_request_form_body(body=body, schemas=schemas_before, parent_name="name", config=config)
 
-        from_string.assert_called_once_with(string=ref, config=config)
-        assert result == from_string.return_value
+        property_from_data.assert_called_once_with(
+            name="data", required=True, data=schema, schemas=schemas_before, parent_name="name", config=config
+        )
+        prop_after = model_property_factory(class_info=class_info, is_form_body=True)
+        schemas_after = Schemas(classes_by_name={class_info.name: prop_after})
+        assert result == (prop_after, schemas_after)
 
     def test_parse_request_form_body_no_data(self):
         body = oai.RequestBody.construct(content={})
         config = MagicMock()
+        schemas = MagicMock()
 
         from openapi_python_client.parser.openapi import Endpoint
 
-        result = Endpoint.parse_request_form_body(body=body, config=config)
+        result = Endpoint.parse_request_form_body(body=body, schemas=schemas, parent_name="name", config=config)
 
-        assert result is None
+        assert result == (None, schemas)
 
     def test_parse_multipart_body(self, mocker, model_property_factory):
         from openapi_python_client.parser.openapi import Endpoint, Schemas
@@ -279,13 +287,13 @@ def test_add_body_no_data(self, mocker):
     def test_add_body_bad_json_data(self, mocker):
         from openapi_python_client.parser.openapi import Endpoint, Schemas
 
-        mocker.patch.object(Endpoint, "parse_request_form_body")
+        schemas = Schemas()
+        mocker.patch.object(Endpoint, "parse_request_form_body", return_value=(None, schemas))
         parse_error = ParseError(data=mocker.MagicMock(), detail=mocker.MagicMock())
         other_schemas = mocker.MagicMock()
         mocker.patch.object(Endpoint, "parse_request_json_body", return_value=(parse_error, other_schemas))
         endpoint = self.make_endpoint()
         request_body = mocker.MagicMock()
-        schemas = Schemas()
 
         result = Endpoint._add_body(
             endpoint=endpoint,
@@ -306,14 +314,14 @@ def test_add_body_bad_json_data(self, mocker):
     def test_add_body_bad_multipart_data(self, mocker):
         from openapi_python_client.parser.openapi import Endpoint, Schemas
 
-        mocker.patch.object(Endpoint, "parse_request_form_body")
+        schemas = Schemas()
+        mocker.patch.object(Endpoint, "parse_request_form_body", return_value=(None, schemas))
         mocker.patch.object(Endpoint, "parse_request_json_body", return_value=(mocker.MagicMock(), mocker.MagicMock()))
         parse_error = ParseError(data=mocker.MagicMock(), detail=mocker.MagicMock())
         other_schemas = mocker.MagicMock()
         mocker.patch.object(Endpoint, "parse_multipart_body", return_value=(parse_error, other_schemas))
         endpoint = self.make_endpoint()
         request_body = mocker.MagicMock()
-        schemas = Schemas()
 
         result = Endpoint._add_body(
             endpoint=endpoint,
@@ -332,13 +340,19 @@ def test_add_body_bad_multipart_data(self, mocker):
         )
 
     def test_add_body_happy(self, mocker):
-        from openapi_python_client.parser.openapi import Class, Endpoint
+        from openapi_python_client.parser.openapi import Endpoint
         from openapi_python_client.parser.properties import Property
 
         request_body = mocker.MagicMock()
         config = mocker.MagicMock()
-        form_body_class = Class(name="A", module_name="a")
-        parse_request_form_body = mocker.patch.object(Endpoint, "parse_request_form_body", return_value=form_body_class)
+
+        form_body = mocker.MagicMock(autospec=Property)
+        form_body_imports = mocker.MagicMock()
+        form_body.get_imports.return_value = {form_body_imports}
+        form_schemas = mocker.MagicMock()
+        parse_request_form_body = mocker.patch.object(
+            Endpoint, "parse_request_form_body", return_value=(form_body, form_schemas)
+        )
 
         multipart_body = mocker.MagicMock(autospec=Property)
         multipart_body_imports = mocker.MagicMock()
@@ -355,7 +369,6 @@ def test_add_body_happy(self, mocker):
         parse_request_json_body = mocker.patch.object(
             Endpoint, "parse_request_json_body", return_value=(json_body, json_schemas)
         )
-        import_string_from_class = mocker.patch(f"{MODULE_NAME}.import_string_from_class", return_value="import_1")
 
         endpoint = self.make_endpoint()
         initial_schemas = mocker.MagicMock()
@@ -368,19 +381,21 @@ def test_add_body_happy(self, mocker):
         )
 
         assert response_schemas == multipart_schemas
-        parse_request_form_body.assert_called_once_with(body=request_body, config=config)
-        parse_request_json_body.assert_called_once_with(
+        parse_request_form_body.assert_called_once_with(
             body=request_body, schemas=initial_schemas, parent_name="name", config=config
         )
+        parse_request_json_body.assert_called_once_with(
+            body=request_body, schemas=form_schemas, parent_name="name", config=config
+        )
         parse_multipart_body.assert_called_once_with(
             body=request_body, schemas=json_schemas, parent_name="name", config=config
         )
-        import_string_from_class.assert_called_once_with(form_body_class, prefix="...models")
+        form_body.get_imports.assert_called_once_with(prefix="...")
         json_body.get_imports.assert_called_once_with(prefix="...")
         multipart_body.get_imports.assert_called_once_with(prefix="...")
-        assert endpoint.relative_imports == {"import_1", "import_3", json_body_imports, multipart_body_imports}
+        assert endpoint.relative_imports == {"import_3", form_body_imports, json_body_imports, multipart_body_imports}
         assert endpoint.json_body == json_body
-        assert endpoint.form_body_class == form_body_class
+        assert endpoint.form_body == form_body
         assert endpoint.multipart_body == multipart_body
 
     def test__add_responses_status_code_error(self, mocker):