paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/inference/pipelines/serving/_pipeline_apps/layout_parsing.py

@@ -0,0 +1,205 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 Final, List, Literal, Optional, Tuple
+
+import numpy as np
+from fastapi import FastAPI, HTTPException
+from numpy.typing import ArrayLike
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated, TypeAlias
+
+from .....utils import logging
+from ...layout_parsing import LayoutParsingPipeline
+from ..storage import SupportsGetURL, Storage, create_storage
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+_DEFAULT_MAX_IMG_SIZE: Final[Tuple[int, int]] = (2000, 2000)
+_DEFAULT_MAX_NUM_IMGS: Final[int] = 10
+
+
+FileType: TypeAlias = Literal[0, 1]
+
+
+class InferenceParams(BaseModel):
+    maxLongSide: Optional[Annotated[int, Field(gt=0)]] = None
+
+
+class InferRequest(BaseModel):
+    file: str
+    fileType: Optional[FileType] = None
+    useImgOrientationCls: bool = True
+    useImgUnwrapping: bool = True
+    useSealTextDet: bool = True
+    inferenceParams: Optional[InferenceParams] = None
+
+
+BoundingBox: TypeAlias = Annotated[List[float], Field(min_length=4, max_length=4)]
+
+
+class LayoutElement(BaseModel):
+    bbox: BoundingBox
+    label: str
+    text: str
+    layoutType: Literal["single", "double"]
+    image: Optional[str] = None
+
+
+class LayoutParsingResult(BaseModel):
+    layoutElements: List[LayoutElement]
+
+
+class InferResult(BaseModel):
+    layoutParsingResults: List[LayoutParsingResult]
+
+
+def _postprocess_image(
+    img: ArrayLike,
+    request_id: str,
+    filename: str,
+    file_storage: Optional[Storage],
+) -> str:
+    key = f"{request_id}/{filename}"
+    ext = os.path.splitext(filename)[1]
+    img = np.asarray(img)
+    img_bytes = serving_utils.image_array_to_bytes(img, ext=ext)
+    if file_storage is not None:
+        file_storage.set(key, img_bytes)
+        if isinstance(file_storage, SupportsGetURL):
+            return file_storage.get_url(key)
+    return serving_utils.base64_encode(img_bytes)
+
+
+def create_pipeline_app(
+    pipeline: LayoutParsingPipeline, app_config: AppConfig
+) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    if ctx.config.extra and "file_storage" in ctx.config.extra:
+        ctx.extra["file_storage"] = create_storage(ctx.config.extra["file_storage"])
+    else:
+        ctx.extra["file_storage"] = None
+    ctx.extra.setdefault("max_img_size", _DEFAULT_MAX_IMG_SIZE)
+    ctx.extra.setdefault("max_num_imgs", _DEFAULT_MAX_NUM_IMGS)
+
+    @app.post(
+        "/layout-parsing",
+        operation_id="infer",
+        responses={422: {"model": Response}},
+        response_model_exclude_none=True,
+    )
+    async def _infer(
+        request: InferRequest,
+    ) -> ResultResponse[InferResult]:
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        request_id = serving_utils.generate_request_id()
+
+        if request.fileType is None:
+            if serving_utils.is_url(request.file):
+                try:
+                    file_type = serving_utils.infer_file_type(request.file)
+                except Exception as e:
+                    logging.exception(e)
+                    raise HTTPException(
+                        status_code=422,
+                        detail="The file type cannot be inferred from the URL. Please specify the file type explicitly.",
+                    )
+            else:
+                raise HTTPException(status_code=422, detail="Unknown file type")
+        else:
+            file_type = "PDF" if request.fileType == 0 else "IMAGE"
+
+        if request.inferenceParams:
+            max_long_side = request.inferenceParams.maxLongSide
+            if max_long_side:
+                raise HTTPException(
+                    status_code=422,
+                    detail="`max_long_side` is currently not supported.",
+                )
+
+        try:
+            file_bytes = await serving_utils.get_raw_bytes(
+                request.file, aiohttp_session
+            )
+            images = await serving_utils.call_async(
+                serving_utils.file_to_images,
+                file_bytes,
+                file_type,
+                max_img_size=ctx.extra["max_img_size"],
+                max_num_imgs=ctx.extra["max_num_imgs"],
+            )
+
+            result = await pipeline.infer(
+                images,
+                use_doc_image_ori_cls_model=request.useImgOrientationCls,
+                use_doc_image_unwarp_model=request.useImgUnwrapping,
+                use_seal_text_det_model=request.useSealTextDet,
+            )
+
+            layout_parsing_results: List[LayoutParsingResult] = []
+            for i, item in enumerate(result):
+                layout_elements: List[LayoutElement] = []
+                for j, subitem in enumerate(
+                    item["layout_parsing_result"]["parsing_result"]
+                ):
+                    dyn_keys = subitem.keys() - {"input_path", "layout_bbox", "layout"}
+                    if len(dyn_keys) != 1:
+                        raise RuntimeError(f"Unexpected result: {subitem}")
+                    label = next(iter(dyn_keys))
+                    if label in ("image", "figure", "img", "fig"):
+                        image_ = await serving_utils.call_async(
+                            _postprocess_image,
+                            subitem[label]["img"],
+                            request_id=request_id,
+                            filename=f"image_{i}_{j}.jpg",
+                            file_storage=ctx.extra["file_storage"],
+                        )
+                        text = subitem[label]["image_text"]
+                    else:
+                        image_ = None
+                        text = subitem[label]
+                    layout_elements.append(
+                        LayoutElement(
+                            bbox=subitem["layout_bbox"],
+                            label=label,
+                            text=text,
+                            layoutType=subitem["layout"],
+                            image=image_,
+                        )
+                    )
+                layout_parsing_results.append(
+                    LayoutParsingResult(layoutElements=layout_elements)
+                )
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(
+                    layoutParsingResults=layout_parsing_results,
+                ),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app

