paddlex 3.0.0b2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

paddlex/inference/pipelines/ts_forecasting/pipeline.py

@@ -0,0 +1,72 @@
+# 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.
+
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+
+from ....utils.deps import pipeline_requires_extra
+from ...models.ts_forecasting.result import TSFcResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+
+@pipeline_requires_extra("ts")
+class TSFcPipeline(BasePipeline):
+    """TSFcPipeline Pipeline"""
+
+    entities = "ts_forecast"
+
+    def __init__(
+        self,
+        config: Dict,
+        device: str = None,
+        pp_option: PaddlePredictorOption = None,
+        use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
+    ) -> None:
+        """Initializes the Time Series Forecast pipeline.
+
+        Args:
+            config (Dict): Configuration dictionary containing various settings.
+            device (str, optional): Device to run the predictions on. Defaults to None.
+            pp_option (PaddlePredictorOption, optional): PaddlePredictor options. Defaults to None.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
+        """
+
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
+
+        ts_forecast_model_config = config["SubModules"]["TSForecast"]
+        self.ts_forecast_model = self.create_model(ts_forecast_model_config)
+
+    def predict(
+        self, input: Union[str, List[str], pd.DataFrame, List[pd.DataFrame]], **kwargs
+    ) -> TSFcResult:
+        """Predicts time series forecast results for the given input.
+
+        Args:
+            input (Union[str, list[str], pd.DataFrame, list[pd.DataFrame]]): The input image(s) or path(s) to the images.
+            **kwargs: Additional keyword arguments that can be passed to the function.
+
+        Returns:
+            TSFcResult: The predicted time series forecast results.
+        """
+        yield from self.ts_forecast_model(input)

paddlex/inference/pipelines/video_classification/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+from .pipeline import VideoClassificationPipeline

paddlex/inference/pipelines/video_classification/pipeline.py

@@ -0,0 +1,79 @@
+# 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.
+
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+
+from ....utils.deps import pipeline_requires_extra
+from ...models.video_classification.result import TopkVideoResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+
+@pipeline_requires_extra("video")
+class VideoClassificationPipeline(BasePipeline):
+    """Video Classification Pipeline"""
+
+    entities = "video_classification"
+
+    def __init__(
+        self,
+        config: Dict,
+        device: str = None,
+        pp_option: PaddlePredictorOption = None,
+        use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
+    ) -> None:
+        """
+        Initializes the class with given configurations and options.
+
+        Args:
+            config (Dict): Configuration dictionary containing model and other parameters.
+            device (str): The device to run the prediction on. Default is None.
+            pp_option (PaddlePredictorOption): Options for PaddlePaddle predictor. Default is None.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
+        """
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
+
+        video_classification_model_config = config["SubModules"]["VideoClassification"]
+        self.video_classification_model = self.create_model(
+            video_classification_model_config
+        )
+
+    def predict(
+        self,
+        input: Union[str, List[str], np.ndarray, List[np.ndarray]],
+        topk: Union[int, None] = 1,
+        **kwargs
+    ) -> TopkVideoResult:
+        """Predicts video classification results for the given input.
+
+        Args:
+            input (Union[str, list[str], np.ndarray, list[np.ndarray]]): The input image(s) or path(s) to the images.
+            topk: Union[int, None]: The number of top predictions to return. Defaults to 1.
+            **kwargs: Additional keyword arguments that can be passed to the function.
+
+        Returns:
+            TopkVideoResult: The predicted top k results.
+        """
+
+        yield from self.video_classification_model(input, topk=topk)

paddlex/inference/pipelines/video_detection/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+from .pipeline import VideoDetectionPipeline

paddlex/inference/pipelines/video_detection/pipeline.py

@@ -0,0 +1,86 @@
+# 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.
+
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+
+from ....utils.deps import pipeline_requires_extra
+from ...models.video_detection.result import DetVideoResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+
+@pipeline_requires_extra("video")
+class VideoDetectionPipeline(BasePipeline):
+    """Video detection Pipeline"""
+
+    entities = "video_detection"
+
+    def __init__(
+        self,
+        config: Dict,
+        device: str = None,
+        pp_option: PaddlePredictorOption = None,
+        use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
+    ) -> None:
+        """
+        Initializes the class with given configurations and options.
+
+        Args:
+            config (Dict): Configuration dictionary containing model and other parameters.
+            device (str): The device to run the prediction on. Default is None.
+            pp_option (PaddlePredictorOption): Options for PaddlePaddle predictor. Default is None.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
+        """
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
+
+        video_detection_model_config = config["SubModules"]["VideoDetection"]
+        model_kwargs = {}
+        if "nms_thresh" in video_detection_model_config:
+            model_kwargs["nms_thresh"] = video_detection_model_config["nms_thresh"]
+        if "score_thresh" in video_detection_model_config:
+            model_kwargs["score_thresh"] = video_detection_model_config["score_thresh"]
+        self.video_detection_model = self.create_model(
+            video_detection_model_config, **model_kwargs
+        )
+
+    def predict(
+        self,
+        input: Union[str, List[str], np.ndarray, List[np.ndarray]],
+        nms_thresh: float = 0.5,
+        score_thresh: float = 0.4,
+        **kwargs
+    ) -> DetVideoResult:
+        """Predicts video detection results for the given input.
+
+        Args:
+            input (Union[str, list[str], np.ndarray, list[np.ndarray]]): The input image(s) or path(s) to the images.
+            **kwargs: Additional keyword arguments that can be passed to the function.
+
+        Returns:
+            DetVideoResult: The predicted video detection results.
+        """
+
+        yield from self.video_detection_model(
+            input, nms_thresh=nms_thresh, score_thresh=score_thresh
+        )

