paddlex 2.1.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

paddlex/inference/serving/basic_serving/_server.py

@@ -0,0 +1,40 @@
+# 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 logging
+
+from ....utils.deps import function_requires_deps, is_dep_available
+
+if is_dep_available("uvicorn"):
+    import uvicorn
+if is_dep_available("fastapi"):
+    from fastapi import FastAPI
+
+
+@function_requires_deps("fastapi", "uvicorn")
+def run_server(app: "FastAPI", *, host: str, port: int) -> None:
+    # HACK: Fix duplicate logs
+    uvicorn_version = tuple(int(x) for x in uvicorn.__version__.split("."))
+    if uvicorn_version < (0, 19, 0):
+        logging.getLogger("uvicorn").propagate = False
+
+    # HACK
+    # https://github.com/encode/starlette/issues/864
+    class _EndpointFilter(logging.Filter):
+        def filter(self, record: logging.LogRecord) -> bool:
+            return record.getMessage().find("/health") == -1
+
+    logging.getLogger("uvicorn.access").addFilter(_EndpointFilter())
+
+    uvicorn.run(app, host=host, port=port, log_level="info")

paddlex/inference/serving/infra/__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/infra/config.py

@@ -0,0 +1,36 @@
+# 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, Final, Mapping, Optional
+
+from pydantic import BaseModel
+
+__all__ = [
+    "SERVING_CONFIG_KEY",
+    "AppConfig",
+    "create_app_config",
+]
+
+SERVING_CONFIG_KEY: Final[str] = "Serving"
+
+
+class AppConfig(BaseModel):
+    visualize: bool = True
+    extra: Optional[Dict[str, Any]] = None
+
+
+def create_app_config(pipeline_config: Mapping[str, Any], **kwargs: Any) -> AppConfig:
+    app_config = pipeline_config.get(SERVING_CONFIG_KEY, {})
+    app_config.update(kwargs)
+    return AppConfig.model_validate(app_config)

paddlex/inference/serving/infra/models.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 Dict, Generic, List, Tuple, TypeVar, Union
+
+from pydantic import BaseModel, Discriminator
+from typing_extensions import Annotated, Literal, TypeAlias
+
+from ....utils.deps import is_dep_available
+
+if is_dep_available("openai"):
+    from openai.types.chat import ChatCompletion
+
+__all__ = [
+    "AIStudioNoResultResponse",
+    "ResultT",
+    "AIStudioResultResponse",
+    "Response",
+    "ImageInfo",
+    "PDFPageInfo",
+    "PDFInfo",
+    "DataInfo",
+    "PrimaryOperations",
+]
+
+
+class AIStudioNoResultResponse(BaseModel):
+    logId: str
+    errorCode: int
+    errorMsg: str
+
+
+ResultT = TypeVar("ResultT", bound=BaseModel)
+
+
+class AIStudioResultResponse(BaseModel, Generic[ResultT]):
+    logId: str
+    result: ResultT
+    errorCode: Literal[0] = 0
+    errorMsg: Literal["Success"] = "Success"
+
+
+Response: TypeAlias = Union[
+    AIStudioResultResponse, AIStudioNoResultResponse, "ChatCompletion"
+]
+
+
+class ImageInfo(BaseModel):
+    width: int
+    height: int
+    type: Literal["image"] = "image"
+
+
+class PDFPageInfo(BaseModel):
+    width: int
+    height: int
+
+
+class PDFInfo(BaseModel):
+    numPages: int
+    pages: List[PDFPageInfo]
+    type: Literal["pdf"] = "pdf"
+
+
+DataInfo: TypeAlias = Annotated[Union[ImageInfo, PDFInfo], Discriminator("type")]
+
+# Should we use generics?
+PrimaryOperations: TypeAlias = Dict[str, Tuple[str, BaseModel, BaseModel]]

paddlex/inference/serving/infra/storage.py

@@ -0,0 +1,180 @@
+# 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 abc
+from os import PathLike
+from pathlib import Path
+from typing import Any, Dict, Optional, Protocol, Union, runtime_checkable
+
+from pydantic import BaseModel, Discriminator, SecretStr, TypeAdapter
+from typing_extensions import Annotated, Literal, assert_never
+
+from ....utils.deps import class_requires_deps
+
+__all__ = [
+    "InMemoryStorageConfig",
+    "FileSystemStorageConfig",
+    "BOSConfig",
+    "FileStorageConfig",
+    "SupportsGetURL",
+    "Storage",
+    "InMemoryStorage",
+    "FileSystemStorage",
+    "BOS",
+    "create_storage",
+]
+
+
+class InMemoryStorageConfig(BaseModel):
+    type: Literal["memory"] = "memory"
+
+
+class FileSystemStorageConfig(BaseModel):
+    directory: Union[str, PathLike]
+
+    type: Literal["file_system"] = "file_system"
+
+
+class BOSConfig(BaseModel):
+    endpoint: str
+    ak: SecretStr
+    sk: SecretStr
+    bucket_name: str
+    key_prefix: Optional[str] = None
+    connection_timeout_in_mills: Optional[int] = None
+
+    type: Literal["bos"] = "bos"
+
+
+FileStorageConfig = Annotated[
+    Union[InMemoryStorageConfig, FileSystemStorageConfig, BOSConfig],
+    Discriminator("type"),
+]
+
+
+@runtime_checkable
+class SupportsGetURL(Protocol):
+    def get_url(self, key: str) -> str: ...
+
+
+class Storage(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def get(self, key: str) -> bytes:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def set(self, key: str, value: bytes) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def delete(self, key: str) -> None:
+        raise NotImplementedError
+
+
+class InMemoryStorage(Storage):
+    def __init__(self, config: InMemoryStorageConfig) -> None:
+        super().__init__()
+        self._data: Dict[str, bytes] = {}
+
+    def get(self, key: str) -> bytes:
+        return self._data[key]
+
+    def set(self, key: str, value: bytes) -> None:
+        self._data[key] = value
+
+    def delete(self, key: str) -> None:
+        del self._data[key]
+
+
+class FileSystemStorage(Storage):
+    def __init__(self, config: FileSystemStorageConfig) -> None:
+        super().__init__()
+        self._directory = Path(config.directory)
+        self._directory.mkdir(exist_ok=True)
+
+    def get(self, key: str) -> bytes:
+        with open(self._get_file_path(key), "rb") as f:
+            contents = f.read()
+        return contents
+
+    def set(self, key: str, value: bytes) -> None:
+        path = self._get_file_path(key)
+        path.parent.mkdir(exist_ok=True)
+        with open(path, "wb") as f:
+            f.write(value)
+
+    def delete(self, key: str) -> None:
+        file_path = self._get_file_path(key)
+        file_path.unlink(missing_ok=True)
+
+    def _get_file_path(self, key: str) -> Path:
+        return self._directory / key
+
+
+@class_requires_deps("bce-python-sdk")
+class BOS(Storage):
+    def __init__(self, config: BOSConfig) -> None:
+        from baidubce.auth.bce_credentials import BceCredentials
+        from baidubce.bce_client_configuration import BceClientConfiguration
+        from baidubce.services.bos.bos_client import BosClient
+
+        super().__init__()
+
+        bos_cfg = BceClientConfiguration(
+            credentials=BceCredentials(
+                config.ak.get_secret_value(), config.sk.get_secret_value()
+            ),
+            endpoint=config.endpoint,
+            connection_timeout_in_mills=config.connection_timeout_in_mills,
+        )
+        self._client = BosClient(bos_cfg)
+        self._bucket_name = config.bucket_name
+        self._key_prefix = config.key_prefix
+
+    def get(self, key: str) -> bytes:
+        key = self._get_full_key(key)
+        return self._client.get_object_as_string(bucket_name=self._bucket_name, key=key)
+
+    def set(self, key: str, value: bytes) -> None:
+        key = self._get_full_key(key)
+        self._client.put_object_from_string(
+            bucket=self._bucket_name, key=key, data=value
+        )
+
+    def delete(self, key: str) -> None:
+        key = self._get_full_key(key)
+        self._client.delete_object(bucket_name=self._bucket_name, key=key)
+
+    def get_url(self, key: str) -> str:
+        key = self._get_full_key(key)
+        return self._client.generate_pre_signed_url(
+            self._bucket_name, key, expiration_in_seconds=-1
+        ).decode("ascii")
+
+    def _get_full_key(self, key: str) -> str:
+        if self._key_prefix:
+            return f"{self._key_prefix}/{key}"
+        return key
+
+
+def create_storage(dic: Dict[str, Any], /) -> Storage:
+    config = TypeAdapter(FileStorageConfig).validate_python(dic)
+    if config.type == "memory":
+        return InMemoryStorage(config)
+    elif config.type == "file_system":
+        return FileSystemStorage(config)
+    elif config.type == "bos":
+        return BOS(config)
+    else:
+        assert_never(config)

paddlex/inference/serving/infra/utils.py

@@ -0,0 +1,285 @@
+# 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 base64
+import io
+import mimetypes
+import re
+import tempfile
+import uuid
+from functools import partial
+from typing import Awaitable, Callable, List, Optional, Tuple, TypeVar, Union, overload
+from urllib.parse import parse_qs, urlparse
+
+import numpy as np
+import pandas as pd
+import requests
+from PIL import Image
+from typing_extensions import Literal, ParamSpec, TypeAlias, assert_never
+
+from ....utils.deps import function_requires_deps, is_dep_available
+from .models import ImageInfo, PDFInfo, PDFPageInfo
+
+if is_dep_available("aiohttp"):
+    import aiohttp
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+if is_dep_available("filetype"):
+    import filetype
+if is_dep_available("pypdfium2"):
+    import pypdfium2 as pdfium
+if is_dep_available("yarl"):
+    import yarl
+
+__all__ = [
+    "FileType",
+    "generate_log_id",
+    "is_url",
+    "infer_file_type",
+    "infer_file_ext",
+    "image_bytes_to_array",
+    "image_bytes_to_image",
+    "image_to_bytes",
+    "image_array_to_bytes",
+    "csv_bytes_to_data_frame",
+    "data_frame_to_bytes",
+    "base64_encode",
+    "read_pdf",
+    "file_to_images",
+    "get_image_info",
+    "write_to_temp_file",
+    "get_raw_bytes",
+    "get_raw_bytes_async",
+    "call_async",
+]
+
+FileType: TypeAlias = Literal["IMAGE", "PDF", "VIDEO", "AUDIO"]
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def generate_log_id() -> str:
+    return str(uuid.uuid4())
+
+
+# TODO:
+# 1. Use Pydantic to validate the URL and Base64-encoded string types for both
+#    input and output data instead of handling this manually.
+# 2. Define a `File` type for global use; this will be part of the contract.
+# 3. Consider using two separate fields instead of a union of URL and Base64,
+#    even though they are both strings. Backward compatibility should be
+#    maintained.
+def is_url(s: str) -> bool:
+    if not (s.startswith("http://") or s.startswith("https://")):
+        # Quick rejection
+        return False
+    result = urlparse(s)
+    return all([result.scheme, result.netloc]) and result.scheme in ("http", "https")
+
+
+def infer_file_type(url: str) -> Optional[FileType]:
+    url_parts = urlparse(url)
+    filename = url_parts.path.split("/")[-1]
+
+    file_type = mimetypes.guess_type(filename)[0]
+
+    if file_type is None:
+        # HACK: The support for BOS URLs with query params is implementation-based,
+        # not interface-based.
+        is_bos_url = re.fullmatch(r"\w+\.bcebos\.com", url_parts.netloc) is not None
+        if is_bos_url and url_parts.query:
+            params = parse_qs(url_parts.query)
+            if (
+                "responseContentDisposition" in params
+                and len(params["responseContentDisposition"]) == 1
+            ):
+                match_ = re.match(
+                    r"attachment;filename=(.*)", params["responseContentDisposition"][0]
+                )
+                if match_:
+                    file_type = mimetypes.guess_type(match_.group(1))[0]
+        if file_type is None:
+            return None
+
+    if file_type.startswith("image/"):
+        return "IMAGE"
+    elif file_type == "application/pdf":
+        return "PDF"
+    elif file_type.startswith("video/"):
+        return "VIDEO"
+    elif file_type.startswith("audio/"):
+        return "AUDIO"
+    else:
+        return None
+
+
+@function_requires_deps("filetype")
+def infer_file_ext(file: str) -> Optional[str]:
+    if is_url(file):
+        url_parts = urlparse(file)
+        filename = url_parts.path.split("/")[-1]
+        mime_type = mimetypes.guess_type(filename)[0]
+        if mime_type is None:
+            return None
+        return mimetypes.guess_extension(mime_type)
+    else:
+        bytes_ = base64.b64decode(file)
+        return "." + filetype.guess_extension(bytes_)
+
+
+@function_requires_deps("opencv-contrib-python")
+def image_bytes_to_array(data: bytes) -> np.ndarray:
+    return cv2.imdecode(np.frombuffer(data, np.uint8), cv2.IMREAD_COLOR)
+
+
+def image_bytes_to_image(data: bytes) -> Image.Image:
+    return Image.open(io.BytesIO(data))
+
+
+def image_to_bytes(image: Image.Image, format: str = "JPEG") -> bytes:
+    with io.BytesIO() as f:
+        image.save(f, format=format)
+        img_bytes = f.getvalue()
+    return img_bytes
+
+
+@function_requires_deps("opencv-contrib-python")
+def image_array_to_bytes(image: np.ndarray, ext: str = ".jpg") -> bytes:
+    image = cv2.imencode(ext, image)[1]
+    return image.tobytes()
+
+
+def csv_bytes_to_data_frame(data: bytes) -> pd.DataFrame:
+    with io.StringIO(data.decode("utf-8")) as f:
+        df = pd.read_csv(f)
+    return df
+
+
+def data_frame_to_bytes(df: pd.DataFrame) -> bytes:
+    return df.to_csv().encode("utf-8")
+
+
+def base64_encode(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii")
+
+
+@function_requires_deps("pypdfium2", "opencv-contrib-python")
+def read_pdf(
+    bytes_: bytes, max_num_imgs: Optional[int] = None
+) -> Tuple[List[np.ndarray], PDFInfo]:
+    images: List[np.ndarray] = []
+    page_info_list: List[PDFPageInfo] = []
+    doc = pdfium.PdfDocument(bytes_)
+    for page in doc:
+        if max_num_imgs is not None and len(images) >= max_num_imgs:
+            break
+        # TODO: Do not always use zoom=2.0
+        zoom = 2.0
+        deg = 0
+        image = page.render(scale=zoom, rotation=deg).to_pil()
+        image = image.convert("RGB")
+        image = np.array(image)
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        images.append(image)
+        page_info = PDFPageInfo(
+            width=image.shape[1],
+            height=image.shape[0],
+        )
+        page_info_list.append(page_info)
+    pdf_info = PDFInfo(
+        numPages=len(page_info_list),
+        pages=page_info_list,
+    )
+    return images, pdf_info
+
+
+@overload
+def file_to_images(
+    file_bytes: bytes,
+    file_type: Literal["IMAGE"],
+    *,
+    max_num_imgs: Optional[int] = ...,
+) -> Tuple[List[np.ndarray], ImageInfo]: ...
+
+
+@overload
+def file_to_images(
+    file_bytes: bytes,
+    file_type: Literal["PDF"],
+    *,
+    max_num_imgs: Optional[int] = ...,
+) -> Tuple[List[np.ndarray], PDFInfo]: ...
+
+
+@overload
+def file_to_images(
+    file_bytes: bytes,
+    file_type: Literal["IMAGE", "PDF"],
+    *,
+    max_num_imgs: Optional[int] = ...,
+) -> Union[Tuple[List[np.ndarray], ImageInfo], Tuple[List[np.ndarray], PDFInfo]]: ...
+
+
+def file_to_images(
+    file_bytes: bytes,
+    file_type: Literal["IMAGE", "PDF"],
+    *,
+    max_num_imgs: Optional[int] = None,
+) -> Union[Tuple[List[np.ndarray], ImageInfo], Tuple[List[np.ndarray], PDFInfo]]:
+    if file_type == "IMAGE":
+        images = [image_bytes_to_array(file_bytes)]
+        data_info = get_image_info(images[0])
+    elif file_type == "PDF":
+        images, data_info = read_pdf(file_bytes, max_num_imgs=max_num_imgs)
+    else:
+        assert_never(file_type)
+    return images, data_info
+
+
+def get_image_info(image: np.ndarray) -> ImageInfo:
+    return ImageInfo(width=image.shape[1], height=image.shape[0])
+
+
+def write_to_temp_file(file_bytes: bytes, suffix: str) -> str:
+    with tempfile.NamedTemporaryFile("wb", suffix=suffix, delete=False) as f:
+        f.write(file_bytes)
+        return f.name
+
+
+def get_raw_bytes(file: str) -> bytes:
+    if is_url(file):
+        resp = requests.get(file, timeout=5)
+        resp.raise_for_status()
+        return resp.content
+    else:
+        return base64.b64decode(file)
+
+
+@function_requires_deps("aiohttp", "yarl")
+async def get_raw_bytes_async(file: str, session: "aiohttp.ClientSession") -> bytes:
+    if is_url(file):
+        async with session.get(yarl.URL(file, encoded=True)) as resp:
+            return await resp.read()
+    else:
+        return base64.b64decode(file)
+
+
+def call_async(
+    func: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs
+) -> Awaitable[R]:
+    return asyncio.get_running_loop().run_in_executor(
+        None, partial(func, *args, **kwargs)
+    )

paddlex/inference/serving/schemas/__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/schemas/anomaly_detection.py

@@ -0,0 +1,39 @@
+# 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 Final, List, Optional
+
+from pydantic import BaseModel
+
+from ..infra.models import PrimaryOperations
+from .shared import image_segmentation
+
+__all__ = ["INFER_ENDPOINT", "InferRequest", "InferResult", "PRIMARY_OPERATIONS"]
+
+INFER_ENDPOINT: Final[str] = "/image-anomaly-detection"
+
+
+class InferRequest(BaseModel):
+    image: str
+
+
+class InferResult(BaseModel):
+    labelMap: List[int]
+    size: image_segmentation.Size
+    image: Optional[str] = None
+
+
+PRIMARY_OPERATIONS: Final[PrimaryOperations] = {
+    "infer": (INFER_ENDPOINT, InferRequest, InferResult),
+}