paddlex/inference/pipelines/serving/_pipeline_apps/multi_label_image_classification.py

@@ -0,0 +1,90 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 List
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+from .....utils import logging
+from ...single_model_pipeline import ImageClassification
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+
+class InferRequest(BaseModel):
+    image: str
+
+
+class Category(BaseModel):
+    id: int
+    name: str
+    score: float
+
+
+class InferResult(BaseModel):
+    categories: List[Category]
+    image: str
+
+
+def create_pipeline_app(
+    pipeline: ImageClassification, app_config: AppConfig
+) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @app.post(
+        "/multilabel-image-classification",
+        operation_id="infer",
+        responses={422: {"model": Response}},
+    )
+    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        try:
+            file_bytes = await serving_utils.get_raw_bytes(
+                request.image, aiohttp_session
+            )
+            image = serving_utils.image_bytes_to_array(file_bytes)
+
+            result = (await pipeline.infer(image))[0]
+
+            if "label_names" in result:
+                cat_names = result["label_names"]
+            else:
+                cat_names = [str(id_) for id_ in result["class_ids"]]
+            categories: List[Category] = []
+            for id_, name, score in zip(
+                result["class_ids"], cat_names, result["scores"]
+            ):
+                categories.append(Category(id=id_, name=name, score=score))
+            output_image_base64 = serving_utils.base64_encode(
+                serving_utils.image_to_bytes(result.img)
+            )
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(categories=categories, image=output_image_base64),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app

paddlex/inference/pipelines/serving/_pipeline_apps/object_detection.py

@@ -0,0 +1,90 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 List
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated, TypeAlias
+
+from .....utils import logging
+from ...single_model_pipeline import ObjectDetection
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+
+class InferRequest(BaseModel):
+    image: str
+
+
+BoundingBox: TypeAlias = Annotated[List[float], Field(min_length=4, max_length=4)]
+
+
+class DetectedObject(BaseModel):
+    bbox: BoundingBox
+    categoryId: int
+    score: float
+
+
+class InferResult(BaseModel):
+    detectedObjects: List[DetectedObject]
+    image: str
+
+
+def create_pipeline_app(pipeline: ObjectDetection, app_config: AppConfig) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @app.post(
+        "/object-detection", operation_id="infer", responses={422: {"model": Response}}
+    )
+    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        try:
+            file_bytes = await serving_utils.get_raw_bytes(
+                request.image, aiohttp_session
+            )
+            image = serving_utils.image_bytes_to_array(file_bytes)
+
+            result = (await pipeline.infer(image))[0]
+
+            objects: List[DetectedObject] = []
+            for obj in result["boxes"]:
+                objects.append(
+                    DetectedObject(
+                        bbox=obj["coordinate"],
+                        categoryId=obj["cls_id"],
+                        score=obj["score"],
+                    )
+                )
+            output_image_base64 = serving_utils.base64_encode(
+                serving_utils.image_to_bytes(result.img)
+            )
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(detectedObjects=objects, image=output_image_base64),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app

