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

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

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

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

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

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

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