paddlex/inference/serving/__init__.py

@@ -0,0 +1,17 @@
+# 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.
+
+from ...utils.deps import require_serving_plugin
+
+require_serving_plugin()

paddlex/inference/serving/basic_serving/__init__.py

@@ -0,0 +1,18 @@
+# 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.
+
+from ._pipeline_apps import create_pipeline_app
+from ._server import run_server
+
+__all__ = ["create_pipeline_app", "run_server"]

paddlex/inference/serving/basic_serving/_app.py

@@ -0,0 +1,221 @@
+# 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 asyncio
+import contextlib
+import json
+from typing import (
+    Any,
+    AsyncGenerator,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    TypedDict,
+    TypeVar,
+)
+
+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 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")
+
+
+class _Error(TypedDict):
+    error: str
+
+
+def _is_error(obj: object) -> TypeGuard[_Error]:
+    return (
+        isinstance(obj, dict)
+        and obj.keys() == {"error"}
+        and isinstance(obj["error"], str)
+    )
+
+
+# XXX: Since typing info (e.g., the pipeline class) cannot be easily obtained
+# without abstraction leaks, generic classes do not offer additional benefits
+# 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__()
+        self._pipeline = pipeline
+        self._lock = asyncio.Lock()
+
+    @property
+    def pipeline(self) -> PipelineT:
+        return self._pipeline
+
+    async def infer(self, *args: Any, **kwargs: Any) -> List[Any]:
+        def _infer() -> List[Any]:
+            output: list = []
+            with contextlib.closing(self._pipeline(*args, **kwargs)) as it:
+                for item in it:
+                    if _is_error(item):
+                        raise fastapi.HTTPException(
+                            status_code=500, detail=item["error"]
+                        )
+                    output.append(item)
+
+            return output
+
+        return await self.call(_infer)
+
+    async def call(self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+        async with self._lock:
+            return await call_async(func, *args, **kwargs)
+
+
+@class_requires_deps("aiohttp")
+class AppContext(Generic[PipelineT]):
+    def __init__(self, *, config: AppConfig) -> None:
+        super().__init__()
+        self._config = config
+        self.extra: Dict[str, Any] = {}
+        self._pipeline: Optional[PipelineWrapper[PipelineT]] = None
+        self._aiohttp_session: Optional[aiohttp.ClientSession] = None
+
+    @property
+    def config(self) -> AppConfig:
+        return self._config
+
+    @property
+    def pipeline(self) -> PipelineWrapper[PipelineT]:
+        if not self._pipeline:
+            raise AttributeError("`pipeline` has not been set.")
+        return self._pipeline
+
+    @pipeline.setter
+    def pipeline(self, val: PipelineWrapper[PipelineT]) -> None:
+        self._pipeline = val
+
+    @property
+    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:
+        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]]:
+    @contextlib.asynccontextmanager
+    async def _app_lifespan(app: "fastapi.FastAPI") -> AsyncGenerator[None, None]:
+        ctx.pipeline = PipelineWrapper[PipelineT](pipeline)
+        if app_aiohttp_session:
+            async with aiohttp.ClientSession(
+                cookie_jar=aiohttp.DummyCookieJar()
+            ) as aiohttp_session:
+                ctx.aiohttp_session = aiohttp_session
+                yield
+        else:
+            yield
+
+    # Should we control API versions?
+    app = fastapi.FastAPI(lifespan=_app_lifespan)
+    ctx = AppContext[PipelineT](config=app_config)
+    app.state.context = ctx
+
+    @app.get("/health", operation_id="checkHealth")
+    async def _check_health() -> AIStudioNoResultResponse:
+        return AIStudioNoResultResponse(
+            logId=generate_log_id(), errorCode=0, errorMsg="Healthy"
+        )
+
+    @app.exception_handler(RequestValidationError)
+    async def _validation_exception_handler(
+        request: fastapi.Request, exc: RequestValidationError
+    ) -> JSONResponse:
+        json_compatible_data = jsonable_encoder(
+            AIStudioNoResultResponse(
+                logId=generate_log_id(),
+                errorCode=422,
+                errorMsg=json.dumps(exc.errors()),
+            )
+        )
+        return JSONResponse(content=json_compatible_data, status_code=422)
+
+    @app.exception_handler(HTTPException)
+    async def _http_exception_handler(
+        request: fastapi.Request, exc: HTTPException
+    ) -> JSONResponse:
+        json_compatible_data = jsonable_encoder(
+            AIStudioNoResultResponse(
+                logId=generate_log_id(), errorCode=exc.status_code, errorMsg=exc.detail
+            )
+        )
+        return JSONResponse(content=json_compatible_data, status_code=exc.status_code)
+
+    @app.exception_handler(Exception)
+    async def _unexpected_exception_handler(
+        request: fastapi.Request, exc: Exception
+    ) -> JSONResponse:
+        # XXX: The default server will duplicate the error message. Is it
+        # necessary to log the exception info here?
+        logging.exception("Unhandled exception")
+        json_compatible_data = jsonable_encoder(
+            AIStudioNoResultResponse(
+                logId=generate_log_id(),
+                errorCode=500,
+                errorMsg="Internal server error",
+            )
+        )
+        return JSONResponse(content=json_compatible_data, status_code=500)
+
+    return app, ctx
+
+
+# TODO: Precise type hints
+@function_requires_deps("fastapi")
+def primary_operation(
+    app: "fastapi.FastAPI", path: str, operation_id: str, **kwargs: Any
+) -> Callable:
+    return app.post(
+        path,
+        operation_id=operation_id,
+        responses={
+            422: {"model": AIStudioNoResultResponse},
+            500: {"model": AIStudioNoResultResponse},
+        },
+        response_model_exclude_none=True,
+        **kwargs,
+    )

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

