fastapi_swagger2 0.0.1__py3-none-any.whl

fastapi_swagger2/__init__.py

@@ -0,0 +1,145 @@
+__version__ = "0.0.1"
+
+from typing import Any, Dict, List, Optional, TypeVar
+
+from fastapi import FastAPI
+from fastapi.openapi.docs import (
+    get_redoc_html,
+    get_swagger_ui_html,
+    get_swagger_ui_oauth2_redirect_html,
+)
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse
+
+from fastapi_swagger2.utils import get_swagger2
+
+
+# Keep mypy happy with the monkey patching
+class FastAPIEx(FastAPI):
+    swagger2_url: Optional[str]
+    swagger2_tags: Optional[List[Dict[str, Any]]]
+    swagger2_docs_url: Optional[str]
+    swagger2_redoc_url: Optional[str]
+    swagger2_ui_oauth2_redirect_url: Optional[str]
+    swagger2_ui_init_oauth: Optional[Dict[str, Any]]
+    swagger2_ui_parameters: Optional[Dict[str, Any]]
+    swagger2_version: str = "2.0"
+    swagger2_schema: Optional[Dict[str, Any]]
+
+    swagger2: Any
+
+
+AppType = TypeVar("AppType", bound="FastAPIEx")
+
+
+class FastAPISwagger2:
+    def __init__(
+        self,
+        app: AppType,
+        swagger2_url: Optional[str] = "/swagger2.json",
+        swagger2_tags: Optional[List[Dict[str, Any]]] = None,
+        swagger2_docs_url: Optional[str] = "/swagger2/docs",
+        swagger2_redoc_url: Optional[str] = "/swagger2/redoc",
+        swagger2_ui_oauth2_redirect_url: Optional[
+            str
+        ] = "/swagger2/docs/oauth2-redirect",
+        swagger2_ui_init_oauth: Optional[Dict[str, Any]] = None,
+        swagger2_ui_parameters: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.app = app
+        self.app.swagger2_url = swagger2_url
+        self.app.swagger2_tags = swagger2_tags
+        self.app.swagger2_docs_url = swagger2_docs_url
+        self.app.swagger2_redoc_url = swagger2_redoc_url
+        self.app.swagger2_ui_oauth2_redirect_url = swagger2_ui_oauth2_redirect_url
+        self.app.swagger2_ui_init_oauth = swagger2_ui_init_oauth
+        self.app.swagger2_ui_parameters = swagger2_ui_parameters
+
+        self.app.swagger2_version = "2.0"
+        self.app.swagger2_schema = None
+        if self.app.swagger2_url:
+            assert (
+                self.app.title
+            ), "A title must be provided for Swagger, e.g.: 'My API'"
+            assert (
+                self.app.version
+            ), "A version must be provided for Swagger, e.g.: '2.1.0'"
+
+        self.app.swagger2 = self.swagger2
+
+        self.setup()
+
+    def setup(self) -> None:
+        if self.app.swagger2_url:
+            urls = (server_data.get("url") for server_data in self.app.servers)
+            server_urls = {url for url in urls if url}
+
+            async def swagger2(req: Request) -> JSONResponse:
+                root_path = req.scope.get("root_path", "").rstrip("/")
+                if root_path not in server_urls:
+                    if root_path and self.app.root_path_in_servers:
+                        self.app.servers.insert(0, {"url": root_path})
+                        server_urls.add(root_path)
+                return JSONResponse(self.swagger2())
+
+            self.app.add_route(self.app.swagger2_url, swagger2, include_in_schema=False)
+
+        if self.app.swagger2_url and self.app.swagger2_docs_url:
+
+            async def swagger_ui_html(req: Request) -> HTMLResponse:
+                root_path = req.scope.get("root_path", "").rstrip("/")
+                swagger2_url = root_path + self.app.swagger2_url
+                oauth2_redirect_url = self.app.swagger2_ui_oauth2_redirect_url
+                if oauth2_redirect_url:
+                    oauth2_redirect_url = root_path + oauth2_redirect_url
+                return get_swagger_ui_html(
+                    openapi_url=swagger2_url,
+                    title=self.app.title + " - Swagger UI",
+                    oauth2_redirect_url=oauth2_redirect_url,
+                    init_oauth=self.app.swagger2_ui_init_oauth,
+                    swagger_ui_parameters=self.app.swagger2_ui_parameters,
+                )
+
+            self.app.add_route(
+                self.app.swagger2_docs_url, swagger_ui_html, include_in_schema=False
+            )
+
+            if self.app.swagger2_ui_oauth2_redirect_url:
+
+                async def swagger_ui_redirect(req: Request) -> HTMLResponse:
+                    return get_swagger_ui_oauth2_redirect_html()
+
+                self.app.add_route(
+                    self.app.swagger2_ui_oauth2_redirect_url,
+                    swagger_ui_redirect,
+                    include_in_schema=False,
+                )
+        if self.app.swagger2_url and self.app.swagger2_redoc_url:
+
+            async def redoc_html(req: Request) -> HTMLResponse:
+                root_path = req.scope.get("root_path", "").rstrip("/")
+                swagger2_url = root_path + self.app.swagger2_url
+                return get_redoc_html(
+                    openapi_url=swagger2_url, title=self.app.title + " - ReDoc"
+                )
+
+            self.app.add_route(
+                self.app.swagger2_redoc_url, redoc_html, include_in_schema=False
+            )
+
+    def swagger2(self) -> Dict[str, Any]:
+        if not self.app.swagger2_schema:
+            self.app.swagger2_schema = get_swagger2(
+                title=self.app.title,
+                version=self.app.version,
+                swagger2_version=self.app.swagger2_version,
+                description=self.app.description,
+                server=str(self.app.servers[0]) if self.app.servers else None,
+                terms_of_service=self.app.terms_of_service,
+                contact=self.app.contact,
+                license_info=self.app.license_info,
+                routes=self.app.routes,
+                tags=self.app.swagger2_tags,
+            )
+
+        return self.app.swagger2_schema

fastapi_swagger2/constants.py

@@ -0,0 +1 @@
+REF_PREFIX = "#/definitions/"

fastapi_swagger2/models.py

@@ -0,0 +1,353 @@
+from enum import Enum
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
+
+from fastapi.logger import logger
+from pydantic import AnyUrl, BaseModel, Field
+
+try:
+    import email_validator  # type: ignore
+
+    assert email_validator  # make autoflake ignore the unused import
+    from pydantic import EmailStr
+except ImportError:  # pragma: no cover
+
+    class EmailStr(str):  # type: ignore
+        @classmethod
+        def __get_validators__(cls) -> Iterable[Callable[..., Any]]:
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, v: Any) -> str:
+            logger.warning(
+                "email-validator not installed, email fields will be treated as str.\n"
+                "To install, run: pip install email-validator"
+            )
+            return str(v)
+
+
+class Contact(BaseModel):
+    name: Optional[str] = None
+    url: Optional[AnyUrl] = None
+    email: Optional[EmailStr] = None
+
+    class Config:
+        extra = "allow"
+
+
+class License(BaseModel):
+    name: str
+    url: Optional[AnyUrl] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Info(BaseModel):
+    title: str
+    description: Optional[str] = None
+    termsOfService: Optional[str] = None
+    contact: Optional[Contact] = None
+    license: Optional[License] = None
+    version: str
+
+    class Config:
+        extra = "allow"
+
+
+# class URLHost(Field)
+"""
+The host (name or ip) serving the API. This MUST be the host only and does not include the scheme nor sub-paths. It
+MAY include a port. If the host is not included, the host serving the documentation is to be used (including the port)
+"""
+
+# class URLBasePath(Field)
+"""
+The base path on which the API is served, which is relative to the host. If it is not included, the API is served
+directly under the host. The value MUST start with a leading slash (/).
+"""
+
+
+class URLSchemeEnum(Enum):
+    http = "http"
+    https = "https"
+    ws = "ws"
+    wss = "wss"
+
+
+class ExternalDocumentation(BaseModel):
+    description: Optional[str] = None
+    url: AnyUrl
+
+    class Config:
+        extra = "allow"
+
+
+class Reference(BaseModel):
+    ref: str = Field(alias="$ref")
+
+
+class XML(BaseModel):
+    name: Optional[str] = None
+    namespace: Optional[str] = None
+    prefix: Optional[str] = None
+    attribute: Optional[bool] = None
+    wrapped: Optional[bool] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Schema(BaseModel):
+    ref: Optional[str] = Field(default=None, alias="$ref")
+    format: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+
+    default: Optional[Any] = None
+    multipleOf: Optional[float] = None
+    maximum: Optional[float] = None
+    exclusiveMaximum: Optional[bool] = None
+    minimum: Optional[float] = None
+    exclusiveMinimum: Optional[bool] = None
+    maxLength: Optional[int] = Field(default=None, ge=0)
+    minLength: Optional[int] = Field(default=None, ge=0)
+    pattern: Optional[str] = None
+    maxItems: Optional[int] = Field(default=None, ge=0)
+    minItems: Optional[int] = Field(default=None, ge=0)
+    uniqueItems: Optional[bool] = None
+    maxProperties: Optional[int] = Field(default=None, ge=0)
+    minProperties: Optional[int] = Field(default=None, ge=0)
+    required: Optional[List[str]] = None
+    enum: Optional[List[Any]] = None
+    type_: Optional[str] = Field(default=None, alias="type")
+
+    items: Optional[Union["Schema", List["Schema"]]] = None
+    allOf: Optional[List["Schema"]] = None
+    properties: Optional[Dict[str, "Schema"]] = None
+    additionalProperties: Optional[Union["Schema", Reference, bool]] = None
+
+    discriminator: Optional[str] = None
+    readOnly: Optional[bool] = None
+    xml: Optional[XML] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+    example: Optional[Any] = None
+
+    class Config:
+        extra: str = "allow"
+
+
+class _Schema2(BaseModel):
+    type: Optional[str] = None
+    format: Optional[str] = None
+    items: Optional[Union["Schema", List["Schema"]]] = None
+    collectionFormat: Optional[str] = None
+    default: Optional[Any] = None
+    maximum: Optional[float] = None
+    exclusiveMaximum: Optional[bool] = None
+    minimum: Optional[float] = None
+    exclusiveMinimum: Optional[bool] = None
+    maxLength: Optional[int] = Field(default=None, ge=0)
+    minLength: Optional[int] = Field(default=None, ge=0)
+    pattern: Optional[str] = None
+    maxItems: Optional[int] = Field(default=None, ge=0)
+    minItems: Optional[int] = Field(default=None, ge=0)
+    uniqueItems: Optional[bool] = None
+    enum: Optional[List[Any]] = None
+    multipleOf: Optional[float] = None
+
+    class Config:
+        extra: str = "allow"
+
+
+class ParameterSchema(_Schema2):
+    allowEmptyValue: bool = False
+
+    class Config:
+        extra: str = "allow"
+
+
+class ParameterInType(Enum):
+    query = "query"
+    header = "header"
+    path = "path"
+    formData = "formData"
+    body = "body"
+
+
+class ParameterBase(BaseModel):
+    name: str
+    in_: ParameterInType = Field(alias="in")
+    description: Optional[str] = None
+    required: Optional[bool] = None
+
+    class Config:
+        extra = "allow"
+
+
+class ParameterBody(ParameterBase):
+    schema_: Optional[Union[Schema, ParameterSchema]] = Field(
+        default=None, alias="schema"
+    )
+
+
+class ParameterNotBody(ParameterBase, ParameterSchema):
+    pass
+
+    class Config:
+        extra = "allow"
+
+
+class Header(_Schema2):
+    pass
+
+
+class Response(BaseModel):
+    description: str
+    schema_: Optional[Schema] = Field(default=None, alias="schema")
+    headers: Optional[Dict[str, Union[Header, Reference]]] = None
+    examples: Optional[Any] = None  # XXX
+
+    class Config:
+        extra = "allow"
+
+
+class Operation(BaseModel):
+    tags: Optional[List[str]] = None
+    summary: Optional[str] = None
+    description: Optional[str] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+    operationId: Optional[str] = None
+    consumes: Optional[List[str]] = None  # XXX
+    produces: Optional[List[str]] = None  # XXX
+    parameters: Optional[List[Union[ParameterBody, ParameterNotBody]]] = None
+    # Using Any for Specification Extensions
+    responses: Dict[str, Union[Response, Any]]
+    schemes: Optional[List[URLSchemeEnum]] = None
+    deprecated: Optional[bool] = None
+    security: Optional[List[Dict[str, List[str]]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class PathItem(BaseModel):
+    ref: Optional[str] = Field(default=None, alias="$ref")
+    get: Optional[Operation] = None
+    put: Optional[Operation] = None
+    post: Optional[Operation] = None
+    delete: Optional[Operation] = None
+    options: Optional[Operation] = None
+    head: Optional[Operation] = None
+    patch: Optional[Operation] = None
+    parameters: Optional[List[Union[ParameterBody, ParameterNotBody]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class SecuritySchemeType(Enum):
+    apiKey = "apiKey"
+    basic = "basic"
+    oauth2 = "oauth2"
+
+
+class SecurityBase(BaseModel):
+    type_: SecuritySchemeType = Field(alias="type")
+    description: Optional[str] = None
+
+    class Config:
+        extra = "allow"
+
+
+class BasicAuth(SecurityBase):
+    pass
+
+
+class APIKeyIn(Enum):
+    query = "query"
+    header = "header"
+
+
+class APIKey(SecurityBase):
+    type_: SecuritySchemeType = Field(default=SecuritySchemeType.apiKey, alias="type")
+    in_: APIKeyIn = Field(alias="in")
+    name: str
+
+
+class OAuth2FlowIn(Enum):
+    implicit = "implicit"
+    password = "password"
+    application = "application"
+    accessCode = "accessCode"
+
+
+class OAuth2FlowBase(SecurityBase):
+    flow: OAuth2FlowIn
+    scopes: Dict[str, str] = {}
+
+    class Config:
+        extra = "allow"
+
+
+class OAuth2Implicit(OAuth2FlowBase):
+    authorizationUrl: str
+
+
+class OAuth2Password(OAuth2FlowBase):
+    tokenUrl: str
+
+
+class OAuth2Application(OAuth2FlowBase):
+    tokenUrl: str
+
+
+class OAuth2AccessCode(OAuth2FlowBase):
+    authorizationUrl: str
+    tokenUrl: str
+
+
+SecurityScheme = Union[
+    BasicAuth,
+    APIKey,
+    OAuth2Implicit,
+    OAuth2Password,
+    OAuth2Application,
+    OAuth2AccessCode,
+]
+
+
+class Tag(BaseModel):
+    name: str
+    description: Optional[str] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Swagger2(BaseModel):
+    swagger: str
+    info: Info
+    host: Optional[str] = None  # URLHost
+    basePath: Optional[str] = None  # URLBasePath
+    schemes: Optional[List[URLSchemeEnum]] = None
+    consumes: Optional[List[str]] = None
+    produces: Optional[List[str]] = None
+    paths: Dict[str, Union[PathItem, Any]]
+    definitions: Optional[Dict[str, Union[Schema, Reference]]] = None
+    parameters: Optional[
+        Dict[str, Union[ParameterBody, ParameterNotBody, Reference]]
+    ] = None
+    responses: Optional[Dict[str, Union[Response, Reference]]] = None
+    securityDefinitions: Optional[Dict[str, Union[SecurityScheme, Reference]]]
+    security: Optional[List[Dict[str, List[str]]]] = None
+    tags: Optional[List[Tag]] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+
+    class Config:
+        extra = "allow"
+
+
+Schema.update_forward_refs()
+Operation.update_forward_refs()
+# Encoding.update_forward_refs()

fastapi_swagger2/utils.py

@@ -0,0 +1,456 @@
+import http.client
+import inspect
+from enum import Enum
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, cast
+from urllib.parse import ParseResult, urlparse
+
+from fastapi import routing
+from fastapi.datastructures import DefaultPlaceholder
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import get_flat_dependant, get_flat_params
+from fastapi.encoders import jsonable_encoder
+from fastapi.logger import logger
+from fastapi.openapi.constants import METHODS_WITH_BODY
+from fastapi.openapi.utils import (
+    get_flat_models_from_routes,
+    get_openapi_operation_metadata,
+    status_code_ranges,
+)
+from fastapi.params import Body, Param
+from fastapi.responses import Response
+from fastapi.utils import deep_dict_update, is_body_allowed_for_status_code
+from pydantic import BaseModel
+from pydantic.fields import ModelField, Undefined
+from pydantic.schema import field_schema, get_model_name_map, model_process_schema
+from pydantic.utils import lenient_issubclass
+from starlette.responses import JSONResponse
+from starlette.routing import BaseRoute
+from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
+
+from fastapi_swagger2.constants import REF_PREFIX
+from fastapi_swagger2.models import Swagger2
+
+validation_error_definition = {
+    "title": "ValidationError",
+    "type": "object",
+    "properties": {
+        "loc": {
+            "title": "Location",
+            "type": "array",
+            "items": {"type": "string"},
+        },
+        "msg": {"title": "Message", "type": "string"},
+        "type": {"title": "Error Type", "type": "string"},
+    },
+    "required": ["loc", "msg", "type"],
+}
+
+validation_error_response_definition = {
+    "title": "HTTPValidationError",
+    "type": "object",
+    "properties": {
+        "detail": {
+            "title": "Detail",
+            "type": "array",
+            "items": {"$ref": REF_PREFIX + "ValidationError"},
+        }
+    },
+}
+
+
+def get_model_definitions(
+    *,
+    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> Dict[str, Any]:
+    definitions: Dict[str, Dict[str, Any]] = {}
+    for model in flat_models:
+        m_schema, m_definitions, m_nested_models = model_process_schema(
+            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+        )
+        definitions.update(m_definitions)
+        model_name = model_name_map[model]
+        if "description" in m_schema:
+            m_schema["description"] = m_schema["description"].split("\f")[0]
+        definitions[model_name] = m_schema
+    return definitions
+
+
+def get_swagger2_security_definitions(
+    flat_dependant: Dependant,
+) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+    def _map_oauth2_flow(flow_key: str, flow: Dict[str, Any]) -> Dict[str, Any]:
+        security_definition = {
+            "type": "oauth2",
+            "flow": flow_key,
+            "scopes": flow["scopes"],
+        }
+        if "authorizationUrl" in flow:
+            security_definition.update({"authorizationUrl": flow["authorizationUrl"]})
+        if "tokenUrl" in flow:
+            security_definition.update({"tokenUrl": flow["tokenUrl"]})
+
+        return security_definition
+
+    oauth2_flows_keys_map = {
+        "implicit": "implicit",
+        "password": "password",
+        "clientCredentials": "application",
+        "authorizationCode": "accessCode",
+    }
+    security_definitions = {}
+    operation_security = []
+    for security_requirement in flat_dependant.security_requirements:
+        # fastapi.security.* which gets model from fastapi.openapi.models
+        security_definition = jsonable_encoder(
+            security_requirement.security_scheme.model,
+            by_alias=True,
+            exclude_none=True,
+        )
+        if security_definition["type"] == "http":
+            if security_definition.get("scheme", "basic") == "basic":
+                security_definition = {"type": "basic"}
+            else:
+                logger.warning(
+                    f"fastapi_swagger2: Unable to handle security_definition: {security_definition}"
+                )
+        elif security_definition["type"] == "apiKey":
+            pass
+        elif security_definition["type"] == "oauth2":
+            _security_definition = security_definition
+            flows = security_definition["flows"]
+            flows_keys = list(flows.keys())
+            if len(flows_keys) >= 1:
+                flow_key_3 = flows_keys[0]
+                flow = flows[flow_key_3]
+                security_definition = _map_oauth2_flow(
+                    oauth2_flows_keys_map[flow_key_3], flow
+                )
+
+                for i in range(1, len(flows_keys)):
+                    flow_key_3 = flows_keys[i]
+                    flow = flows[flow_key_3]
+                    flow_key_2 = oauth2_flows_keys_map[flow_key_3]
+                    security_definition_1 = _map_oauth2_flow(flow_key_2, flow)
+                    security_name = security_requirement.security_scheme.scheme_name
+                    _security_name = security_name + "_" + flow_key_2
+                    security_definitions[_security_name] = security_definition_1
+                    operation_security.append(
+                        {_security_name: security_requirement.scopes}
+                    )
+        else:
+            logger.warning(
+                f"fastapi_swagger2: Unable to handle security_definition: {security_definition}"
+            )
+        security_name = security_requirement.security_scheme.scheme_name
+        security_definitions[security_name] = security_definition
+        operation_security.append({security_name: security_requirement.scopes})
+    return security_definitions, operation_security
+
+
+def get_swagger2_operation_parameters(
+    *,
+    all_route_params: Sequence[ModelField],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> List[Dict[str, Any]]:
+    parameters = []
+    for param in all_route_params:
+        field_info = param.field_info
+        field_info = cast(Param, field_info)
+        if not field_info.include_in_schema:
+            continue
+        parameter: Dict[str, Any] = {
+            "name": param.alias,
+            "in": field_info.in_.value,
+            "required": param.required,
+        }
+        schema: Dict[str, Any] = field_schema(
+            param, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+        )[0]
+        if field_info.in_.value == "body":
+            parameter["schema"] = schema
+        else:
+            parameter.update({k: v for (k, v) in schema.items() if k != "title"})
+        if field_info.description:
+            parameter["description"] = field_info.description
+        if field_info.examples:
+            parameter["examples"] = jsonable_encoder(field_info.examples)
+        elif field_info.example != Undefined:
+            parameter["example"] = jsonable_encoder(field_info.example)
+        if field_info.deprecated:
+            parameter["deprecated"] = field_info.deprecated
+        parameters.append(parameter)
+    return parameters
+
+
+def get_swagger2_operation_request_body(
+    *,
+    body_field: Optional[ModelField],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> Optional[Dict[str, Any]]:
+    if not body_field:
+        return None
+    assert isinstance(body_field, ModelField)
+    body_schema, _, _ = field_schema(
+        body_field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+    )
+    field_info = cast(Body, body_field.field_info)
+    # request_media_type = field_info.media_type
+    required = body_field.required
+    request_body_oai: Dict[str, Any] = {}
+    request_body_oai["name"] = body_field.alias
+    request_body_oai["in"] = "body"
+    if required:
+        request_body_oai["required"] = required
+
+    request_media_content: Dict[str, Any] = {"schema": body_schema}
+    if field_info.examples:
+        request_media_content["examples"] = jsonable_encoder(field_info.examples)
+    elif field_info.example != Undefined:
+        request_media_content["example"] = jsonable_encoder(field_info.example)
+    # request_body_oai["content"] = {request_media_type: request_media_content}
+    request_body_oai.update(request_media_content)
+    return request_body_oai
+
+
+def get_swagger2_path(
+    *, route: routing.APIRoute, model_name_map: Dict[type, str], operation_ids: Set[str]
+) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any]]:
+    path: Dict[str, Any] = {}
+    security_schemes: Dict[str, Any] = {}
+    definitions: Dict[str, Any] = {}
+    assert route.methods is not None, "Methods must be a list"
+
+    if isinstance(route.response_class, DefaultPlaceholder):
+        current_response_class: Type[Response] = route.response_class.value
+    else:
+        current_response_class = route.response_class
+    assert current_response_class, "A response class is needed to generate Swagger"
+
+    route_response_media_type: Optional[str] = current_response_class.media_type
+    if route.include_in_schema:
+        for method in route.methods:
+            operation = get_openapi_operation_metadata(
+                route=route, method=method, operation_ids=operation_ids
+            )
+
+            parameters: List[Dict[str, Any]] = []
+            flat_dependant = get_flat_dependant(route.dependant, skip_repeats=True)
+            (
+                security_definitions,
+                operation_security,
+            ) = get_swagger2_security_definitions(flat_dependant=flat_dependant)
+
+            if operation_security:
+                operation.setdefault("security", []).extend(operation_security)
+
+            if security_definitions:
+                security_schemes.update(security_definitions)
+
+            all_route_params = get_flat_params(route.dependant)
+            operation_parameters = get_swagger2_operation_parameters(
+                all_route_params=all_route_params, model_name_map=model_name_map
+            )
+            parameters.extend(operation_parameters)
+            if parameters:
+                all_parameters = {
+                    (param["in"], param["name"]): param for param in parameters
+                }
+                required_parameters = {
+                    (param["in"], param["name"]): param
+                    for param in parameters
+                    if param.get("required")
+                }
+                # Make sure required definitions of the same parameter take precedence
+                # over non-required definitions
+                all_parameters.update(required_parameters)
+
+                if method in METHODS_WITH_BODY:
+                    request_body_oai = get_swagger2_operation_request_body(
+                        body_field=route.body_field, model_name_map=model_name_map
+                    )
+                    if request_body_oai:
+                        all_parameters.update({("body", "body"): request_body_oai})
+
+                operation["parameters"] = list(all_parameters.values())
+
+            if route.callbacks:
+                callbacks = {}
+                for callback in route.callbacks:
+                    if isinstance(callback, routing.APIRoute):
+                        (
+                            cb_path,
+                            cb_security_schemes,
+                            cb_definitions,
+                        ) = get_swagger2_path(
+                            route=callback,
+                            model_name_map=model_name_map,
+                            operation_ids=operation_ids,
+                        )
+                        callbacks[callback.name] = {callback.path: cb_path}
+                operation["callbacks"] = callbacks
+
+            if route.status_code is not None:
+                status_code = str(route.status_code)
+            else:
+                # It would probably make more sense for all response classes to have an
+                # explicit default status_code, and to extract it from them, instead of
+                # doing this inspection tricks, that would probably be in the future
+                # TODO: probably make status_code a default class attribute for all
+                # responses in Starlette
+                response_signature = inspect.signature(current_response_class.__init__)
+                status_code_param = response_signature.parameters.get("status_code")
+                if status_code_param is not None:
+                    if isinstance(status_code_param.default, int):
+                        status_code = str(status_code_param.default)
+            operation.setdefault("responses", {}).setdefault(status_code, {})[
+                "description"
+            ] = route.response_description
+
+            if route_response_media_type and is_body_allowed_for_status_code(
+                route.status_code
+            ):
+                response_schema = {"type": "string"}
+                if lenient_issubclass(current_response_class, JSONResponse):
+                    if route.response_field:
+                        response_schema, _, _ = field_schema(
+                            route.response_field,
+                            model_name_map=model_name_map,
+                            ref_prefix=REF_PREFIX,
+                        )
+                    else:
+                        response_schema = {}
+                operation.setdefault("responses", {}).setdefault(status_code, {})[
+                    "schema"
+                ] = response_schema
+                operation.setdefault("produces", []).append(route_response_media_type)
+
+            if route.responses:
+                operation_responses = operation.setdefault("responses", {})
+                for (
+                    additional_status_code,
+                    additional_response,
+                ) in route.responses.items():
+                    process_response = additional_response.copy()
+                    process_response.pop("model", None)
+                    status_code_key = str(additional_status_code).upper()
+                    if status_code_key == "DEFAULT":
+                        status_code_key = "default"
+                    openapi_response = operation_responses.setdefault(
+                        status_code_key, {}
+                    )
+                    assert isinstance(
+                        process_response, dict
+                    ), "An additional response must be a dict"
+                    field = route.response_fields.get(additional_status_code)
+                    additional_field_schema: Optional[Dict[str, Any]] = None
+                    if field:
+                        additional_field_schema, _, _ = field_schema(
+                            field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+                        )
+                        # media_type = route_response_media_type or "application/json"
+                        additional_schema = process_response.setdefault("schema", {})
+                        deep_dict_update(additional_schema, additional_field_schema)
+                    status_text: Optional[str] = status_code_ranges.get(
+                        str(additional_status_code).upper()
+                    ) or http.client.responses.get(int(additional_status_code))
+                    description = (
+                        process_response.get("description")
+                        or openapi_response.get("description")
+                        or status_text
+                        or "Additional Response"
+                    )
+                    deep_dict_update(openapi_response, process_response)
+                    openapi_response["description"] = description
+
+            http422 = str(HTTP_422_UNPROCESSABLE_ENTITY)
+            if (all_route_params or route.body_field) and not any(
+                status in operation["responses"]
+                for status in [http422, "4XX", "default"]
+            ):
+                operation["responses"][http422] = {
+                    "description": "Validation Error",
+                    "schema": {"$ref": REF_PREFIX + "HTTPValidationError"},
+                }
+                if "ValidationError" not in definitions:
+                    definitions.update(
+                        {
+                            "ValidationError": validation_error_definition,
+                            "HTTPValidationError": validation_error_response_definition,
+                        }
+                    )
+            if route.openapi_extra:
+                deep_dict_update(operation, route.openapi_extra)
+            path[method.lower()] = operation
+
+    return path, security_schemes, definitions
+
+
+def get_swagger2(
+    *,
+    title: str,
+    version: str,
+    swagger2_version: str = "2.0",
+    description: Optional[str] = None,
+    routes: Sequence[BaseRoute],
+    tags: Optional[List[Dict[str, Any]]] = None,
+    server: Optional[str] = None,
+    terms_of_service: Optional[str] = None,
+    contact: Optional[Dict[str, Union[str, Any]]] = None,
+    license_info: Optional[Dict[str, Union[str, Any]]] = None,
+) -> Dict[str, Any]:
+    info: Dict[str, Any] = {"title": title, "version": version}
+    if description:
+        info["description"] = description
+    if terms_of_service:
+        info["termsOfService"] = terms_of_service
+    if contact:
+        info["contact"] = contact
+    if license_info:
+        info["license"] = license_info
+
+    output: Dict[str, Any] = {"swagger": swagger2_version, "info": info}
+
+    if server:
+        pr: ParseResult = urlparse(server)
+        output["host"] = pr.netloc
+        output["basePath"] = pr.path or "/"
+        output.setdefault("schemes", []).append(pr.scheme)
+
+    paths: Dict[str, Dict[str, Any]] = {}
+    operation_ids: Set[str] = set()
+
+    flat_models = get_flat_models_from_routes(routes)
+    model_name_map = get_model_name_map(flat_models)
+    definitions = get_model_definitions(
+        flat_models=flat_models, model_name_map=model_name_map
+    )
+
+    for route in routes:
+        if isinstance(route, routing.APIRoute):
+            result = get_swagger2_path(
+                route=route, model_name_map=model_name_map, operation_ids=operation_ids
+            )
+            if result:
+                path, security_schemes, path_definitions = result
+
+                if path:
+                    paths.setdefault(route.path_format, {}).update(path)
+
+                if security_schemes:
+                    output.setdefault("securityDefinitions", {}).update(
+                        security_schemes
+                    )
+
+                if path_definitions:
+                    definitions.update(path_definitions)
+
+    output["paths"] = paths
+
+    if definitions:
+        output["definitions"] = {k: definitions[k] for k in sorted(definitions)}
+
+    if tags:
+        output["tags"] = tags
+
+    return jsonable_encoder(Swagger2(**output), by_alias=True, exclude_none=True)  # type: ignore

fastapi_swagger2-0.0.1.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: fastapi_swagger2
+Version: 0.0.1
+Summary: Swagger2 support for FastAPI framework
+Project-URL: Homepage, https://github.com/virajkanwade/fastapi_swagger2
+Project-URL: Documentation, https://github.com/virajkanwade/fastapi_swagger2
+Author-email: Viraj Kanwade <virajk.oib@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2023 Viraj Kanwade
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 1
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: fastapi>=0.79.0
+Provides-Extra: all
+Requires-Dist: httpx>=0.23.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: ruff==0.0.272; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: black==23.3.0; extra == 'test'
+Requires-Dist: coverage[toml]<8.0,>=6.5.0; extra == 'test'
+Requires-Dist: httpx<0.24.0,>=0.23.0; extra == 'test'
+Requires-Dist: isort<6.0.0,>=5.0.6; extra == 'test'
+Requires-Dist: mypy==1.3.0; extra == 'test'
+Requires-Dist: pytest<8.0.0,>=7.1.3; extra == 'test'
+Requires-Dist: ruff==0.0.272; extra == 'test'
+Description-Content-Type: text/markdown
+
+# fastapi_swagger2
+<p align="center">
+Swagger2 support for FastAPI
+</p>
+<p align="center">
+<a href="https://pypi.org/project/fastapi_swagger2" target="_blank">
+    <img src="https://img.shields.io/pypi/v/fastapi_swagger2?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+<a href="https://pypi.org/project/fastapi_swagger2" target="_blank">
+    <img src="https://img.shields.io/pypi/pyversions/fastapi_swagger2.svg?color=%2334D058" alt="Supported Python versions">
+</a>
+</p>
+
+---
+
+_Reason behind this library:_
+
+Few API GW services like Google Cloud API GW still support only Swagger 2.0 spec. Since FastAPI only supports OAS3, it is a challenge. Converting from OAS3 to Swagger 2.0 requires some manual steps which would hinder CI/CD.
+
+---
+
+## Requirements
+
+Python 3.8+
+
+FastAPI 0.79.0+
+
+## Installation
+
+<div class="termy">
+
+```console
+$ pip install fastapi_swagger2
+```
+
+</div>
+
+## Example
+
+```Python
+from typing import Union
+
+from fastapi import FastAPI
+from fastapi_swagger2 import FastAPISwagger2
+
+app = FastAPI()
+FastAPISwagger2(app)
+
+
+@app.get("/")
+def read_root():
+    return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: Union[str, None] = None):
+    return {"item_id": item_id, "q": q}
+```
+
+This adds following endpoints:
+* http://localhost:8000/swagger2.json
+* http://localhost:8000/swagger2/docs
+* http://localhost:8000/swagger2/redoc
+
+## Development
+
+```console
+$ pip install "/path/to/fastapi_swagger2/repo[test,all]"
+```

fastapi_swagger2-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+fastapi_swagger2/__init__.py,sha256=lMqJDEL0ul7-HQkDP7kZt2oT3xxo9obO3OEXI85Klm8,5674
+fastapi_swagger2/constants.py,sha256=CocDvqrd9i-APawDkQMJlSltfg329f5FsFJ0UM2k0wc,30
+fastapi_swagger2/models.py,sha256=Qe_MgqzTuBj2oXHMqdhyCIGFG4QkC4Sz6qLugd2B7Ko,9198
+fastapi_swagger2/utils.py,sha256=ouYny39RgjJ6ddY43-83TLmCjOI9_qc4AJPcAehcDdI,18893
+fastapi_swagger2-0.0.1.dist-info/METADATA,sha256=A2jB_6kfHFf7bK_BWFcG277sdF-W9MiaFh5DsGpORys,4768
+fastapi_swagger2-0.0.1.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+fastapi_swagger2-0.0.1.dist-info/licenses/LICENSE,sha256=Ro8vX7VuT9CkpLBBRrKO7G2NY0CD5ZVLwL1_snxmd-E,1070
+fastapi_swagger2-0.0.1.dist-info/RECORD,,

fastapi_swagger2-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.17.1
+Root-Is-Purelib: true
+Tag: py3-none-any

fastapi_swagger2-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Viraj Kanwade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.