revert: "feat: show fastapi routes in playground ui" (#5323)

Revert "feat: show fastapi routes in playground ui (#5314)"

This reverts commit b9f63e6.

Author: frostming

src/_bentoml_sdk/method.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import copy
 import functools
 import inspect
 import sys
@@ -197,7 +196,7 @@ def schema(self) -> dict[str, t.Any]:
     def openapi_request(self) -> dict[str, t.Any]:
         from .service.openapi import REF_TEMPLATE
 
-        input = flatten_field(
+        input = _flatten_field(
             _only_include(
                 self.input_spec.model_json_schema(
                     ref_template=REF_TEMPLATE, mode="serialization"
@@ -224,7 +223,7 @@ def openapi_request(self) -> dict[str, t.Any]:
     def openapi_response(self) -> dict[str, t.Any]:
         from .service.openapi import REF_TEMPLATE
 
-        output = flatten_field(
+        output = _flatten_field(
             _only_include(
                 self.output_spec.model_json_schema(
                     ref_template=REF_TEMPLATE, mode="serialization"
@@ -243,45 +242,30 @@ def openapi_response(self) -> dict[str, t.Any]:
         }
 
 
-def flatten_field(
+def _flatten_field(
     schema: dict[str, t.Any],
     defs: dict[str, t.Any],
     max_depth: int | None = None,
     _depth: int = 0,
-    def_prefix: str = "#/$defs/",
 ) -> dict[str, t.Any]:
     if "allOf" in schema:
         schema.update(schema.pop("allOf")[0])
     if "anyOf" in schema:
-        if len(schema["anyOf"]) == 2 and schema["anyOf"][1].get("type") == "null":
-            schema.update(schema.pop("anyOf")[0])
-        else:  # we are not able to handle this, convert to a plain object
-            schema.update(type="object")
-            schema.pop("anyOf")
+        schema.update(schema.pop("anyOf")[0])
     if max_depth is not None and _depth >= max_depth:
         return schema
     if "$ref" in schema:
-        ref = schema.pop("$ref")[len(def_prefix) :]
-        schema.update(
-            flatten_field(
-                copy.deepcopy(defs[ref]),
-                defs,
-                max_depth,
-                _depth=_depth + 1,
-                def_prefix=def_prefix,
-            )
-        )
+        ref = schema.pop("$ref")[len("#/$defs/") :]
+        schema.update(_flatten_field(defs[ref], defs, max_depth, _depth=_depth + 1))
     elif schema.get("type") == "object" and "properties" in schema:
         for k, v in schema["properties"].items():
-            schema["properties"][k] = flatten_field(
-                v, defs, max_depth, _depth=_depth + 1, def_prefix=def_prefix
+            schema["properties"][k] = _flatten_field(
+                v, defs, max_depth, _depth=_depth + 1
             )
     elif schema.get("type") == "array" and "items" in schema:
-        schema["items"] = flatten_field(
-            schema["items"], defs, max_depth, _depth=_depth + 1, def_prefix=def_prefix
+        schema["items"] = _flatten_field(
+            schema["items"], defs, max_depth, _depth=_depth + 1
         )
-    elif schema.get("type") == "string" and schema.get("format") == "binary":
-        schema["type"] = "file"
     return schema
 
 
@@ -290,4 +274,4 @@ def _flatten_model_schema(model: type[IODescriptor]) -> dict[str, t.Any]:
     if not schema.get("properties"):
         return schema
     defs = schema.pop("$defs", {})
-    return flatten_field(schema, defs)
+    return _flatten_field(schema, defs)

src/_bentoml_sdk/service/factory.py

@@ -23,10 +23,8 @@
 from bentoml._internal.configuration.containers import BentoMLContainer
 from bentoml._internal.context import ServiceContext
 from bentoml._internal.models import Model as StoredModel
-from bentoml._internal.types import LazyType
 from bentoml._internal.utils import deprecated
 from bentoml._internal.utils import dict_filter_none
-from bentoml._internal.utils import join_path
 from bentoml.exceptions import BentoMLConfigException
 from bentoml.exceptions import BentoMLException
 
@@ -42,8 +40,6 @@
 T = t.TypeVar("T", bound=object)
 
 if t.TYPE_CHECKING:
-    import fastapi as fastapi
-
     from bentoml._internal import external_typing as ext
     from bentoml._internal.service.openapi.specification import OpenAPISpecification
     from bentoml._internal.utils.circus import Server
@@ -211,55 +207,11 @@ def doc(self) -> str:
         return get_default_svc_readme(self)
 
     def schema(self) -> dict[str, t.Any]:
-        from ..method import flatten_field
-
-        routes = [method.schema() for method in self.apis.values()]
-        for app, path, _ in self.mount_apps:
-            if not LazyType["fastapi.FastAPI"]("fastapi.FastAPI").isinstance(app):
-                continue
-            from fastapi.openapi.utils import get_openapi
-
-            openapi = get_openapi(
-                title=app.title, version=app.version, routes=app.routes
-            )
-            defs = openapi.get("components", {}).get("schemas", {})
-            for subpath, methods in openapi["paths"].items():
-                if "post" not in methods:
-                    continue
-                method = methods["post"]
-                subpath = join_path(path, subpath)
-                request_body = method.get("requestBody", {}).get("content", {})
-                input_schema = next(iter(request_body.values())).get(
-                    "schema", {"type": "object"}
-                )
-                response_body = (
-                    method.get("responses", {}).get("200", {}).get("content", {})
-                )
-                output_schema = next(iter(response_body.values())).get(
-                    "schema", {"type": "object"}
-                )
-                route = dict_filter_none(
-                    {
-                        "name": subpath.strip("/").replace("/", "_"),
-                        "route": subpath,
-                        "description": method.get("summary", ""),
-                        "batchable": False,
-                        "input": flatten_field(
-                            input_schema, defs, def_prefix="#/components/schemas/"
-                        ),
-                        "output": flatten_field(
-                            output_schema, defs, def_prefix="#/components/schemas/"
-                        ),
-                        "is_task": False,
-                    }
-                )
-                routes.append(route)
-
         return dict_filter_none(
             {
                 "name": self.name,
                 "type": "service",
-                "routes": routes,
+                "routes": [method.schema() for method in self.apis.values()],
                 "description": getattr(self.inner, "__doc__", None),
             }
         )

src/_bentoml_sdk/service/openapi.py

@@ -20,7 +20,6 @@
 from bentoml._internal.service.openapi.utils import exception_schema
 from bentoml._internal.types import LazyType
 from bentoml._internal.utils import deep_merge
-from bentoml._internal.utils import join_path
 from bentoml._internal.utils.cattr import bentoml_cattr
 from bentoml.exceptions import InternalServerError
 from bentoml.exceptions import InvalidArgument
@@ -39,6 +38,9 @@ def generate_spec(svc: Service[t.Any], *, openapi_version: str = "3.0.2"):
     mounted_app_paths = {}
     schema_components: dict[str, dict[str, Schema]] = {}
 
+    def join_path(prefix: str, path: str) -> str:
+        return f"{prefix.rstrip('/')}/{path.lstrip('/')}"
+
     for app, path, _ in svc.mount_apps:
         if LazyType["fastapi.FastAPI"]("fastapi.FastAPI").isinstance(app):
             from fastapi.openapi.utils import get_openapi

src/bentoml/_internal/utils/__init__.py

@@ -505,10 +505,6 @@ def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
     return decorator
 
 
-def join_path(prefix: str, path: str) -> str:
-    return f"{prefix.rstrip('/')}/{path.lstrip('/')}"
-
-
 def is_jupyter() -> bool:  # pragma: no cover
     """Check if we're running in a Jupyter notebook."""
     try: