Rename Schema class to Model to disambiguate with OpenAPI term

Author: dbanty

CHANGELOG.md

@@ -4,11 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
 ## 0.5.0 - Unreleased
 ### Internal Changes
 - Switched OpenAPI document parsing to use 
     [openapi-schema-pydantic](https://github.com/kuimono/openapi-schema-pydantic/pull/1) (#103)
 
+
 ## 0.4.2 - 2020-06-13
 ### Additions
 - Support for responses with no content (#63 & #66). Thanks @acgray!

openapi_python_client/__init__.py

@@ -170,10 +170,10 @@ def _build_models(self) -> None:
         types_path.write_text(types_template.render())
 
         model_template = self.env.get_template("model.pyi")
-        for schema in self.openapi.schemas.values():
-            module_path = models_dir / f"{schema.reference.module_name}.py"
-            module_path.write_text(model_template.render(schema=schema))
-            imports.append(import_string_from_reference(schema.reference))
+        for model in self.openapi.models.values():
+            module_path = models_dir / f"{model.reference.module_name}.py"
+            module_path.write_text(model_template.render(model=model))
+            imports.append(import_string_from_reference(model.reference))
 
         # Generate enums
         enum_template = self.env.get_template("enum.pyi")

openapi_python_client/openapi_parser/openapi.py

@@ -167,9 +167,9 @@ def from_data(*, data: oai.Operation, path: str, method: str, tag: str) -> Endpo
 
 
 @dataclass
-class Schema:
+class Model:
     """
-    Describes a schema, AKA data model used in requests.
+    A data model used by the API- usually a Schema with type "object".
 
     These will all be converted to dataclasses in the client
     """
@@ -181,8 +181,8 @@ class Schema:
     relative_imports: Set[str]
 
     @staticmethod
-    def from_data(*, data: Union[oai.Reference, oai.Schema], name: str) -> Schema:
-        """ A single Schema from its OAI data
+    def from_data(*, data: Union[oai.Reference, oai.Schema], name: str) -> Model:
+        """ A single Model from its OAI data
 
         Args:
             data: Data of a single Schema
@@ -207,21 +207,21 @@ def from_data(*, data: Union[oai.Reference, oai.Schema], name: str) -> Schema:
                 optional_properties.append(p)
             relative_imports.update(p.get_imports(prefix=""))
 
-        schema = Schema(
+        model = Model(
             reference=ref,
             required_properties=required_properties,
             optional_properties=optional_properties,
             relative_imports=relative_imports,
             description=data.description or "",
         )
-        return schema
+        return model
 
     @staticmethod
-    def build(*, schemas: Dict[str, Union[oai.Reference, oai.Schema]]) -> Dict[str, Schema]:
+    def build(*, schemas: Dict[str, Union[oai.Reference, oai.Schema]]) -> Dict[str, Model]:
         """ Get a list of Schemas from an OpenAPI dict """
         result = {}
         for name, data in schemas.items():
-            s = Schema.from_data(data=data, name=name)
+            s = Model.from_data(data=data, name=name)
             result[s.reference.class_name] = s
         return result
 
@@ -233,7 +233,7 @@ class GeneratorData:
     title: str
     description: Optional[str]
     version: str
-    schemas: Dict[str, Schema]
+    models: Dict[str, Model]
     endpoint_collections_by_tag: Dict[str, EndpointCollection]
     enums: Dict[str, EnumProperty]
 
@@ -242,9 +242,9 @@ def from_dict(d: Dict[str, Dict[str, Any]]) -> GeneratorData:
         """ Create an OpenAPI from dict """
         openapi = oai.OpenAPI.parse_obj(d)
         if openapi.components is None or openapi.components.schemas is None:
-            schemas = {}
+            models = {}
         else:
-            schemas = Schema.build(schemas=openapi.components.schemas)
+            models = Model.build(schemas=openapi.components.schemas)
         endpoint_collections_by_tag = EndpointCollection.from_data(data=openapi.paths)
         enums = EnumProperty.get_all_enums()
 
@@ -253,6 +253,6 @@ def from_dict(d: Dict[str, Dict[str, Any]]) -> GeneratorData:
             description=openapi.info.description,
             version=openapi.info.version,
             endpoint_collections_by_tag=endpoint_collections_by_tag,
-            schemas=schemas,
+            models=models,
             enums=enums,
         )

openapi_python_client/templates/model.pyi

@@ -3,20 +3,20 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Dict
 
-{% for relative in schema.relative_imports %}
+{% for relative in model.relative_imports %}
 {{ relative }}
 {% endfor %}
 
 
 @dataclass
-class {{ schema.reference.class_name }}:
-    """ {{ schema.description }} """
-    {% for property in schema.required_properties + schema.optional_properties %}
+class {{ model.reference.class_name }}:
+    """ {{ model.description }} """
+    {% for property in model.required_properties + model.optional_properties %}
     {{ property.to_string() }}
     {% endfor %}
 
     def to_dict(self) -> Dict[str, Any]:
-        {% for property in schema.required_properties + schema.optional_properties %}
+        {% for property in model.required_properties + model.optional_properties %}
         {% if property.template %}
         {% from "property_templates/" + property.template import transform %}
         {{ transform(property, "self." + property.python_name, property.python_name) | indent(8) }}
@@ -26,14 +26,14 @@ class {{ schema.reference.class_name }}:
         {% endfor %}
 
         return {
-            {% for property in schema.required_properties + schema.optional_properties %}
+            {% for property in model.required_properties + model.optional_properties %}
             "{{ property.name }}": {{ property.python_name }},
             {% endfor %}
         }
 
     @staticmethod
-    def from_dict(d: Dict[str, Any]) -> {{ schema.reference.class_name }}:
-{% for property in schema.required_properties + schema.optional_properties %}
+    def from_dict(d: Dict[str, Any]) -> {{ model.reference.class_name }}:
+{% for property in model.required_properties + model.optional_properties %}
     {% if property.required %}
         {% set property_source = 'd["' + property.name + '"]' %}
     {% else %}
@@ -47,8 +47,8 @@ class {{ schema.reference.class_name }}:
     {% endif %}
 
 {% endfor %}
-        return {{ schema.reference.class_name }}(
-{% for property in schema.required_properties + schema.optional_properties %}
+        return {{ model.reference.class_name }}(
+{% for property in model.required_properties + model.optional_properties %}
             {{ property.python_name }}={{ property.python_name }},
 {% endfor %}
         )

tests/test___init__.py

@@ -260,9 +260,9 @@ def test__build_models(self, mocker):
         from openapi_python_client import GeneratorData, _Project
 
         openapi = mocker.MagicMock(autospec=GeneratorData, title="My Test API")
-        schema_1 = mocker.MagicMock()
-        schema_2 = mocker.MagicMock()
-        openapi.schemas = {"1": schema_1, "2": schema_2}
+        model_1 = mocker.MagicMock()
+        model_2 = mocker.MagicMock()
+        openapi.models = {"1": model_1, "2": model_2}
         enum_1 = mocker.MagicMock()
         enum_2 = mocker.MagicMock()
         openapi.enums = {"1": enum_1, "2": enum_2}
@@ -271,15 +271,15 @@ def test__build_models(self, mocker):
         models_init = mocker.MagicMock()
         types_py = mocker.MagicMock()
         models_dir = mocker.MagicMock()
-        schema_1_module_path = mocker.MagicMock()
-        schema_2_module_path = mocker.MagicMock()
+        model_1_module_path = mocker.MagicMock()
+        model_2_module_path = mocker.MagicMock()
         enum_1_module_path = mocker.MagicMock()
         enum_2_module_path = mocker.MagicMock()
         module_paths = {
             "__init__.py": models_init,
             "types.py": types_py,
-            f"{schema_1.reference.module_name}.py": schema_1_module_path,
-            f"{schema_2.reference.module_name}.py": schema_2_module_path,
+            f"{model_1.reference.module_name}.py": model_1_module_path,
+            f"{model_2.reference.module_name}.py": model_2_module_path,
             f"{enum_1.reference.module_name}.py": enum_1_module_path,
             f"{enum_2.reference.module_name}.py": enum_2_module_path,
         }
@@ -327,13 +327,13 @@ def models_dir_get(x):
         models_dir.mkdir.assert_called_once()
         models_dir.__truediv__.assert_has_calls([mocker.call(key) for key in module_paths])
         project.env.get_template.assert_has_calls([mocker.call(key) for key in templates])
-        model_template.render.assert_has_calls([mocker.call(schema=schema_1), mocker.call(schema=schema_2)])
-        schema_1_module_path.write_text.assert_called_once_with(model_render_1)
-        schema_2_module_path.write_text.assert_called_once_with(model_render_2)
+        model_template.render.assert_has_calls([mocker.call(model=model_1), mocker.call(model=model_2)])
+        model_1_module_path.write_text.assert_called_once_with(model_render_1)
+        model_2_module_path.write_text.assert_called_once_with(model_render_2)
         import_string_from_reference.assert_has_calls(
             [
-                mocker.call(schema_1.reference),
-                mocker.call(schema_2.reference),
+                mocker.call(model_1.reference),
+                mocker.call(model_2.reference),
                 mocker.call(enum_1.reference),
                 mocker.call(enum_2.reference),
             ]

tests/test_openapi_parser/test_openapi.py

@@ -8,7 +8,7 @@
 
 class TestGeneratorData:
     def test_from_dict(self, mocker):
-        Schema = mocker.patch(f"{MODULE_NAME}.Schema")
+        Model = mocker.patch(f"{MODULE_NAME}.Model")
         EndpointCollection = mocker.patch(f"{MODULE_NAME}.EndpointCollection")
         OpenAPI = mocker.patch(f"{MODULE_NAME}.oai.OpenAPI")
         openapi = OpenAPI.parse_obj.return_value
@@ -21,39 +21,39 @@ def test_from_dict(self, mocker):
         generator_data = GeneratorData.from_dict(in_dict)
 
         OpenAPI.parse_obj.assert_called_once_with(in_dict)
-        Schema.build.assert_called_once_with(schemas=openapi.components.schemas)
+        Model.build.assert_called_once_with(schemas=openapi.components.schemas)
         EndpointCollection.from_data.assert_called_once_with(data=openapi.paths)
         get_all_enums.assert_called_once_with()
         assert generator_data == GeneratorData(
             title=openapi.info.title,
             description=openapi.info.description,
             version=openapi.info.version,
             endpoint_collections_by_tag=EndpointCollection.from_data.return_value,
-            schemas=Schema.build.return_value,
+            models=Model.build.return_value,
             enums=get_all_enums.return_value,
         )
 
         # Test no components
         openapi.components = None
-        Schema.build.reset_mock()
+        Model.build.reset_mock()
 
         generator_data = GeneratorData.from_dict(in_dict)
 
-        Schema.build.assert_not_called()
-        assert generator_data.schemas == {}
+        Model.build.assert_not_called()
+        assert generator_data.models == {}
 
 
-class TestSchema:
+class TestModel:
     def test_build(self, mocker):
-        from_data = mocker.patch(f"{MODULE_NAME}.Schema.from_data")
+        from_data = mocker.patch(f"{MODULE_NAME}.Model.from_data")
         in_data = {1: mocker.MagicMock(), 2: mocker.MagicMock()}
         schema_1 = mocker.MagicMock()
         schema_2 = mocker.MagicMock()
         from_data.side_effect = [schema_1, schema_2]
 
-        from openapi_python_client.openapi_parser.openapi import Schema
+        from openapi_python_client.openapi_parser.openapi import Model
 
-        result = Schema.build(schemas=in_data)
+        result = Model.build(schemas=in_data)
 
         from_data.assert_has_calls([mocker.call(data=value, name=name) for (name, value) in in_data.items()])
         assert result == {
@@ -81,9 +81,9 @@ def test_from_data(self, mocker):
         )
         from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
 
-        from openapi_python_client.openapi_parser.openapi import Schema
+        from openapi_python_client.openapi_parser.openapi import Model
 
-        result = Schema.from_data(data=in_data, name=mocker.MagicMock())
+        result = Model.from_data(data=in_data, name=mocker.MagicMock())
 
         from_ref.assert_called_once_with(in_data.title)
         property_from_data.assert_has_calls(
@@ -94,7 +94,7 @@ def test_from_data(self, mocker):
         )
         required_property.get_imports.assert_called_once_with(prefix="")
         optional_property.get_imports.assert_called_once_with(prefix="")
-        assert result == Schema(
+        assert result == Model(
             reference=from_ref(),
             required_properties=[required_property],
             optional_properties=[optional_property],
@@ -103,10 +103,10 @@ def test_from_data(self, mocker):
         )
 
     def test_from_data_parse_error_on_reference(self):
-        from openapi_python_client.openapi_parser.openapi import Schema
+        from openapi_python_client.openapi_parser.openapi import Model
 
         with pytest.raises(ParseError):
-            Schema.from_data(data=oai.Reference.construct(), name="")
+            Model.from_data(data=oai.Reference.construct(), name="")
 
 
 class TestEndpoint: