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

robotframework_openapitools-1.0.0b2.dist-info/RECORD

@@ -0,0 +1,37 @@
+OpenApiDriver/__init__.py,sha256=YjHr-j8g9KwRriNCw_ABvCEbUEp118J70xeJ_t7qcas,1453
+OpenApiDriver/openapi_executors.py,sha256=NsHhcP6CM3DsQgxqOcKhpAAOM0zjhMmCsrEygIxJleY,12534
+OpenApiDriver/openapi_reader.py,sha256=BPD_T8PUjfB-NBajogErI2ATmzlUGFJT8Nx5WpM5N5Y,4478
+OpenApiDriver/openapidriver.libspec,sha256=ObsSKxKimuui6KcJ6PifLJtfOitHbg7bl_TGW-cPpB8,28220
+OpenApiDriver/openapidriver.py,sha256=vypR00YZS3ygGfFxdUedLdCm_f_bWDLMpD1vb49-O0A,15321
+OpenApiDriver/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OpenApiLibCore/__init__.py,sha256=R6n4FTEz0IGD_LehKkOFSQrlt9Bk4Ugl3OicsZ_h84I,1775
+OpenApiLibCore/annotations.py,sha256=zfWwItXzECBezyQKoom9BLfrRFlU1u4jOF7NEgEAuQQ,135
+OpenApiLibCore/data_generation/__init__.py,sha256=KYBoMeFsa4fzb6E-BsQBykCGwt54NvXthXiy9VNwQBc,303
+OpenApiLibCore/data_generation/body_data_generation.py,sha256=c887DfNMghHFyu3omUDxA0SkaQtMaNiWYNM3YREbbEQ,8903
+OpenApiLibCore/data_generation/data_generation_core.py,sha256=N6hgyc2WHnPfIRwqdUwmT9XSGM2P-l88K2kblk0VCeA,8413
+OpenApiLibCore/data_invalidation.py,sha256=HSzbeJnzxrlS2NlPfXnCRXvGzGzXvBwiaJ3WXxrZOSw,10503
+OpenApiLibCore/dto_base.py,sha256=m41QZyL6ChIcC3DcBCpDFkok5wpCZ6K9gjmADyMGOWc,12132
+OpenApiLibCore/dto_utils.py,sha256=5dvMYM2Nt9gXq6GGTGJjU5Z75x9p9ky-1V01aLTZgX8,3177
+OpenApiLibCore/oas_cache.py,sha256=Z2v0mn6JwKchbUKojYVt9sXi8Mc4LoENtN_ekTUtzfI,387
+OpenApiLibCore/openapi_libcore.libspec,sha256=45xzp_QdGtaH4F_RjDDlL6mEKH12f6NndY0nrZi4yaA,53175
+OpenApiLibCore/openapi_libcore.py,sha256=30FtvsNHkfWZhz55bJq8bnWiHKvX6dEbGyLhbdNAtqY,36257
+OpenApiLibCore/parameter_utils.py,sha256=_P2GRc_teIixTgPsRgCxY2Bj6nsZq41GoSOhVgfXE0Y,3251
+OpenApiLibCore/path_functions.py,sha256=757f655yLg5HzvXxlOIQ76i48gK91Ct7KM-D9OAEA3A,8055
+OpenApiLibCore/path_invalidation.py,sha256=2iYjkskMV-7lWu_id_LbVIiumffMWZicqoIKeewqpFA,1539
+OpenApiLibCore/protocols.py,sha256=N9HxH9SqNuzWTyOGQuyEGfyorHZyYkehlBsyPse5jtQ,763
+OpenApiLibCore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OpenApiLibCore/request_data.py,sha256=jm6HnTG4xvQfSeYPMIMzowlSi7cuU3XqDGTQ6FdKnUY,10644
+OpenApiLibCore/resource_relations.py,sha256=Qp5TBNSArLaDfAqcjC5xiHwlB1h4hgAFIfuJnBg5Yxw,1710
+OpenApiLibCore/validation.py,sha256=uVPgg3k5X1ww4u4-glqC2szSL1qsvqgnCUoqUMjpnek,20067
+OpenApiLibCore/value_utils.py,sha256=M4k5m0YW1B20-6KD0f9-5xMERWKG8ncu2-5ahC2_VzU,19208
+openapi_libgen/__init__.py,sha256=9ZfgPSI8AUAcJ59hBRZE1VImhMVRyt6G_w1nYIPORgQ,1543
+openapi_libgen/command_line.py,sha256=GppzNAAMomd0Dl5c5HGK8chDQw-kaIztD0hqQ2iUEXE,2783
+openapi_libgen/parsing_utils.py,sha256=d_N-v619SR6iyolz65IGN12H5wMUA8dzPuG1l7rv5gg,821
+openapi_libgen/spec_parser.py,sha256=9WCuCCDpMMr9jhA8fgzjBhhoF_DEWFc0lBwFcGBDqs4,8509
+openapi_libgen/templates/__init__.jinja,sha256=92OFwNzeO7lEiUBv04GfjKXA1088V7GbeneASBShbmc,102
+openapi_libgen/templates/library.jinja,sha256=tIwJuGerOUJmMt928P_38MMfcnSHZqcPDPEJ56R6wT0,952
+robotframework_openapitools-1.0.0b2.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+robotframework_openapitools-1.0.0b2.dist-info/METADATA,sha256=Nu-LfVU0r_z8VCFX5UeM3r9eFScb9eiFmyalTBEiF10,14491
+robotframework_openapitools-1.0.0b2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+robotframework_openapitools-1.0.0b2.dist-info/entry_points.txt,sha256=_yd5PITEJf85hIEsrRkkWxXePf_O9YOOUjON3TYLy0c,69
+robotframework_openapitools-1.0.0b2.dist-info/RECORD,,

{robotframework_openapitools-0.4.0.dist-info → robotframework_openapitools-1.0.0b2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any

robotframework_openapitools-1.0.0b2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+generate-library=openapi_libgen.command_line:main
+

roboswag/__init__.py

@@ -1,9 +0,0 @@
-from importlib.metadata import version
-
-from roboswag.cli import cli
-from roboswag.core import APIModel
-
-try:
-    __version__ = version("robotframework-openapitools")
-except Exception:  # pragma: no cover
-    pass

roboswag/__main__.py

@@ -1,3 +0,0 @@
-from roboswag import cli
-
-cli()

roboswag/auth.py

@@ -1,44 +0,0 @@
-from requests.auth import HTTPBasicAuth
-from robot.libraries.BuiltIn import BuiltIn
-
-
-class MissingParameter(ValueError):
-    def __init__(self, name):
-        super().__init__(
-            f"Missing {name}. Set ${{{name}}} global variable or pass it as {name} named variable."
-        )
-
-
-def get_from_kwargs_or_robot(
-    kwargs, name, missing_ok=True
-):  # TODO pass flag to enforce auth with missing_ok
-    value = kwargs.get(name)
-    if value is None:
-        value = BuiltIn().get_variable_value(f"${{{name}}}")
-    if not missing_ok and value is None:
-        raise MissingParameter(name) from None
-    return value
-
-
-class TokenHandler:
-    # FIXME
-    def __init__(self, **kwargs):
-        self.access_token = get_from_kwargs_or_robot(kwargs, "access_token")
-
-    def __call__(self, *args, **kwargs):
-        user = get_from_kwargs_or_robot(kwargs, "user")
-        password = get_from_kwargs_or_robot(kwargs, "password")
-        super().__init__(user, password)
-
-
-class BasicAuth(HTTPBasicAuth):
-    def __init__(self, **kwargs):
-        user = get_from_kwargs_or_robot(kwargs, "user")
-        password = get_from_kwargs_or_robot(kwargs, "password")
-        super().__init__(user, password)
-
-
-AUTH_BACKENDS = {
-    "disable": "disable",
-    "basicauth": "BasicAuth",
-}

roboswag/cli.py

@@ -1,80 +0,0 @@
-from pathlib import Path
-from typing import Optional
-
-import rich_click as click
-
-from roboswag import __version__ as version
-from roboswag.auth import AUTH_BACKENDS
-from roboswag.generate import generate_libraries
-
-CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
-
-
-class AuthBackend(click.ParamType):
-    name = "auth"
-
-    def convert(self, value, param, ctx):
-        backends = {
-            backend.lower(): auth_class for backend, auth_class in AUTH_BACKENDS.items()
-        }
-        normalized = value.casefold()
-        if normalized in backends:
-            return backends[normalized]
-        backend_names = "\n    ".join(backend for backend in AUTH_BACKENDS.keys())
-        self.fail(
-            f"Invalid authentication backend: {value}. Authentication can be only one of:\n    {backend_names}",
-            param,
-            ctx,
-        )
-
-
-@click.group(invoke_without_command=True, context_settings=CONTEXT_SETTINGS)
-@click.version_option(version=version, prog_name="roboswag")
-def cli():
-    """
-    Roboswag is a tool that generates Python libraries out of your Swagger (OpenAPI specification file).
-    """
-    pass
-
-
-@cli.command()
-@click.option(
-    "-s",
-    "--spec",
-    type=click.Path(
-        exists=True,
-        file_okay=True,
-        dir_okay=False,
-        readable=True,
-        allow_dash=False,
-        path_type=str,
-    ),
-    required=True,
-    metavar="SWAGGER",
-    help="OpenAPI specification file",
-)
-@click.option(
-    "-o",
-    "--output-dir",
-    type=click.Path(
-        file_okay=False,
-        dir_okay=True,
-        writable=True,
-        allow_dash=False,
-        path_type=Path,
-    ),
-    show_default="current working directory",
-    metavar="OUTPUT_DIR",
-    help="Output directory path",
-)
-@click.option(
-    "-a",
-    "--auth",
-    type=AuthBackend(),
-    show_default="Authentication found in the specification",
-    metavar="AUTH_CLASS",
-    help="Overwrite default authentication class",
-)
-def generate(spec: str, output_dir: Optional[Path] = None, auth: Optional[Path] = None):
-    """Generate Python libraries."""
-    generate_libraries(spec, output_dir, auth)

roboswag/core.py

@@ -1,85 +0,0 @@
-import requests
-import urllib3
-
-from roboswag.auth import TokenHandler
-from roboswag.logger import Logger
-from roboswag.validate import Validate
-
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-
-class APIModel:
-    def __init__(
-        self,
-        base_url,
-        verify=False,
-        headers=None,
-        content_type="application/json",
-        proxies=None,
-        allow_redirects=True,
-        authentication=None,
-    ):
-        # Set headers from init too (or reuse auth)
-        self.base_url = base_url
-        self.session = requests.Session()
-        self.session.verify = verify
-        self.content_type = content_type
-        if content_type is not None:
-            self.session.headers = {"Content-Type": content_type}
-        self.allow_redirects = allow_redirects
-        if proxies is not None:  # TODO urllib have autodetect proxy - allow to use it
-            self.session.proxies.update(proxies)
-        self.authentication = authentication
-        self.logger = Logger()
-        self.validate = Validate(self.logger)
-        if headers is not None:
-            self.session.headers.update(headers)
-
-    def send_request(
-        self, method, url, status=None, headers=None, body=None, query=None, **kwargs
-    ):
-        headers = self.trim_empty(headers)
-        query = self.trim_empty(query)
-        auth = (
-            self.authentication(**kwargs) if self.authentication is not None else None
-        )
-        content_type = kwargs.get("content-type", self.content_type)
-        if content_type is not None:
-            headers["Content-Type"] = content_type
-
-        resp = self.session.request(
-            method,
-            url=self.base_url + url,
-            headers=headers,
-            json=body,
-            params=query,
-            auth=auth,
-            allow_redirects=self.allow_redirects,
-        )
-        # TODO quiet mode
-        self.logger.log_request(resp)
-        self.logger.log_response(resp)
-        if status is not None:
-            assert (
-                resp.status_code == status
-            ), f"Expected return status: {status} but received: {resp.status_code}"
-        return resp
-
-    def post(self, *args, **kwargs):
-        # TODO handle files upload
-        return self.send_request("POST", *args, **kwargs)
-
-    def get(self, *args, **kwargs):
-        return self.send_request("GET", *args, **kwargs)
-
-    def put(self, *args, **kwargs):
-        return self.send_request("PUT", *args, **kwargs)
-
-    def delete(self, *args, **kwargs):
-        return self.send_request("DELETE", *args, **kwargs)
-
-    @staticmethod
-    def trim_empty(dictionary):
-        if dictionary is None:
-            return {}
-        return {key: value for key, value in dictionary.items() if value is not None}

roboswag/generate/__init__.py

@@ -1 +0,0 @@
-from roboswag.generate.generate import generate_libraries

roboswag/generate/generate.py

@@ -1,121 +0,0 @@
-import json
-from pathlib import Path
-from typing import Any, Optional
-
-import black
-from jinja2 import Template
-
-from roboswag.generate.models.api import (
-    get_definitions_from_swagger,
-    parse_swagger_specification,
-)
-
-
-class LibraryGenerator:
-    def __init__(self, source, output: Optional[Path], authentication):
-        self.source = source
-        self.parent_dir = Path(__file__).parent
-        api_model, swagger = parse_swagger_specification(self.source)
-        self.api_model = api_model
-        self.swagger = swagger
-        self.output_dir = self.resolve_output_dir(output)
-        self.default_auth = authentication
-        self.unformatted_files = []
-
-    def resolve_output_dir(self, output: Optional[Path]):
-        output_dir = self.api_model.name
-        if output is None:
-            return Path(output_dir)
-        return output / output_dir
-
-    def generate(self):
-        self.output_dir.mkdir(exist_ok=True, parents=True)
-        self.generate_init()
-        self.generate_endpoints()
-        self.generate_models()
-        self.generate_schemas()
-        self.format_files()
-
-    def format_files(self):
-        for path in self.unformatted_files:
-            blackify_file(path)
-        self.unformatted_files = []
-
-    def generate_init(self):
-        swagger_version = self.swagger.get("openapi") or self.swagger.get("swagger")
-        api_init_template = self.parent_dir / "templates" / "api_init.jinja"
-        with open(api_init_template) as f:
-            template = Template(f.read()).render(
-                swagger_version=swagger_version, infos=self.swagger["info"]
-            )
-        init_file = self.output_dir / "__init__.py"
-        with open(init_file, "w") as f:
-            f.write(template)
-        print(f"Generated '{init_file}' file")
-        self.unformatted_files.append(init_file)
-
-    def get_api_auth(self):
-        if self.default_auth is None:
-            return self.api_model.authentication
-        if self.default_auth == "disable":
-            return None
-        return self.default_auth
-
-    def generate_endpoints(self):
-        endpoints_dir = self.output_dir / "endpoints"
-        Path(endpoints_dir).mkdir(exist_ok=True)
-        print("Generating endpoints...")
-        for tag in self.api_model.tags.values():
-            paths_template = self.parent_dir / "templates" / "paths.jinja"
-            with open(paths_template) as f:
-                template = Template(f.read()).render(
-                    class_name=tag.name,
-                    authentication=self.get_api_auth(),
-                    endpoints=tag.endpoints,
-                    description=tag.description,
-                )
-            endpoint_file = endpoints_dir / f"{tag.name}.py"
-            with open(endpoint_file, "w") as f:
-                f.write(template)
-            print(f"Generated '{endpoint_file}' file")
-            self.unformatted_files.append(endpoint_file)
-
-    def generate_models(self):
-        models_dir = self.output_dir / "models"
-        Path(models_dir).mkdir(exist_ok=True)
-        print("Generating models...")
-        for definition in self.api_model.definitions.values():
-            models_template = self.parent_dir / "templates" / "models.jinja"
-            with open(models_template) as f:
-                template = Template(f.read()).render(
-                    class_name=definition.name, properties=definition.properties
-                )
-            model_file = models_dir / f"{definition.name}.py"
-            with open(model_file, "w") as f:
-                f.write(template)
-            print(f"Generated '{model_file}' file")
-            self.unformatted_files.append(model_file)
-
-    def generate_schemas(self):
-        schemas_dir = self.output_dir / "schemas"
-        Path(schemas_dir).mkdir(exist_ok=True)
-        print("Generating schemas...")
-        schemas = get_definitions_from_swagger(self.swagger)
-        for schema_name, schema in schemas.items():
-            schema_file = schemas_dir / f"{schema_name}.json"
-            with open(schema_file, "w") as f:
-                f.write(json.dumps(schema, indent=4))
-                f.write("\n")
-            print(f"Generated '{schema_file}' file")
-            self.unformatted_files.append(schema_file)
-
-
-def blackify_file(source):
-    black.format_file_in_place(
-        source, fast=True, mode=black.FileMode(), write_back=black.WriteBack.YES
-    )
-
-
-def generate_libraries(source: str, output_dir: Optional[Path], authentication: Any):
-    generator = LibraryGenerator(source, output_dir, authentication)
-    generator.generate()

roboswag/generate/models/api.py

@@ -1,219 +0,0 @@
-import re
-from collections import defaultdict
-from typing import Dict, Optional
-
-from prance import ResolvingParser
-from prance.convert import convert_spec
-
-from roboswag.generate.models.definition import (
-    Definition,
-    Property,
-    get_definitions_from_swagger,
-)
-from roboswag.generate.models.endpoint import Endpoint
-from roboswag.generate.models.parameter import Parameter
-from roboswag.generate.models.response import Response
-from roboswag.generate.models.tag import Tag
-from roboswag.generate.models.utils import get_python_type, pythonify_name
-
-
-def get_schema(param):
-    return param.get("schema") or get_schema_openapi_v3(param)
-
-
-def get_schema_openapi_v3(param):
-    return param.get("content", {}).get("application/json", {}).get("schema", {})
-
-
-def get_body(params, method_body):
-    """
-    Get optional body of the request.
-    For OpenAPI v2 body is part of the parameters (with in: body).
-    For OpenAPi v3 body is in separate property requestBody.
-    # TODO: We only support application/json type of the body
-    """
-    if "body" in params:
-        # TODO Can it be more than one? If not, should we use the same container as for headers & query?
-        return params["body"][0]
-    if "requestBody" in method_body:
-        schema = get_schema_openapi_v3(method_body["requestBody"])
-        if not schema:
-            return None
-        return Parameter(
-            "body",
-            default="None",
-            param_type=None,
-            description=None,
-            required=None,
-            schema=schema,  # TODO
-        )
-
-
-class APIModel:
-    def __init__(self) -> None:
-        self.name: str = ""
-        self.tags: Dict[str, Tag] = {}
-        self.definitions: Dict[str, Definition] = {}
-        self.authentication: Optional[str] = None
-
-    def parse_swagger(self, swagger):
-        self.parse_info(swagger)
-        self.parse_paths(swagger)
-        self.parse_tags(swagger)
-        self.parse_schemas(swagger)
-        self.parse_authentication(swagger)
-
-    def parse_info(self, swagger):
-        name = swagger["info"]["title"].replace(" ", "")
-        self.name = name
-
-    def get_unique_endpoint_name(self, path, method, method_body):
-        if "operationId" in method_body:
-            return pythonify_name(method_body["operationId"])
-        # split on camelCase and / path
-        parts = re.split("((?<=[a-z])(?=[A-Z])|/)", path)
-        name = method
-        for part in parts:
-            part = re.sub("[/{}]", "", part)
-            part = part.replace("-", "_")
-            if not part:
-                continue
-            name += f"_{part.lower()}"
-        return name
-
-    @staticmethod
-    def class_name_from_tag(method_body, **kwargs):
-        return method_body["tags"][0].strip(" -_").title()
-
-    @staticmethod
-    def class_name_from_path(path, **kwargs):
-        for part in path.split("/"):
-            part = re.sub("[/{}]", "", part)
-            if not part:
-                continue
-            return part.title()
-        return "Root"
-
-    def set_source_of_class_name(self, swagger):
-        """
-        If all methods have their tags - use tag name. Otherwise use first part of the path.
-        """
-        # TODO configurable class name
-        for path_body in swagger["paths"].values():
-            for method in path_body.values():
-                if "tags" not in method:
-                    return self.class_name_from_path
-        return self.class_name_from_tag
-
-    def parse_paths(self, swagger):
-        get_class_name = self.set_source_of_class_name(swagger)
-        for path, path_body in swagger["paths"].items():
-            method: str
-            method_body: Dict
-            for method, method_body in path_body.items():
-                class_name = get_class_name(path=path, method_body=method_body)
-                unique_name = self.get_unique_endpoint_name(path, method, method_body)
-                summary = method_body.get("summary", "")
-                description = method_body.get("description", "")
-                params = defaultdict(list)
-                for param in method_body.get("parameters", []):
-                    params[param["in"]].append(
-                        Parameter(
-                            param["name"],
-                            default=(
-                                "None" if param["in"] != "path" else None
-                            ),  # TODO Retrieve default value
-                            param_type=(
-                                get_python_type(param["type"], param.get("format"))
-                                if param.get("type")
-                                else None
-                            ),
-                            description=param.get("description"),
-                            required=param.get("required"),
-                            schema=get_schema(param),
-                        )
-                    )
-                responses = dict()
-                for status_code, resp in method_body.get("responses", []).items():
-                    responses[status_code] = Response(
-                        description=resp.get("description"),
-                        headers=resp.get("headers"),
-                        schema=get_schema(resp),
-                    )
-                body = get_body(params, method_body)
-                endpoint = Endpoint(
-                    unique_name,
-                    method,
-                    path,
-                    summary=summary,
-                    description=description,
-                    path_params=params["path"],
-                    headers=params["header"],
-                    query=params["query"],
-                    body=body,
-                    responses=responses,
-                )
-                self.add_endpoint_to_tag(class_name, endpoint)
-
-    def parse_tags(self, swagger):
-        if not swagger.get("tags"):
-            return
-        for tag in swagger["tags"]:
-            tag_name = Tag.normalize_tag_name(tag["name"])
-            if tag_name in self.tags:
-                self.tags[tag_name].description = tag["description"]
-
-    def add_endpoint_to_tag(self, tag: str, endpoint: Endpoint) -> None:
-        if tag not in self.tags:
-            self.tags[tag] = Tag(tag)
-        self.tags[tag].endpoints.append(endpoint)
-
-    def parse_schemas(self, swagger):
-        schemas = get_definitions_from_swagger(swagger)
-        for def_name, def_body in schemas.items():
-            def_type = def_body.get("type", "")
-            def_req = def_body.get("required")
-            properties = []
-            for prop_name, prop_body in def_body.get("properties", {}).items():
-                prop_type = prop_body.get("type", "")
-                prop_format = prop_body.get("format", "")
-                properties.append(
-                    Property(
-                        prop_name, prop_type=get_python_type(prop_type, prop_format)
-                    )
-                )
-
-            definition = Definition(
-                def_name, def_type=def_type, properties=properties, required=def_req
-            )
-            self.definitions[def_name] = definition
-
-    def parse_authentication(self, swagger):
-        # TODO we should check what security schemes applies to which endpoints
-        # it could be that entire path does not need auth, while other needs it etc
-        security_schemes = swagger.get("components", {}).get("securitySchemes", {})
-        if not security_schemes:
-            return
-        for name, scheme in security_schemes.items():
-            if scheme.get("type", "") == "http" and scheme.get("scheme", "") == "basic":
-                self.authentication = "BasicAuth"
-                return
-
-
-def parse_swagger_specification(source, convert_to_3=False):
-    def recursion_limit_handler(limit, refstring, recursions):
-        return {}
-
-    parser = ResolvingParser(
-        source,
-        backend="openapi-spec-validator",
-        recursion_limit=1,
-        recursion_limit_handler=recursion_limit_handler,
-    )
-    swagger = parser.specification
-    # convert to OpenAPI 3.x if swagger is in version 2.x
-    if swagger.get("swagger") and convert_to_3:
-        swagger = convert_spec(swagger).specification
-    api_model = APIModel()
-    api_model.parse_swagger(swagger)
-    return api_model, swagger

roboswag/generate/models/definition.py

@@ -1,28 +0,0 @@
-from typing import List
-
-from roboswag.generate.models.utils import (
-    get_python_type,
-    pythonify_name,
-    replace_reserved_name,
-)
-
-
-class Property:
-    def __init__(self, name: str, prop_type=None):
-        self.name: str = replace_reserved_name(pythonify_name(name))
-        self.type = prop_type
-
-
-class Definition:
-    def __init__(self, name: str, def_type, properties: List[Property], required=None):
-        self.name: str = name
-        self.type = get_python_type(def_type)
-        self.required = required
-        self.properties: List[Property] = properties
-
-
-def get_definitions_from_swagger(swagger):
-    """
-    Get resolved schema definition from Swagger file. Supports both OpenAPI v2 and 3.
-    """
-    return swagger.get("definitions", swagger.get("components", {}).get("schemas", {}))