@@ -0,0 +1,44 @@
+# 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 importlib
+from typing import Any, Dict
+
+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:
+        raise ValueError("Empty pipeline name")
+    mod_name = pipeline_name.lower().replace("-", "_")
+    if mod_name[0].isdigit():
+        return "m_" + mod_name
+    return mod_name
+
+
+# XXX: A dynamic approach is used here for writing fewer lines of code, at the
+# cost of sacrificing some benefits of type hints.
+@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__)
+    app_config = create_app_config(pipeline_config)
+    app_creator = getattr(mod, "create_pipeline_app")
+    app = app_creator(pipeline, app_config)
+    return app

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

@@ -0,0 +1,13 @@
+# 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.

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

@@ -0,0 +1,100 @@
+# 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 os
+from typing import Dict, Optional, Tuple, Union
+
+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", "page_index"]
+
+    def _process_obj(obj):
+        if isinstance(obj, dict):
+            return {
+                k: _process_obj(v) for k, v in obj.items() if k not in KEYS_TO_REMOVE
+            }
+        elif isinstance(obj, list):
+            return [_process_obj(item) for item in obj]
+        else:
+            return obj
+
+    return _process_obj(result)
+
+
+@function_requires_deps("opencv-contrib-python")
+def postprocess_image(
+    image: np.ndarray,
+    log_id: str,
+    filename: str,
+    *,
+    file_storage: Optional[Storage] = None,
+    return_url: bool = False,
+    max_img_size: Optional[Tuple[int, int]] = None,
+) -> str:
+    if return_url:
+        if not file_storage:
+            raise ValueError(
+                "`file_storage` must not be None when URLs need to be returned."
+            )
+        if not isinstance(file_storage, SupportsGetURL):
+            raise TypeError("The provided storage does not support getting URLs.")
+
+    key = f"{log_id}/{filename}"
+    ext = os.path.splitext(filename)[1]
+    h, w = image.shape[0:2]
+    if max_img_size is not None:
+        if w > max_img_size[1] or h > max_img_size[0]:
+            if w / h > max_img_size[0] / max_img_size[1]:
+                factor = max_img_size[0] / w
+            else:
+                factor = max_img_size[1] / h
+            image = cv2.resize(image, (int(factor * w), int(factor * h)))
+    img_bytes = serving_utils.image_array_to_bytes(image, ext=ext)
+    if file_storage is not None:
+        file_storage.set(key, img_bytes)
+        if return_url:
+            assert isinstance(file_storage, SupportsGetURL)
+            return file_storage.get_url(key)
+    return serving_utils.base64_encode(img_bytes)
+
+
+def postprocess_images(
+    images: Dict[str, Union[Image, np.ndarray]],
+    log_id: str,
+    filename_template: str = "{key}.jpg",
+    file_storage: Optional[Storage] = None,
+    return_urls: bool = False,
+    max_img_size: Optional[Tuple[int, int]] = None,
+) -> Dict[str, str]:
+    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,
+            log_id=log_id,
+            filename=filename_template.format(key=key),
+            file_storage=file_storage,
+            return_url=return_urls,
+            max_img_size=max_img_size,
+        )
+    return output_images