paddlex/inference/pipelines/serving/_pipeline_apps/ocr.py

@@ -0,0 +1,98 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 List, Optional
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated, TypeAlias
+
+from .....utils import logging
+from ...ocr import OCRPipeline
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+
+class InferenceParams(BaseModel):
+    maxLongSide: Optional[Annotated[int, Field(gt=0)]] = None
+
+
+class InferRequest(BaseModel):
+    image: str
+    inferenceParams: Optional[InferenceParams] = None
+
+
+Point: TypeAlias = Annotated[List[int], Field(min_length=2, max_length=2)]
+Polygon: TypeAlias = Annotated[List[Point], Field(min_length=3)]
+
+
+class Text(BaseModel):
+    poly: Polygon
+    text: str
+    score: float
+
+
+class InferResult(BaseModel):
+    texts: List[Text]
+    image: str
+
+
+def create_pipeline_app(pipeline: OCRPipeline, app_config: AppConfig) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @app.post("/ocr", operation_id="infer", responses={422: {"model": Response}})
+    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        if request.inferenceParams:
+            max_long_side = request.inferenceParams.maxLongSide
+            if max_long_side:
+                raise HTTPException(
+                    status_code=422,
+                    detail="`max_long_side` is currently not supported.",
+                )
+
+        try:
+            file_bytes = await serving_utils.get_raw_bytes(
+                request.image, aiohttp_session
+            )
+            image = serving_utils.image_bytes_to_array(file_bytes)
+
+            result = (await pipeline.infer(image))[0]
+
+            texts: List[Text] = []
+            for poly, text, score in zip(
+                result["dt_polys"], result["rec_text"], result["rec_score"]
+            ):
+                texts.append(Text(poly=poly, text=text, score=score))
+            output_image_base64 = serving_utils.base64_encode(
+                serving_utils.image_to_bytes(result.img)
+            )
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(texts=texts, image=output_image_base64),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app

paddlex/inference/pipelines/serving/_pipeline_apps/pedestrian_attribute_recognition.py

@@ -0,0 +1,102 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 List
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated, TypeAlias
+
+from .....utils import logging
+from ...attribute_recognition import PedestrianAttributeRecPipeline
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+
+class InferRequest(BaseModel):
+    image: str
+
+
+BoundingBox: TypeAlias = Annotated[List[float], Field(min_length=4, max_length=4)]
+
+
+class Attribute(BaseModel):
+    label: str
+    score: float
+
+
+class Pedestrian(BaseModel):
+    bbox: BoundingBox
+    attributes: List[Attribute]
+    score: float
+
+
+class InferResult(BaseModel):
+    pedestrians: List[Pedestrian]
+    image: str
+
+
+def create_pipeline_app(
+    pipeline: PedestrianAttributeRecPipeline, app_config: AppConfig
+) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @app.post(
+        "/pedestrian-attribute-recognition",
+        operation_id="infer",
+        responses={422: {"model": Response}},
+    )
+    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        try:
+            file_bytes = await serving_utils.get_raw_bytes(
+                request.image, aiohttp_session
+            )
+            image = serving_utils.image_bytes_to_array(file_bytes)
+
+            result = (await pipeline.infer(image))[0]
+
+            pedestrians: List[Pedestrian] = []
+            for obj in result["boxes"]:
+                pedestrians.append(
+                    Pedestrian(
+                        bbox=obj["coordinate"],
+                        attributes=[
+                            Attribute(label=l, score=s)
+                            for l, s in zip(obj["labels"], obj["cls_scores"])
+                        ],
+                        score=obj["det_score"],
+                    )
+                )
+            output_image_base64 = serving_utils.base64_encode(
+                serving_utils.image_to_bytes(result.img)
+            )
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(pedestrians=pedestrians, image=output_image_base64),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app