Added template for enums

improved codecov

Author: MarcoMuellner

README.md

@@ -23,11 +23,16 @@
 
 ## Features
 
-- TODO
+- Easy code generation for OpenAPI 3.0.0+ APIs
+- Async and Sync code generation support (with the help of [httpx](https://pypi.org/project/httpx/))])
+- Typed services and models for your convinience
+- Support for HttpBearer authentication
+- Python only
+- Usage as CLI tool or as a library
 
 ## Requirements
 
-- TODO
+- Python 3.7+
 
 ## Installation
 
@@ -41,6 +46,12 @@ $ pip install openapi-python-generator
 
 Please see the [Command-line Reference] for details.
 
+## Roadmap
+
+- Support for all commonly used http libraries in the python ecosystem (requests, urllib, ...)
+- Support for multiple languages
+- Support for multiple authentication schemes
+
 ## Contributing
 
 Contributions are very welcome.

codecov.yml

@@ -3,7 +3,7 @@ coverage:
   status:
     project:
       default:
-        target: "100"
+        target: "85"
     patch:
       default:
-        target: "100"
+        target: "85"

src/openapi_python_generator/__main__.py

@@ -2,8 +2,8 @@
 
 import typer
 
-from .common import HTTPLibrary
-from .generate_data import generate_data
+from openapi_python_generator.common import HTTPLibrary
+from openapi_python_generator.generate_data import generate_data
 
 app = typer.Typer()
 
@@ -16,5 +16,7 @@ def main(file_name :str, output : str, library : Optional[HTTPLibrary]  = HTTPLi
     generate_data(file_name, output, library)
 
 
-if __name__ == "__main__":
+
+if __name__ == "__main__": #pragma: no cover
     app()
+

src/openapi_python_generator/generate_data.py

@@ -39,13 +39,13 @@ def get_open_api(path: Union[str,Path]) -> OpenAPI:
             return OpenAPI(**orjson.loads(f.read()))
     except FileNotFoundError:
         typer.echo(f"File {path} not found. Please make sure to pass the path to the OpenAPI 3.0 specification.")
-        typer.Exit(1)
+        raise
     except ConnectError:
         typer.echo(f"Could not connect to {path}.")
-        typer.Exit(1)
+        raise
     except ValidationError:
         typer.echo(f"File {path} is not a valid OpenAPI 3.0 specification, or there may be a problem with your JSON.")
-        typer.Exit(1)
+        raise
 
 
 def write_data(data: ConversionResult, output: str):

src/openapi_python_generator/language_converters/python/jinja_config.py

@@ -2,6 +2,7 @@
 
 from jinja2 import Environment, FileSystemLoader
 
+ENUM_TEMPLATE = "enum.template"
 MODELS_TEMPLATE = "models.template"
 SERVICE_TEMPLATE = "service.template"
 HTTPX_TEMPLATE = "httpx.template"

src/openapi_python_generator/language_converters/python/model_generator.py

@@ -3,10 +3,9 @@
 import typer
 from openapi_schema_pydantic import Components, Reference, Schema
 
-from openapi_python_generator.language_converters.python.jinja_config import JINJA_ENV, MODELS_TEMPLATE
+from openapi_python_generator.language_converters.python.jinja_config import JINJA_ENV, MODELS_TEMPLATE, ENUM_TEMPLATE
 from openapi_python_generator.models import Model, Property
 
-
 def type_converter(schema: Schema, required: bool = False) -> str:
     """
     Converts an OpenAPI type to a Python type.
@@ -40,10 +39,9 @@ def type_converter(schema: Schema, required: bool = False) -> str:
             retVal += schema.items.ref.split("/")[-1]
         elif isinstance(schema.items, Schema):
             retVal += type_converter(schema.items, True)
-        elif schema.items is None:
-            retVal += "Any"
         else:
-            raise Exception(f"Unknown item type: {type(schema.items)}")
+            retVal += "Any"
+
         return retVal + "]" + post_type
     elif schema.type == "object":
         return pre_type + "Dict[str, Any]" + post_type
@@ -103,18 +101,29 @@ def generate_models(components: Components) -> List[Model]:
 
     for name, schema in components.schemas.items():
         if schema.enum is not None:
-            continue  # TODO generate enum class using different template
+            m = Model(
+                file_name=name,
+                content=JINJA_ENV.get_template(ENUM_TEMPLATE).render(name=name,**schema.dict()),
+                openapi_object=schema,
+                references=[],
+                properties=[],
+            )
+            try:
+                compile(m.content, "<string>", "exec")
+                models.append(m)
+            except SyntaxError as e: #pragma: no cover
+                typer.echo(f"Error in model {name}: {e}")
+
+            continue  #pragma: no cover
 
         import_models = []
         properties = []
         for prop_name, property in schema.properties.items():
             if isinstance(property, Reference):
                 conv_property, import_model = _generate_property_from_reference(prop_name, property, schema)
                 import_models.append(import_model)
-            elif isinstance(property, Schema):
-                conv_property = _generate_property_from_schema(prop_name, property, schema)
             else:
-                raise Exception(f"Unknown property type: {type(property)}")
+                conv_property = _generate_property_from_schema(prop_name, property, schema)
             properties.append(conv_property)
 
         generated_content = JINJA_ENV.get_template(MODELS_TEMPLATE).render(
@@ -126,9 +135,8 @@ def generate_models(components: Components) -> List[Model]:
 
         try:
             compile(generated_content, "<string>", "exec")
-        except SyntaxError as e:
-            typer.echo(f"Error in model {name}: {e}")
-            typer.Exit()
+        except SyntaxError as e: #pragma: no cover
+            typer.echo(f"Error in model {name}: {e}") #pragma: no cover
 
         models.append(Model(
             file_name=name,

src/openapi_python_generator/language_converters/python/service_generator.py

@@ -22,10 +22,8 @@ def generate_params(operation: Operation) -> List[str]:
     def _generate_params_from_content(content: Union[Reference, Schema]):
         if isinstance(content, Reference):
             return f"data : {content.ref.split('/')[-1]}"
-        elif isinstance(content, Schema):
-            return f"data : {type_converter(content, True)}"
         else:
-            raise Exception("Unknown content type")
+            return f"data : {type_converter(content, True)}"
 
     if operation.parameters is None and operation.requestBody is None:
         return []
@@ -36,11 +34,9 @@ def _generate_params_from_content(content: Union[Reference, Schema]):
             if isinstance(param.param_schema, Schema):
                 params.append(f"{param.name} : {type_converter(param.param_schema, param.required)}" + (
                     "" if param.required else " = None"))
-            elif isinstance(param.param_schema, Reference):
+            else:
                 params.append(
                     f"{param.name} : {param.param_schema.ref.split('/')[-1]}" + ("" if param.required else " = None"))
-            else:
-                raise Exception("Unknown param schema type")
 
     if operation.requestBody is not None:
         if isinstance(operation.requestBody.content, MediaType):

src/openapi_python_generator/language_converters/python/templates/enum.template

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class {{ name }}(Enum, str):
+    {% for enumItem in enum %}
+
+    {% if enumItem is string %}
+    {{ enumItem.lower() }} = '{{ enumItem }}'
+    {% else %}
+    value_{{ enumItem }} = {{ enumItem }}
+    {% endif %}
+    {% endfor %}

tests/__init__.py

@@ -1 +0,0 @@
-"""Test suite for the openapi_python_generator package."""

tests/conftest.py

@@ -7,7 +7,8 @@
 
 from openapi_schema_pydantic import OpenAPI
 
-test_data_path = Path(__file__).parent / "test_data" / "test_api.json"
+test_data_folder = Path(__file__).parent / "test_data"
+test_data_path = test_data_folder / "test_api.json"
 test_result_path = Path(__file__).parent / "test_result"
 
 

tests/test_data/failing_api.json

@@ -0,0 +1,2 @@
+{
+}

tests/test_data/test_api.json

@@ -63,12 +63,21 @@
             "type": "string",
             "description": "User token",
             "example": "test"
+          },
+          "complex_type": {
+            "ref":"#/components/schemas/TokenUser"
           }
         },
         "required": [
           "user_id",
           "token"
         ]
+      },
+      "EnumerationString": {
+        "enum" : ["test","test_2","test_3"]
+      },
+      "EnumerationInt": {
+        "enum" : [1,2,3]
       }
     }
   },

tests/test_generate_data.py

@@ -1,13 +1,37 @@
 import pytest
+from httpx import ConnectError
 
-from openapi_python_generator.generate_data import get_open_api, write_data
+from openapi_python_generator.generate_data import get_open_api, write_data, generate_data
 from openapi_python_generator.language_converters.python.generator import generator
-from tests.conftest import test_data_path, test_result_path
+from pydantic import ValidationError
+
+from tests.conftest import test_data_path, test_result_path, test_data_folder
 
 
 def test_get_open_api(model_data):
     assert get_open_api(test_data_path) == model_data
 
+    with pytest.raises(ConnectError):
+        assert get_open_api("http://test.com")
+
+    with pytest.raises(ValidationError):
+        assert get_open_api(test_data_folder / 'failing_api.json')
+
+def test_generate_data(model_data_with_cleanup):
+    generate_data(test_data_path,test_result_path)
+    assert test_result_path.exists()
+    assert test_result_path.is_dir()
+    assert (test_result_path / "api_config.py").exists()
+    assert (test_result_path / "models").exists()
+    assert (test_result_path / "models").is_dir()
+    assert (test_result_path / "services").exists()
+    assert (test_result_path / "services").is_dir()
+    assert (test_result_path / "models" / "__init__.py").exists()
+    assert (test_result_path / "services" / "__init__.py").exists()
+    assert (test_result_path / "services" / "__init__.py").is_file()
+    assert (test_result_path / "models" / "__init__.py").is_file()
+    assert (test_result_path / "__init__.py").exists()
+    assert (test_result_path / "__init__.py").is_file()
 
 def test_write_data(model_data_with_cleanup):
     result = generator(model_data_with_cleanup)

tests/test_model_generator.py

@@ -7,20 +7,19 @@
 
 
 @pytest.mark.parametrize("test_openapi_types,expected_python_types", [
-    ("string", "str"),
-    ("integer", "int"),
-    ("number", "float"),
-    ("boolean", "bool"),
-    ("array", "List[Any]"),
-    ("object", "Dict[str, Any]"),
-    ("null", "Any"),
+    (Schema(type='string'), "str"),
+    (Schema(type='integer'), "int"),
+    (Schema(type='number'), "float"),
+    (Schema(type='boolean'), "bool"),
+    (Schema(type='array'), "List[Any]"),
+    (Schema(type='array', items=Schema(type='string')), "List[str]"),
+    (Schema(type='array', items=Reference(ref='#/components/schemas/test_name')), "List[test_name]"),
+    (Schema(type='object'), "Dict[str, Any]"),
+    (Schema(type='null'), "Any"),
 ])
 def test_type_converter_simple(test_openapi_types, expected_python_types):
-    # Generate Schema object from test_openapi_types
-    schema = Schema(type=test_openapi_types)
-
-    assert type_converter(schema, True) == expected_python_types
-    assert type_converter(schema, False) == 'Optional[' + expected_python_types + ']'
+    assert type_converter(test_openapi_types, True) == expected_python_types
+    assert type_converter(test_openapi_types, False) == 'Optional[' + expected_python_types + ']'
 
 
 @pytest.mark.parametrize("test_openapi_types,expected_python_types", [
@@ -85,4 +84,3 @@ def test_model_generation(model_data: OpenAPI):
         assert i.content is not None
 
         compile(i.content, '<string>', 'exec')
-        

tests/test_service_generator.py

@@ -33,6 +33,15 @@ def test_generate_body_param(test_openapi_operation, expected_result):
                   required=True),
         Parameter(name="test2", param_in="path", param_schema=Schema(type="string"), required=False)
     ], ), ["test : TestModel", "test2 : Optional[str] = None"]),
+    (Operation(parameters=[
+        Parameter(name="test", param_in="query", param_schema=Reference(ref="#/components/schemas/TestModel"),
+                  required=True),
+        Parameter(name="test2", param_in="path", param_schema=Schema(type="string"), required=True),
+    ], requestBody=RequestBody(content={
+        "application/json": MediaType(
+            media_type_schema=Reference(ref="#/components/schemas/TestModel")
+        )
+    })), ["test : TestModel", "test2 : str", "data : TestModel"]),
     (Operation(parameters=[
         Parameter(name="test", param_in="query", param_schema=Reference(ref="#/components/schemas/TestModel"),
                   required=True),
@@ -42,6 +51,7 @@ def test_generate_body_param(test_openapi_operation, expected_result):
             media_type_schema=Reference(ref="#/components/schemas/TestModel")
         )
     })), ["test : TestModel", "test2 : str", "data : TestModel"])
+
 ])
 def test_generate_params(test_openapi_operation, expected_result):
     assert generate_params(test_openapi_operation) == expected_result