- Added "use-orjson" option

- Added orjson implementation for generated code
- Datetimes are now converted properly if orjson is used
- Adapted doc
- Adapted tests

Author: MarcoMuellner

docs/references/index.md

@@ -16,6 +16,7 @@ Arguments:
 Options:
 ```console
 --library                  The library to use. Defaults to `httpx`.
---autoformat               Specifies which auto formattool to apply to the generated code. Defaults to `black`.
+--env-token-name           The name of the environment variable to use for the API key. Defaults to `access_token`.
+--use-orjson               Use the `orjson` library for serialization. Defaults to `false`.
 -h, --help                 Show this help message and exit.
 ```

docs/tutorial/index.md

@@ -534,6 +534,11 @@ suite of the generator. It has the following structure:
           "is_active": {
             "title": "Is Active",
             "type": "boolean"
+          },
+          "created_at": {
+            "title": "Created At",
+            "type": "string",
+            "format": "date-time"
           }
         }
       },
@@ -657,6 +662,7 @@ take a look at the `User.py` and the `Team.py` files:
         email: str
         password: str
         is_active: Optional[bool] = None
+        created_at: Optional[str] = None
     ```
 
 === "Team.py"

src/openapi_python_generator/__main__.py

@@ -14,28 +14,39 @@
     "--library",
     default=HTTPLibrary.httpx,
     type=HTTPLibrary,
+    show_default=True,
     help="HTTP library to use in the generation of the client.",
 )
 @click.option(
     "--env-token-name",
     default="access_token",
+    show_default=True,
     help="Name of the environment variable that contains the token. If you set this, the code expects this environment "
     "variable to be set and will raise an error if it is not.",
 )
+@click.option(
+    "--use-orjson",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Use the orjson library to serialize the data. This is faster than the default json library and provides "
+    "serialization of datetimes and other types that are not supported by the default json library.",
+)
 @click.version_option(version=__version__)
 def main(
     source: str,
     output: str,
     library: Optional[HTTPLibrary] = HTTPLibrary.httpx,
     env_token_name: Optional[str] = None,
+    use_orjson: bool = False,
 ) -> None:
     """
     Generate Python code from an OpenAPI 3.0 specification.
 
     Provide a SOURCE (file or URL) containing the OpenAPI 3 specification and
     an OUTPUT path, where the resulting client is created.
     """
-    generate_data(source, output, library, env_token_name)
+    generate_data(source, output, library, env_token_name, use_orjson)
 
 
 if __name__ == "__main__":  # pragma: no cover

src/openapi_python_generator/generate_data.py

@@ -115,10 +115,7 @@ def write_data(data: ConversionResult, output: Union[str, Path]) -> None:
         )
 
     # Create services.__init__.py file containing imports to all services.
-    write_code(
-        services_path / "__init__.py",
-        "\n".join([f"from .{file} import *" for file in files]),
-    )
+    write_code(services_path / "__init__.py", "")
 
     # Write the api_config.py file.
     write_code(Path(output) / "api_config.py", data.api_config.content)
@@ -135,11 +132,12 @@ def generate_data(
     output: Union[str, Path],
     library: Optional[HTTPLibrary] = HTTPLibrary.httpx,
     env_token_name: Optional[str] = None,
+    use_orjson: bool = False,
 ) -> None:
     """
     Generate Python code from an OpenAPI 3.0 specification.
     """
     data = get_open_api(source)
     click.echo(f"Generating data from {source}")
-    result = generator(data, library_config_dict[library], env_token_name)
+    result = generator(data, library_config_dict[library], env_token_name, use_orjson)
     write_data(result, output)

src/openapi_python_generator/language_converters/python/common.py

@@ -0,0 +1,19 @@
+_use_orjson: bool = False
+
+
+def set_use_orjson(value: bool) -> None:
+    """
+    Set the value of the global variable _use_orjson.
+    :param value: value of the variable
+    """
+    global _use_orjson
+    _use_orjson = value
+
+
+def get_use_orjson() -> bool:
+    """
+    Get the value of the global variable _use_orjson.
+    :return: value of the variable
+    """
+    global _use_orjson
+    return _use_orjson

src/openapi_python_generator/language_converters/python/generator.py

@@ -2,6 +2,7 @@
 
 from openapi_schema_pydantic import OpenAPI
 
+from openapi_python_generator.language_converters.python import common
 from openapi_python_generator.language_converters.python.api_config_generator import (
     generate_api_config,
 )
@@ -16,12 +17,17 @@
 
 
 def generator(
-    data: OpenAPI, library_config: LibraryConfig, env_token_name: Optional[str] = None
+    data: OpenAPI,
+    library_config: LibraryConfig,
+    env_token_name: Optional[str] = None,
+    use_orjson: bool = False,
 ) -> ConversionResult:
     """
     Generate Python code from an OpenAPI 3.0 specification.
     """
 
+    common.set_use_orjson(use_orjson)
+
     if data.components is not None:
         models = generate_models(data.components)
     else:

src/openapi_python_generator/language_converters/python/model_generator.py

@@ -7,6 +7,7 @@
 from openapi_schema_pydantic import Reference
 from openapi_schema_pydantic import Schema
 
+from openapi_python_generator.language_converters.python import common
 from openapi_python_generator.language_converters.python.jinja_config import (
     ENUM_TEMPLATE,
 )
@@ -42,11 +43,12 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
             if isinstance(sub_schema, Schema):
                 conversions.append(type_converter(sub_schema, True))
             else:
-                import_types = [sub_schema.ref.split("/")[-1]]
+                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_types[0],
+                        converted_type=import_type,
                         import_types=import_types,
                     )
                 )
@@ -73,11 +75,12 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
             if isinstance(sub_schema, Schema):
                 conversions.append(type_converter(sub_schema, True))
             else:
-                import_types = [sub_schema.ref.split("/")[-1]]
+                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_types[0],
+                        converted_type=import_type,
                         import_types=import_types,
                     )
                 )
@@ -96,8 +99,15 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
                 *[i.import_types for i in conversions if i.import_types is not None]
             )
         )
-    elif schema.type == "string":
+    # We only want to auto convert to datetime if orjson is used throghout the code, otherwise we can not
+    # serialize it to JSON.
+    elif schema.type == "string" and (
+        schema.schema_format is None or not common.get_use_orjson()
+    ):
         converted_type = pre_type + "str" + post_type
+    elif schema.type == "string" and schema.schema_format == "date-time":
+        converted_type = pre_type + "datetime" + post_type
+        import_types = ["from datetime import datetime"]
     elif schema.type == "integer":
         converted_type = pre_type + "int" + post_type
     elif schema.type == "number":
@@ -107,7 +117,8 @@ def type_converter(schema: Schema, required: bool = False) -> TypeConversion:
     elif schema.type == "array":
         retVal = pre_type + "List["
         if isinstance(schema.items, Reference):
-            import_types = [schema.items.ref.split("/")[-1]]
+            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]
         elif isinstance(schema.items, Schema):
@@ -177,7 +188,7 @@ def _generate_property_from_reference(
     type_conv = TypeConversion(
         original_type=reference.ref,
         converted_type=import_model if required else "Optional[" + import_model + "]",
-        import_types=[import_model],
+        import_types=[f"from .{import_model} import {import_model}"],
     )
     return Property(
         name=name,

src/openapi_python_generator/language_converters/python/service_generator.py

@@ -1,3 +1,4 @@
+import re
 from typing import Dict
 from typing import List
 from typing import Tuple
@@ -13,6 +14,7 @@
 from openapi_schema_pydantic import Response
 from openapi_schema_pydantic import Schema
 
+from openapi_python_generator.language_converters.python import common
 from openapi_python_generator.language_converters.python.jinja_config import JINJA_ENV
 from openapi_python_generator.language_converters.python.model_generator import (
     type_converter,
@@ -189,7 +191,13 @@ def generate_return_type(operation: Operation) -> OpReturnType:
             if "array" in converted_result.original_type and isinstance(
                 converted_result.import_types, list
             ):
-                list_type = converted_result.import_types[0]
+                matched = re.findall(r"List\[(.+)\]", converted_result.converted_type)
+                if len(matched) > 0:
+                    list_type = matched[0]
+                else:
+                    raise Exception(
+                        f"Unable to parse list type from {converted_result.converted_type}"
+                    )  # pragma: no cover
             else:
                 list_type = None
             return OpReturnType(
@@ -235,6 +243,7 @@ def generate_service_operation(
             body_param=body_param,
             path_name=path_name,
             method=http_operation,
+            use_orjson=common.get_use_orjson(),
         )
 
         so.content = JINJA_ENV.get_template(library_config.template_name).render(
@@ -285,6 +294,7 @@ def generate_service_operation(
                 ),
                 async_client=False,
                 library_import=library_config.library_name,
+                use_orjson=common.get_use_orjson(),
             )
         )
 
@@ -304,6 +314,7 @@ def generate_service_operation(
                 ),
                 async_client=True,
                 library_import=library_config.library_name,
+                use_orjson=common.get_use_orjson(),
             )
         )
 

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

@@ -24,8 +24,12 @@ with httpx.Client(base_url=base_path) as client:
         headers=headers,
         params=query_params,
         {% if body_param %}
+        {% if use_orjson %}
+        content=orjson.dumps({{ body_param }})
+        {% else %}
         json = json.dumps({{ body_param }})
         {% endif %}
+        {% endif %}
     )
 
     if response.status_code != {{ return_type.status_code }}:

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

@@ -3,7 +3,7 @@ from pydantic import BaseModel
 {%  for property in properties %}
 {% if property.type.import_types is not none %}
 {% for import_type in property.type.import_types %}
-from .{{ import_type }} import {{ import_type}}
+{{ import_type }}
 {% endfor %}
 {% endif %}
 {% endfor %}