robotframework-openapitools 0.4.0__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

openapi_libgen/__init__.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader
+
+from openapi_libgen.spec_parser import get_keyword_data
+
+HERE = Path(__file__).parent.resolve()
+INIT_TEMPLATE_PATH = HERE / "templates/__init__.jinja"
+LIBRARY_TEMPLATE_PATH = HERE / "templates/library.jinja"
+
+
+def generate(
+    openapi_spec: dict[str, Any],
+    output_folder: Path,
+    library_name: str,
+    module_name: str,
+) -> str:
+    keyword_data = get_keyword_data(openapi_spec=openapi_spec)
+
+    library_folder = output_folder / library_name
+    library_folder.mkdir(parents=True, exist_ok=True)
+
+    environment = Environment(loader=FileSystemLoader(f"{HERE}/templates/"))
+
+    init_template = environment.get_template("__init__.jinja")
+    init_path = library_folder / "__init__.py"
+    init_content = init_template.render(
+        library_name=library_name,
+        module_name=module_name,
+    )
+    with open(init_path, mode="w", encoding="utf-8") as init_file:
+        init_file.write(init_content)
+        print(f"{init_path} created")
+
+    library_template = environment.get_template("library.jinja")
+    module_path = library_folder / f"{module_name}.py"
+    library_content = library_template.render(
+        library_name=library_name,
+        keywords=keyword_data,
+    )
+    with open(module_path, mode="w", encoding="utf-8") as library_file:
+        library_file.write(library_content)
+        print(f"{module_path} created")
+
+    return f"Generating {library_name} at {output_folder.resolve().as_posix()}/{module_name}"

openapi_libgen/command_line.py

@@ -0,0 +1,87 @@
+import argparse
+from pathlib import Path
+
+from prance import ResolvingParser
+
+import openapi_libgen
+from openapi_libgen.parsing_utils import remove_unsafe_characters_from_string
+
+parser = argparse.ArgumentParser(
+    prog="openapi_libgen",
+    description="The OpenApiTools library generator",
+    epilog="Inspired by roboswag. Thank you Bartlomiej and Mateusz for your work!",
+)
+parser.add_argument("-s", "--source")
+parser.add_argument("-d", "--destination")
+parser.add_argument("-n", "--name")
+parser.add_argument("--recursion-limit", default=1, type=int)
+parser.add_argument("--recursion-default", default={})
+args = parser.parse_args()
+
+
+def get_class_and_module_name_from_string(string: str) -> tuple[str, str]:
+    safe_string = remove_unsafe_characters_from_string(string)
+    class_name = safe_string.replace("_", "")
+    module_name = safe_string.lower()
+    return class_name, module_name
+
+
+def main() -> None:
+    def recursion_limit_handler(
+        limit: int, refstring: str, recursions: object
+    ) -> object:  # pylint: disable=unused-argument
+        return args.recursion_default
+
+    if not (source := args.source):
+        source = input("Please provide a source for the generation: ")
+
+    parser = ResolvingParser(
+        source,
+        backend="openapi-spec-validator",
+        recursion_limit=args.recursion_limit,
+        recursion_limit_handler=recursion_limit_handler,
+    )
+    assert parser.specification is not None, (
+        "Source was loaded, but no specification was present after parsing."
+    )
+    spec = parser.specification
+
+    if not (destination := args.destination):
+        destination = input(
+            "Please provide a path to where the library will be generated: "
+        )
+    path = Path(destination)
+
+    if args.name:
+        safe_library_name, safe_module_name = get_class_and_module_name_from_string(
+            args.name
+        )
+    else:
+        default_name = spec["info"]["title"]
+
+        default_library_name, default_module_name = (
+            get_class_and_module_name_from_string(default_name)
+        )
+
+        library_name = (
+            input(
+                f"Please provide a name for the library [default: {default_library_name}]: "
+            )
+            or default_library_name
+        )
+        if library_name != default_library_name:
+            safe_library_name, safe_module_name = get_class_and_module_name_from_string(
+                library_name
+            )
+        else:
+            safe_library_name, safe_module_name = (
+                default_library_name,
+                default_module_name,
+            )
+
+    openapi_libgen.generate(
+        openapi_spec=spec,
+        output_folder=path,
+        library_name=safe_library_name,
+        module_name=safe_module_name,
+    )

openapi_libgen/parsing_utils.py

@@ -0,0 +1,26 @@
+from typing import Generator
+
+
+def remove_unsafe_characters_from_string(string: str) -> str:
+    def _remove_unsafe_characters_from_string(
+        string: str,
+    ) -> Generator[str, None, None]:
+        string_iterator = iter(string)
+        capitalize_next_character = False
+
+        for character in string_iterator:
+            if character.isalpha():
+                yield character
+                break
+
+        for character in string_iterator:
+            if character.isalnum():
+                if capitalize_next_character:
+                    capitalize_next_character = False
+                yield character
+
+            elif not capitalize_next_character:
+                capitalize_next_character = True
+                yield "_"
+
+    return "".join(_remove_unsafe_characters_from_string(string=string))

openapi_libgen/spec_parser.py

@@ -0,0 +1,212 @@
+from dataclasses import dataclass
+from os import getenv
+from string import Template
+from typing import Any, Generator
+
+from robot.utils import is_truthy
+
+from openapi_libgen.parsing_utils import remove_unsafe_characters_from_string
+from OpenApiLibCore.parameter_utils import get_safe_name_for_oas_name
+from OpenApiLibCore.value_utils import python_type_by_json_type_name
+
+KEYWORD_TEMPLATE = r"""@keyword
+    {signature}
+        {body}"""
+
+SIGNATURE_TEMPLATE = r"def {keyword_name}(self{arguments}) -> Response:"
+
+BODY_TEMPLATE_ = r"""overrides = {key: value for key, value in locals().items() if value is not UNSET and key != "self"}
+        body_data = overrides.pop("body", {})
+        overrides.update(body_data)
+        updated_path: str = substitute_path_parameters(path="{path_value}", substitution_dict=overrides)
+        request_values: RequestValues = self.get_request_values(path=f"{updated_path}", method="{method_value}", overrides=overrides)
+        return self._perform_request(request_values=request_values)"""
+
+
+class BodyTemplate(Template):
+    delimiter = ""
+
+
+BODY_TEMPLATE = BodyTemplate(BODY_TEMPLATE_)
+
+
+@dataclass
+class OperationDetails:
+    path: str
+    method: str
+    operation_id: str
+    parameters: list[dict[str, Any]]
+    request_body: dict[str, Any]
+    summary: str
+    description: str
+
+
+@dataclass
+class ParameterDetails:
+    type: str
+    name: str
+    schema: dict[str, Any]
+
+
+@dataclass
+class BodyDetails:
+    schema: dict[str, Any]
+
+
+def get_path_items(paths: dict[str, Any]) -> Generator[OperationDetails, None, None]:
+    for path, operation_items in paths.items():
+        for method, method_item in operation_items.items():
+            operation_details = OperationDetails(
+                path=path,
+                method=method,
+                operation_id=method_item["operationId"],
+                parameters=method_item.get("parameters", []),
+                request_body=method_item.get("requestBody", {}),
+                summary=method_item.get("summary"),
+                description=method_item.get("description"),
+            )
+            yield operation_details
+
+
+def get_parameter_details(
+    operation_details: OperationDetails,
+) -> list[ParameterDetails]:
+    def _get_parameter_details(
+        data: OperationDetails,
+    ) -> Generator[ParameterDetails, None, None]:
+        for param_data in data.parameters:
+            name = param_data["name"]
+            type = param_data["in"]
+            if not (schema := param_data.get("schema", {})):
+                content = param_data["content"]
+                for _, media_data in content.items():
+                    schema = media_data["schema"]
+
+            yield ParameterDetails(
+                type=type,
+                name=name,
+                schema=schema,
+            )
+
+    return list(_get_parameter_details(data=operation_details))
+
+
+def get_body_details(operation_details: OperationDetails) -> BodyDetails | None:
+    if not (body_data := operation_details.request_body):
+        return None
+    content = body_data["content"]
+    if not (schema := content.get("application/json")):
+        return None
+    return BodyDetails(schema=schema["schema"])
+
+
+def get_keyword_signature(operation_details: OperationDetails) -> str:
+    USE_SUMMARY_AS_KEYWORD_NAME = getenv("USE_SUMMARY_AS_KEYWORD_NAME")
+    EXPAND_BODY_ARGUMENTS = getenv("EXPAND_BODY_ARGUMENTS")
+
+    if is_truthy(USE_SUMMARY_AS_KEYWORD_NAME):
+        keyword_name = remove_unsafe_characters_from_string(
+            operation_details.summary
+        ).lower()
+    else:
+        keyword_name = remove_unsafe_characters_from_string(
+            operation_details.operation_id
+        ).lower()
+
+    parameters = get_parameter_details(operation_details=operation_details)
+    path_parameters = [p for p in parameters if p.type == "path"]
+    query_parameters = [p for p in parameters if p.type == "query"]
+    header_parameters = [p for p in parameters if p.type == "header"]
+
+    body_details = get_body_details(operation_details=operation_details)
+
+    argument_parts: list[str] = []
+    # Keep track of the already used argument names. From the OAS:
+    # "A unique parameter is defined by a combination of a name and location"
+    # To prevent duplicates, a location prefix is added if a duplication would occur.
+    keyword_argument_names: set[str] = set()
+
+    for parameter in path_parameters:
+        if "anyOf" in parameter.schema:
+            parameter_python_type = "Any"
+        else:
+            parameter_json_type = parameter.schema["type"]
+            parameter_python_type = python_type_by_json_type_name(
+                parameter_json_type
+            ).__name__
+        annotation = f"{parameter_python_type} = UNSET"
+        safe_name = get_safe_name_for_oas_name(parameter.name)
+        keyword_argument_names.add(safe_name)
+        argument = f", {safe_name}: {annotation}"
+        argument_parts.append(argument)
+    arguments = "".join(argument_parts)
+
+    if body_details:
+        body_json_type = body_details.schema["type"]
+        body_python_type = python_type_by_json_type_name(body_json_type).__name__
+        if body_python_type == "dict" and is_truthy(EXPAND_BODY_ARGUMENTS):
+            body_properties = body_details.schema["properties"]
+            for property_name, property_data in body_properties.items():
+                if "anyOf" in property_data:
+                    property_python_type = "Any"
+                else:
+                    property_json_type = property_data["type"]
+                    property_python_type = python_type_by_json_type_name(
+                        property_json_type
+                    ).__name__
+                annotation = f"{property_python_type} = UNSET"
+                safe_name = get_safe_name_for_oas_name(property_name)
+                if safe_name in keyword_argument_names:
+                    safe_name = "body_" + safe_name
+                keyword_argument_names.add(safe_name)
+                argument = f", {safe_name}: {annotation}"
+                arguments += argument
+        else:
+            annotation = f"{body_python_type} = UNSET"
+            argument = f", body: {annotation}"
+            arguments += argument
+
+    for parameter in query_parameters:
+        if "anyOf" in parameter.schema:
+            parameter_python_type = "Any"
+        else:
+            parameter_json_type = parameter.schema["type"]
+            parameter_python_type = python_type_by_json_type_name(
+                parameter_json_type
+            ).__name__
+        annotation = f"{parameter_python_type} = UNSET"
+        safe_name = get_safe_name_for_oas_name(parameter.name)
+        if safe_name in keyword_argument_names:
+            safe_name = "query_" + safe_name
+        keyword_argument_names.add(safe_name)
+        argument = f", {safe_name}: {annotation}"
+        arguments += argument
+
+    for parameter in header_parameters:
+        if "anyOf" in parameter.schema:
+            parameter_python_type = "Any"
+        else:
+            parameter_json_type = parameter.schema["type"]
+            parameter_python_type = python_type_by_json_type_name(
+                parameter_json_type
+            ).__name__
+        annotation = f"{parameter_python_type} = UNSET"
+        safe_name = get_safe_name_for_oas_name(parameter.name)
+        if safe_name in keyword_argument_names:
+            safe_name = "header_" + safe_name
+        keyword_argument_names.add(safe_name)
+        argument = f", {safe_name}: {annotation}"
+        arguments += argument
+
+    return SIGNATURE_TEMPLATE.format(keyword_name=keyword_name, arguments=arguments)
+
+
+def get_keyword_body(data: OperationDetails) -> str:
+    return BODY_TEMPLATE.safe_substitute(path_value=data.path, method_value=data.method)
+
+
+def get_keyword_data(openapi_spec: dict[str, Any]) -> Generator[str, None, None]:
+    for path_item in get_path_items(openapi_spec["paths"]):
+        signature = get_keyword_signature(path_item)
+        body = get_keyword_body(path_item)
+        yield KEYWORD_TEMPLATE.format(signature=signature, body=body)

openapi_libgen/templates/__init__.jinja

@@ -0,0 +1,3 @@
+from {{ library_name }}.{{ module_name }} import {{ library_name }}
+
+__all__ = ["{{ library_name }}"]

openapi_libgen/templates/library.jinja

@@ -0,0 +1,30 @@
+# pyright: reportArgumentType=false
+from typing import Any
+
+from requests import Response
+from robot.api.deco import keyword, library
+from robot.libraries.BuiltIn import BuiltIn
+
+from OpenApiLibCore import UNSET, OpenApiLibCore, RequestValues
+from OpenApiLibCore.path_functions import substitute_path_parameters
+
+run_keyword = BuiltIn().run_keyword
+
+
+@library(scope="SUITE", doc_format="ROBOT")
+class {{ library_name }}(OpenApiLibCore):
+    """Generated library with keywords for all the path operations."""
+{% for keyword in keywords %}
+    {{ keyword }}
+{% endfor %}
+    @staticmethod
+    def _perform_request(request_values: RequestValues) -> Response:
+        response: Response = run_keyword(
+            "authorized_request",
+            request_values.url,
+            request_values.method,
+            request_values.params,
+            request_values.headers,
+            request_values.json_data,
+        )
+        return response

robotframework_openapitools-1.0.0b1.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.3
+Name: robotframework-openapitools
+Version: 1.0.0b1
+Summary: A set of Robot Framework libraries to test APIs for which the OAS is available.
+License: Apache License
+                                    Version 2.0, January 2004
+                                 http://www.apache.org/licenses/
+         
+            TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+         
+            1. Definitions.
+         
+               "License" shall mean the terms and conditions for use, reproduction,
+               and distribution as defined by Sections 1 through 9 of this document.
+         
+               "Licensor" shall mean the copyright owner or entity authorized by
+               the copyright owner that is granting the License.
+         
+               "Legal Entity" shall mean the union of the acting entity and all
+               other entities that control, are controlled by, or are under common
+               control with that entity. For the purposes of this definition,
+               "control" means (i) the power, direct or indirect, to cause the
+               direction or management of such entity, whether by contract or
+               otherwise, or (ii) ownership of fifty percent (50%) or more of the
+               outstanding shares, or (iii) beneficial ownership of such entity.
+         
+               "You" (or "Your") shall mean an individual or Legal Entity
+               exercising permissions granted by this License.
+         
+               "Source" form shall mean the preferred form for making modifications,
+               including but not limited to software source code, documentation
+               source, and configuration files.
+         
+               "Object" form shall mean any form resulting from mechanical
+               transformation or translation of a Source form, including but
+               not limited to compiled object code, generated documentation,
+               and conversions to other media types.
+         
+               "Work" shall mean the work of authorship, whether in Source or
+               Object form, made available under the License, as indicated by a
+               copyright notice that is included in or attached to the work
+               (an example is provided in the Appendix below).
+         
+               "Derivative Works" shall mean any work, whether in Source or Object
+               form, that is based on (or derived from) the Work and for which the
+               editorial revisions, annotations, elaborations, or other modifications
+               represent, as a whole, an original work of authorship. For the purposes
+               of this License, Derivative Works shall not include works that remain
+               separable from, or merely link (or bind by name) to the interfaces of,
+               the Work and Derivative Works thereof.
+         
+               "Contribution" shall mean any work of authorship, including
+               the original version of the Work and any modifications or additions
+               to that Work or Derivative Works thereof, that is intentionally
+               submitted to Licensor for inclusion in the Work by the copyright owner
+               or by an individual or Legal Entity authorized to submit on behalf of
+               the copyright owner. For the purposes of this definition, "submitted"
+               means any form of electronic, verbal, or written communication sent
+               to the Licensor or its representatives, including but not limited to
+               communication on electronic mailing lists, source code control systems,
+               and issue tracking systems that are managed by, or on behalf of, the
+               Licensor for the purpose of discussing and improving the Work, but
+               excluding communication that is conspicuously marked or otherwise
+               designated in writing by the copyright owner as "Not a Contribution."
+         
+               "Contributor" shall mean Licensor and any individual or Legal Entity
+               on behalf of whom a Contribution has been received by Licensor and
+               subsequently incorporated within the Work.
+         
+            2. Grant of Copyright License. Subject to the terms and conditions of
+               this License, each Contributor hereby grants to You a perpetual,
+               worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+               copyright license to reproduce, prepare Derivative Works of,
+               publicly display, publicly perform, sublicense, and distribute the
+               Work and such Derivative Works in Source or Object form.
+         
+            3. Grant of Patent License. Subject to the terms and conditions of
+               this License, each Contributor hereby grants to You a perpetual,
+               worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+               (except as stated in this section) patent license to make, have made,
+               use, offer to sell, sell, import, and otherwise transfer the Work,
+               where such license applies only to those patent claims licensable
+               by such Contributor that are necessarily infringed by their
+               Contribution(s) alone or by combination of their Contribution(s)
+               with the Work to which such Contribution(s) was submitted. If You
+               institute patent litigation against any entity (including a
+               cross-claim or counterclaim in a lawsuit) alleging that the Work
+               or a Contribution incorporated within the Work constitutes direct
+               or contributory patent infringement, then any patent licenses
+               granted to You under this License for that Work shall terminate
+               as of the date such litigation is filed.
+         
+            4. Redistribution. You may reproduce and distribute copies of the
+               Work or Derivative Works thereof in any medium, with or without
+               modifications, and in Source or Object form, provided that You
+               meet the following conditions:
+         
+               (a) You must give any other recipients of the Work or
+                   Derivative Works a copy of this License; and
+         
+               (b) You must cause any modified files to carry prominent notices
+                   stating that You changed the files; and
+         
+               (c) You must retain, in the Source form of any Derivative Works
+                   that You distribute, all copyright, patent, trademark, and
+                   attribution notices from the Source form of the Work,
+                   excluding those notices that do not pertain to any part of
+                   the Derivative Works; and
+         
+               (d) If the Work includes a "NOTICE" text file as part of its
+                   distribution, then any Derivative Works that You distribute must
+                   include a readable copy of the attribution notices contained
+                   within such NOTICE file, excluding those notices that do not
+                   pertain to any part of the Derivative Works, in at least one
+                   of the following places: within a NOTICE text file distributed
+                   as part of the Derivative Works; within the Source form or
+                   documentation, if provided along with the Derivative Works; or,
+                   within a display generated by the Derivative Works, if and
+                   wherever such third-party notices normally appear. The contents
+                   of the NOTICE file are for informational purposes only and
+                   do not modify the License. You may add Your own attribution
+                   notices within Derivative Works that You distribute, alongside
+                   or as an addendum to the NOTICE text from the Work, provided
+                   that such additional attribution notices cannot be construed
+                   as modifying the License.
+         
+               You may add Your own copyright statement to Your modifications and
+               may provide additional or different license terms and conditions
+               for use, reproduction, or distribution of Your modifications, or
+               for any such Derivative Works as a whole, provided Your use,
+               reproduction, and distribution of the Work otherwise complies with
+               the conditions stated in this License.
+         
+            5. Submission of Contributions. Unless You explicitly state otherwise,
+               any Contribution intentionally submitted for inclusion in the Work
+               by You to the Licensor shall be under the terms and conditions of
+               this License, without any additional terms or conditions.
+               Notwithstanding the above, nothing herein shall supersede or modify
+               the terms of any separate license agreement you may have executed
+               with Licensor regarding such Contributions.
+         
+            6. Trademarks. This License does not grant permission to use the trade
+               names, trademarks, service marks, or product names of the Licensor,
+               except as required for reasonable and customary use in describing the
+               origin of the Work and reproducing the content of the NOTICE file.
+         
+            7. Disclaimer of Warranty. Unless required by applicable law or
+               agreed to in writing, Licensor provides the Work (and each
+               Contributor provides its Contributions) on an "AS IS" BASIS,
+               WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+               implied, including, without limitation, any warranties or conditions
+               of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+               PARTICULAR PURPOSE. You are solely responsible for determining the
+               appropriateness of using or redistributing the Work and assume any
+               risks associated with Your exercise of permissions under this License.
+         
+            8. Limitation of Liability. In no event and under no legal theory,
+               whether in tort (including negligence), contract, or otherwise,
+               unless required by applicable law (such as deliberate and grossly
+               negligent acts) or agreed to in writing, shall any Contributor be
+               liable to You for damages, including any direct, indirect, special,
+               incidental, or consequential damages of any character arising as a
+               result of this License or out of the use or inability to use the
+               Work (including but not limited to damages for loss of goodwill,
+               work stoppage, computer failure or malfunction, or any and all
+               other commercial damages or losses), even if such Contributor
+               has been advised of the possibility of such damages.
+         
+            9. Accepting Warranty or Additional Liability. While redistributing
+               the Work or Derivative Works thereof, You may choose to offer,
+               and charge a fee for, acceptance of support, warranty, indemnity,
+               or other liability obligations and/or rights consistent with this
+               License. However, in accepting such obligations, You may act only
+               on Your own behalf and on Your sole responsibility, not on behalf
+               of any other Contributor, and only if You agree to indemnify,
+               defend, and hold each Contributor harmless for any liability
+               incurred by, or claims asserted against, such Contributor by reason
+               of your accepting any such warranty or additional liability.
+         
+            END OF TERMS AND CONDITIONS
+         
+            APPENDIX: How to apply the Apache License to your work.
+         
+               To apply the Apache License to your work, attach the following
+               boilerplate notice, with the fields enclosed by brackets "[]"
+               replaced with your own identifying information. (Don't include
+               the brackets!)  The text should be enclosed in the appropriate
+               comment syntax for the file format. We also recommend that a
+               file or class name and description of purpose be included on the
+               same "printed page" as the copyright notice for easier
+               identification within third-party archives.
+         
+            Copyright [yyyy] [name of copyright owner]
+         
+            Licensed under the Apache License, Version 2.0 (the "License");
+            you may not use this file except in compliance with the License.
+            You may obtain a copy of the License at
+         
+                http://www.apache.org/licenses/LICENSE-2.0
+         
+            Unless required by applicable law or agreed to in writing, software
+            distributed under the License is distributed on an "AS IS" BASIS,
+            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+            See the License for the specific language governing permissions and
+            limitations under the License.
+Author: Robin Mackaij
+Author-email: r.a.mackaij@gmail.com
+Maintainer: Robin Mackaij
+Maintainer-email: r.a.mackaij@gmail.com
+Requires-Python: >=3.10, <4
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Acceptance
+Classifier: Framework :: Robot Framework
+Requires-Dist: Faker (>=23.1.0)
+Requires-Dist: Jinja2 (>=3.1.2)
+Requires-Dist: black (>=24.1.0)
+Requires-Dist: openapi-core (>=0.19.0)
+Requires-Dist: prance[cli] (>=23)
+Requires-Dist: requests (>=2.31.0)
+Requires-Dist: rich_click (>=1.7.0)
+Requires-Dist: robotframework (>=6.0.0,!=7.0.0)
+Requires-Dist: robotframework-datadriver (>=1.10.0)
+Requires-Dist: rstr (>=3.2.0)
+Project-URL: Homepage, https://github.com/MarketSquare/robotframework-openapitools
+Description-Content-Type: text/markdown
+
+# OpenApiTools for Robot Framework
+
+OpenApiTools is a set of libraries centered around the OpenAPI Specification:
+
+- [OpenApiDriver](./driver.md)
+- [OpenApiLibCore](./libcore.md)
+