paddlex 3.0.0rc0__py3-none-any.whl → 3.0.1__py3-none-any.whl

paddlex/inference/serving/basic_serving/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/serving/basic_serving/_app.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,20 +28,25 @@ from typing import (
     TypeVar,
 )
 
-import aiohttp
-import fastapi
-from fastapi.encoders import jsonable_encoder
-from fastapi.exceptions import RequestValidationError
-from fastapi.responses import JSONResponse
-from starlette.exceptions import HTTPException
 from typing_extensions import ParamSpec, TypeGuard
 
 from ....utils import logging
+from ....utils.deps import class_requires_deps, function_requires_deps, is_dep_available
 from ...pipelines import BasePipeline
 from ..infra.config import AppConfig
-from ..infra.models import NoResultResponse
+from ..infra.models import AIStudioNoResultResponse
 from ..infra.utils import call_async, generate_log_id
 
+if is_dep_available("aiohttp"):
+    import aiohttp
+if is_dep_available("fastapi"):
+    import fastapi
+    from fastapi.encoders import jsonable_encoder
+    from fastapi.exceptions import RequestValidationError
+    from fastapi.responses import JSONResponse
+if is_dep_available("starlette"):
+    from starlette.exceptions import HTTPException
+
 PipelineT = TypeVar("PipelineT", bound=BasePipeline)
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -64,6 +69,7 @@ def _is_error(obj: object) -> TypeGuard[_Error]:
 # for type hinting. However, I would stick with the current design, as it does
 # not introduce runtime overhead at the moment and may prove useful in the
 # future.
+@class_requires_deps("fastapi")
 class PipelineWrapper(Generic[PipelineT]):
     def __init__(self, pipeline: PipelineT) -> None:
         super().__init__()
@@ -94,6 +100,7 @@ class PipelineWrapper(Generic[PipelineT]):
             return await call_async(func, *args, **kwargs)
 
 
+@class_requires_deps("aiohttp")
 class AppContext(Generic[PipelineT]):
     def __init__(self, *, config: AppConfig) -> None:
         super().__init__()
@@ -117,21 +124,22 @@ class AppContext(Generic[PipelineT]):
         self._pipeline = val
 
     @property
-    def aiohttp_session(self) -> aiohttp.ClientSession:
+    def aiohttp_session(self) -> "aiohttp.ClientSession":
         if not self._aiohttp_session:
             raise AttributeError("`aiohttp_session` has not been set.")
         return self._aiohttp_session
 
     @aiohttp_session.setter
-    def aiohttp_session(self, val: aiohttp.ClientSession) -> None:
+    def aiohttp_session(self, val: "aiohttp.ClientSession") -> None:
         self._aiohttp_session = val
 
 
+@function_requires_deps("fastapi", "aiohttp", "starlette")
 def create_app(
     *, pipeline: PipelineT, app_config: AppConfig, app_aiohttp_session: bool = True
-) -> Tuple[fastapi.FastAPI, AppContext[PipelineT]]:
+) -> Tuple["fastapi.FastAPI", AppContext[PipelineT]]:
     @contextlib.asynccontextmanager
-    async def _app_lifespan(app: fastapi.FastAPI) -> AsyncGenerator[None, None]:
+    async def _app_lifespan(app: "fastapi.FastAPI") -> AsyncGenerator[None, None]:
         ctx.pipeline = PipelineWrapper[PipelineT](pipeline)
         if app_aiohttp_session:
             async with aiohttp.ClientSession(
@@ -148,8 +156,8 @@ def create_app(
     app.state.context = ctx
 
     @app.get("/health", operation_id="checkHealth")
-    async def _check_health() -> NoResultResponse:
-        return NoResultResponse(
+    async def _check_health() -> AIStudioNoResultResponse:
+        return AIStudioNoResultResponse(
             logId=generate_log_id(), errorCode=0, errorMsg="Healthy"
         )
 
@@ -158,7 +166,7 @@ def create_app(
         request: fastapi.Request, exc: RequestValidationError
     ) -> JSONResponse:
         json_compatible_data = jsonable_encoder(
-            NoResultResponse(
+            AIStudioNoResultResponse(
                 logId=generate_log_id(),
                 errorCode=422,
                 errorMsg=json.dumps(exc.errors()),
@@ -171,7 +179,7 @@ def create_app(
         request: fastapi.Request, exc: HTTPException
     ) -> JSONResponse:
         json_compatible_data = jsonable_encoder(
-            NoResultResponse(
+            AIStudioNoResultResponse(
                 logId=generate_log_id(), errorCode=exc.status_code, errorMsg=exc.detail
             )
         )
@@ -185,7 +193,7 @@ def create_app(
         # necessary to log the exception info here?
         logging.exception("Unhandled exception")
         json_compatible_data = jsonable_encoder(
-            NoResultResponse(
+            AIStudioNoResultResponse(
                 logId=generate_log_id(),
                 errorCode=500,
                 errorMsg="Internal server error",
@@ -197,13 +205,17 @@ def create_app(
 
 
 # TODO: Precise type hints
+@function_requires_deps("fastapi")
 def primary_operation(
-    app: fastapi.FastAPI, path: str, operation_id: str, **kwargs: Any
+    app: "fastapi.FastAPI", path: str, operation_id: str, **kwargs: Any
 ) -> Callable:
     return app.post(
         path,
         operation_id=operation_id,
-        responses={422: {"model": NoResultResponse}, 500: {"model": NoResultResponse}},
+        responses={
+            422: {"model": AIStudioNoResultResponse},
+            500: {"model": AIStudioNoResultResponse},
+        },
         response_model_exclude_none=True,
         **kwargs,
     )

paddlex/inference/serving/basic_serving/_pipeline_apps/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,10 +15,12 @@
 import importlib
 from typing import Any, Dict
 
-from fastapi import FastAPI
-
+from .....utils.deps import function_requires_deps, is_dep_available
 from ...infra.config import create_app_config
 
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+
 
 def _pipeline_name_to_mod_name(pipeline_name: str) -> str:
     if not pipeline_name:
@@ -31,7 +33,8 @@ def _pipeline_name_to_mod_name(pipeline_name: str) -> str:
 
 # XXX: A dynamic approach is used here for writing fewer lines of code, at the
 # cost of sacrificing some benefits of type hints.
-def create_pipeline_app(pipeline: Any, pipeline_config: Dict[str, Any]) -> FastAPI:
+@function_requires_deps("fastapi")
+def create_pipeline_app(pipeline: Any, pipeline_config: Dict[str, Any]) -> "FastAPI":
     pipeline_name = pipeline_config["pipeline_name"]
     mod_name = _pipeline_name_to_mod_name(pipeline_name)
     mod = importlib.import_module(f".{mod_name}", package=__package__)

paddlex/inference/serving/basic_serving/_pipeline_apps/_common/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/serving/basic_serving/_pipeline_apps/_common/common.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,16 +15,19 @@
 import os
 from typing import Dict, Optional, Tuple, Union
 
-import cv2
 import numpy as np
 from PIL.Image import Image
 
+from ......utils.deps import function_requires_deps, is_dep_available
 from ....infra import utils as serving_utils
 from ....infra.storage import Storage, SupportsGetURL
 
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
 
 def prune_result(result: dict) -> dict:
-    KEYS_TO_REMOVE = ["input_path"]
+    KEYS_TO_REMOVE = ["input_path", "page_index"]
 
     def _process_obj(obj):
         if isinstance(obj, dict):
@@ -39,6 +42,7 @@ def prune_result(result: dict) -> dict:
     return _process_obj(result)
 
 
+@function_requires_deps("opencv-contrib-python")
 def postprocess_image(
     image: np.ndarray,
     log_id: str,
@@ -86,7 +90,11 @@ def postprocess_images(
     output_images: Dict[str, str] = {}
     for key, img in images.items():
         output_images[key] = postprocess_image(
-            np.array(img) if isinstance(img, Image) else img,
+            (
+                cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2BGR)
+                if isinstance(img, Image)
+                else img
+            ),
             log_id=log_id,
             filename=filename_template.format(key=key),
             file_storage=file_storage,

paddlex/inference/serving/basic_serving/_pipeline_apps/_common/image_recognition.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/serving/basic_serving/_pipeline_apps/_common/ocr.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,15 +15,19 @@
 from typing import Final, List, Tuple, Union
 
 import numpy as np
-from fastapi import HTTPException
 from typing_extensions import Literal
 
+from ......utils.deps import function_requires_deps, is_dep_available
 from ....infra import utils as serving_utils
 from ....infra.models import ImageInfo, PDFInfo
 from ....infra.storage import SupportsGetURL, create_storage
 from ....schemas.shared.ocr import BaseInferRequest
 from ..._app import AppContext
 
+if is_dep_available("fastapi"):
+    from fastapi import HTTPException
+
+
 DEFAULT_MAX_NUM_INPUT_IMGS: Final[int] = 10
 DEFAULT_MAX_OUTPUT_IMG_SIZE: Final[Tuple[int, int]] = (2000, 2000)
 
@@ -52,6 +56,7 @@ def update_app_context(app_context: AppContext) -> None:
     )
 
 
+@function_requires_deps("fastapi")
 def get_file_type(request: BaseInferRequest) -> Literal["PDF", "IMAGE"]:
     if request.fileType is None:
         if serving_utils.is_url(request.file):

paddlex/inference/serving/basic_serving/_pipeline_apps/anomaly_detection.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,16 +14,19 @@
 
 from typing import Any
 
-from fastapi import FastAPI
-
+from .....utils.deps import function_requires_deps, is_dep_available
 from ...infra import utils as serving_utils
 from ...infra.config import AppConfig
-from ...infra.models import ResultResponse
+from ...infra.models import AIStudioResultResponse
 from ...schemas.anomaly_detection import INFER_ENDPOINT, InferRequest, InferResult
 from .._app import create_app, primary_operation
 
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+
 
-def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
+@function_requires_deps("fastapi")
+def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     app, ctx = create_app(
         pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
     )
@@ -33,7 +36,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
         INFER_ENDPOINT,
         "infer",
     )
-    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+    async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
 
@@ -54,7 +57,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
         else:
             output_image_base64 = None
 
-        return ResultResponse[InferResult](
+        return AIStudioResultResponse[InferResult](
             logId=serving_utils.generate_log_id(),
             result=InferResult(
                 labelMap=label_map, size=size, image=output_image_base64

paddlex/inference/serving/basic_serving/_pipeline_apps/doc_preprocessor.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,18 +14,21 @@
 
 from typing import Any, Dict, List
 
-from fastapi import FastAPI
-
+from .....utils.deps import function_requires_deps, is_dep_available
 from ...infra import utils as serving_utils
 from ...infra.config import AppConfig
-from ...infra.models import ResultResponse
+from ...infra.models import AIStudioResultResponse
 from ...schemas.doc_preprocessor import INFER_ENDPOINT, InferRequest, InferResult
 from .._app import create_app, primary_operation
 from ._common import common
 from ._common import ocr as ocr_common
 
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+
 
-def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
+@function_requires_deps("fastapi")
+def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     app, ctx = create_app(
         pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
     )
@@ -37,7 +40,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
         INFER_ENDPOINT,
         "infer",
     )
-    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+    async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
 
         log_id = serving_utils.generate_log_id()
@@ -86,7 +89,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
                 )
             )
 
-        return ResultResponse[InferResult](
+        return AIStudioResultResponse[InferResult](
             logId=log_id,
             result=InferResult(
                 docPreprocessingResults=doc_pp_results,

paddlex/inference/serving/basic_serving/_pipeline_apps/doc_understanding.py

@@ -0,0 +1,153 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+import math
+import time
+from typing import Any, List
+
+from .....utils import logging
+from .....utils.deps import function_requires_deps, is_dep_available
+from ...infra import utils as serving_utils
+from ...infra.config import AppConfig
+from ...schemas.doc_understanding import (
+    INFER_ENDPOINT,
+    ImageContent,
+    ImageUrl,
+    InferRequest,
+    Message,
+    RoleType,
+    TextContent,
+)
+from .._app import create_app, primary_operation
+
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+if is_dep_available("openai"):
+    from openai.types.chat import ChatCompletion
+    from openai.types.chat.chat_completion import Choice as ChatCompletionChoice
+    from openai.types.chat.chat_completion_message import ChatCompletionMessage
+if is_dep_available("pillow"):
+    from PIL import Image
+
+
+@function_requires_deps("fastapi", "openai", "pillow")
+def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @primary_operation(
+        app,
+        "/chat/completions",
+        "inferA",
+    )
+    @primary_operation(
+        app,
+        INFER_ENDPOINT,
+        "infer",
+    )
+    async def _infer(request: InferRequest) -> "ChatCompletion":
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        def _resize_image_with_token_limit(image, max_token_num=2200, tile_size=28):
+            image = Image.fromarray(image)
+            w0, h0 = image.width, image.height
+            tokens = math.ceil(w0 / tile_size) * math.ceil(h0 / tile_size)
+            if tokens <= max_token_num:
+                return image
+
+            k = math.sqrt(
+                max_token_num / (math.ceil(w0 / tile_size) * math.ceil(h0 / tile_size))
+            )
+            k = min(1.0, k)
+            w_new = max(int(w0 * k), tile_size)
+            h_new = max(int(h0 * k), tile_size)
+            new_size = (w_new, h_new)
+            resized_image = image.resize(new_size)
+            tokens_new = math.ceil(w_new / tile_size) * math.ceil(h_new / tile_size)
+            logging.info(
+                f"Resizing image from {w0}x{h0} to {w_new}x{h_new}, "
+                f"which will reduce the image tokens from {tokens} to {tokens_new}."
+            )
+
+            return resized_image
+
+        def _process_messages(messages: List[Message]):
+            system_message = ""
+            user_message = ""
+            image_url = ""
+
+            for msg in messages:
+                if msg.role == RoleType.SYSTEM:
+                    if isinstance(msg.content, list):
+                        for content in msg.content:
+                            if isinstance(content, TextContent):
+                                system_message = content.text
+                                break
+                    else:
+                        system_message = msg.content
+
+                elif msg.role == RoleType.USER:
+                    if isinstance(msg.content, list):
+                        for content in msg.content:
+                            if isinstance(content, str):
+                                user_message = content
+                            else:
+                                if isinstance(content, TextContent):
+                                    user_message = content.text
+                                elif isinstance(content, ImageContent):
+                                    image_url = content.image_url
+                                    if isinstance(image_url, ImageUrl):
+                                        image_url = image_url.url
+                    else:
+                        user_message = msg.content
+            return system_message, user_message, image_url
+
+        system_message, user_message, image_url = _process_messages(request.messages)
+        if request.max_image_tokens is not None:
+            if image_url.startswith("data:image"):
+                _, image_url = image_url.split(",", 1)
+            img_bytes = await serving_utils.get_raw_bytes_async(
+                image_url, aiohttp_session
+            )
+            image = serving_utils.image_bytes_to_array(img_bytes)
+            image = _resize_image_with_token_limit(image, request.max_image_tokens)
+        else:
+            image = image_url
+
+        result = (
+            await pipeline.infer(
+                {"image": image, "query": user_message},
+            )
+        )[0]
+
+        return ChatCompletion(
+            id=serving_utils.generate_log_id(),
+            model=request.model,
+            choices=[
+                ChatCompletionChoice(
+                    index=0,
+                    finish_reason="stop",
+                    message=ChatCompletionMessage(
+                        role="assistant",
+                        content=result["result"],
+                    ),
+                )
+            ],
+            created=int(time.time()),
+            object="chat.completion",
+        )
+
+    return app

paddlex/inference/serving/basic_serving/_pipeline_apps/face_recognition.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,23 +16,26 @@ import asyncio
 from operator import attrgetter
 from typing import Any, Dict, List
 
-from fastapi import FastAPI
-
+from .....utils.deps import function_requires_deps, is_dep_available
 from ....pipelines.components import IndexData
 from ...infra import utils as serving_utils
 from ...infra.config import AppConfig
-from ...infra.models import ResultResponse
+from ...infra.models import AIStudioResultResponse
 from ...schemas import face_recognition as schema
 from .._app import create_app, primary_operation
 from ._common import image_recognition as ir_common
 
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+
 # XXX: Currently the implementations of the face recognition and PP-ShiTuV2
 # pipeline apps overlap significantly. We should aim to facilitate code reuse,
 # but is it acceptable to assume a strong similarity between these two
 # pipelines?
 
 
-def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
+@function_requires_deps("fastapi")
+def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     app, ctx = create_app(
         pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
     )
@@ -46,7 +49,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
     )
     async def _build_index(
         request: schema.BuildIndexRequest,
-    ) -> ResultResponse[schema.BuildIndexResult]:
+    ) -> AIStudioResultResponse[schema.BuildIndexResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
 
@@ -74,7 +77,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
         index_data_bytes = index_data.to_bytes()
         await serving_utils.call_async(index_storage.set, index_key, index_data_bytes)
 
-        return ResultResponse[schema.BuildIndexResult](
+        return AIStudioResultResponse[schema.BuildIndexResult](
             logId=serving_utils.generate_log_id(),
             result=schema.BuildIndexResult(
                 indexKey=index_key, imageCount=len(index_data.id_map)
@@ -88,7 +91,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
     )
     async def _add_images_to_index(
         request: schema.AddImagesToIndexRequest,
-    ) -> ResultResponse[schema.AddImagesToIndexResult]:
+    ) -> AIStudioResultResponse[schema.AddImagesToIndexResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
 
@@ -116,7 +119,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
             index_storage.set, request.indexKey, index_data_bytes
         )
 
-        return ResultResponse[schema.AddImagesToIndexResult](
+        return AIStudioResultResponse[schema.AddImagesToIndexResult](
             logId=serving_utils.generate_log_id(),
             result=schema.AddImagesToIndexResult(imageCount=len(index_data.id_map)),
         )
@@ -128,7 +131,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
     )
     async def _remove_images_from_index(
         request: schema.RemoveImagesFromIndexRequest,
-    ) -> ResultResponse[schema.RemoveImagesFromIndexResult]:
+    ) -> AIStudioResultResponse[schema.RemoveImagesFromIndexResult]:
         pipeline = ctx.pipeline
 
         index_storage = ctx.extra["index_storage"]
@@ -146,7 +149,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
             index_storage.set, request.indexKey, index_data_bytes
         )
 
-        return ResultResponse[schema.RemoveImagesFromIndexResult](
+        return AIStudioResultResponse[schema.RemoveImagesFromIndexResult](
             logId=serving_utils.generate_log_id(),
             result=schema.RemoveImagesFromIndexResult(
                 imageCount=len(index_data.id_map)
@@ -160,7 +163,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
     )
     async def _infer(
         request: schema.InferRequest,
-    ) -> ResultResponse[schema.InferResult]:
+    ) -> AIStudioResultResponse[schema.InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
 
@@ -215,7 +218,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
         else:
             output_image_base64 = None
 
-        return ResultResponse[schema.InferResult](
+        return AIStudioResultResponse[schema.InferResult](
             logId=serving_utils.generate_log_id(),
             result=schema.InferResult(faces=objs, image=output_image_base64),
         )

paddlex/inference/serving/basic_serving/_pipeline_apps/formula_recognition.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,18 +14,21 @@
 
 from typing import Any, Dict, List
 
-from fastapi import FastAPI
-
+from .....utils.deps import function_requires_deps, is_dep_available
 from ...infra import utils as serving_utils
 from ...infra.config import AppConfig
-from ...infra.models import ResultResponse
+from ...infra.models import AIStudioResultResponse
 from ...schemas.formula_recognition import INFER_ENDPOINT, InferRequest, InferResult
 from .._app import create_app, primary_operation
 from ._common import common
 from ._common import ocr as ocr_common
 
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+
 
-def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
+@function_requires_deps("fastapi")
+def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     app, ctx = create_app(
         pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
     )
@@ -37,7 +40,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
         INFER_ENDPOINT,
         "infer",
     )
-    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+    async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
 
         log_id = serving_utils.generate_log_id()
@@ -86,7 +89,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> FastAPI:
                 )
             )
 
-        return ResultResponse[InferResult](
+        return AIStudioResultResponse[InferResult](
             logId=log_id,
             result=InferResult(
                 formulaRecResults=formula_rec_results,