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

paddlex/inference/utils/io/__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.
@@ -14,20 +14,23 @@
 
 
 from .readers import (
-    ReaderType,
-    ImageReader,
-    VideoReader,
+    AudioReader,
     CSVReader,
+    ImageReader,
     PDFReader,
+    ReaderType,
+    VideoReader,
     YAMLReader,
 )
 from .writers import (
-    WriterType,
-    ImageWriter,
-    TextWriter,
-    JsonWriter,
     CSVWriter,
     HtmlWriter,
+    ImageWriter,
+    JsonWriter,
+    MarkdownWriter,
+    TextWriter,
+    VideoWriter,
+    WriterType,
     XlsxWriter,
     YAMLWriter,
 )

paddlex/inference/utils/io/readers.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,12 +15,21 @@
 
 import enum
 import itertools
-import cv2
-import fitz
-from PIL import Image, ImageOps
-import pandas as pd
+import random
+
 import numpy as np
+import pandas as pd
 import yaml
+from PIL import Image, ImageOps
+
+from ....utils.deps import class_requires_deps, is_dep_available
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+if is_dep_available("PyMuPDF"):
+    import fitz
+if is_dep_available("soundfile"):
+    import soundfile
 
 __all__ = [
     "ReaderType",
@@ -29,6 +38,7 @@ __all__ = [
     "CSVReader",
     "PDFReader",
     "YAMLReader",
+    "AudioReader",
 ]
 
 
@@ -90,7 +100,7 @@ class PDFReader(_BaseReader):
         super().__init__(backend, **bk_args)
 
     def read(self, in_path):
-        return self._backend.read_file(str(in_path))
+        yield from self._backend.read_file(str(in_path))
 
     def _init_backend(self, bk_type, bk_args):
         return PDFReaderBackend(**bk_args)
@@ -152,21 +162,28 @@ class VideoReader(_GenerativeReader):
         self.st_frame_id = st_frame_id
         self.max_num_frames = max_num_frames
         self.auto_close = auto_close
+        self._fps = 0
 
     def read(self, in_path):
         """read vide file from path"""
         self._backend.set_pos(self.st_frame_id)
         gen = self._backend.read_file(str(in_path))
-        if self.num_frames is not None:
+        if self.max_num_frames is not None:
             gen = itertools.islice(gen, self.num_frames)
         yield from gen
         if self.auto_close:
             self._backend.close()
 
+    def get_fps(self):
+        """get fps"""
+        return self._backend.get_fps()
+
     def _init_backend(self, bk_type, bk_args):
         """init backend"""
         if bk_type == "opencv":
             return OpenCVVideoReaderBackend(**bk_args)
+        elif bk_type == "decord":
+            return DecordVideoReaderBackend(**bk_args)
         else:
             raise ValueError("Unsupported backend type")
 
@@ -200,14 +217,15 @@ class _BaseReaderBackend(object):
 class _ImageReaderBackend(_BaseReaderBackend):
     """_ImageReaderBackend"""
 
-    pass
-
 
+@class_requires_deps("opencv-contrib-python")
 class OpenCVImageReaderBackend(_ImageReaderBackend):
     """OpenCVImageReaderBackend"""
 
-    def __init__(self, flags=cv2.IMREAD_COLOR):
+    def __init__(self, flags=None):
         super().__init__()
+        if flags is None:
+            flags = cv2.IMREAD_COLOR
         self.flags = flags
 
     def read_file(self, in_path):
@@ -226,6 +244,7 @@ class PILImageReaderBackend(_ImageReaderBackend):
         return ImageOps.exif_transpose(Image.open(in_path))
 
 
+@class_requires_deps("PyMuPDF", "opencv-contrib-python")
 class PDFReaderBackend(_BaseReaderBackend):
 
     def __init__(self, rotate=0, zoom_x=2.0, zoom_y=2.0):
@@ -233,15 +252,13 @@ class PDFReaderBackend(_BaseReaderBackend):
         self.mat = fitz.Matrix(zoom_x, zoom_y).prerotate(rotate)
 
     def read_file(self, in_path):
-        images = []
         for page in fitz.open(in_path):
-            pix = page.get_pixmap(matrix=self.mat, alpha=False)
-            getpngdata = pix.tobytes(output="png")
-            # decode as np.uint8
-            image_array = np.frombuffer(getpngdata, dtype=np.uint8)
-            img_cv = cv2.imdecode(image_array, cv2.IMREAD_ANYCOLOR)
-            images.append(img_cv)
-        return images
+            pixmap = page.get_pixmap(matrix=self.mat, alpha=False)
+            img_cv = np.frombuffer(pixmap.samples, dtype=np.uint8).reshape(
+                pixmap.h, pixmap.w, pixmap.n
+            )
+            img_cv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2BGR)
+            yield img_cv
 
 
 class _VideoReaderBackend(_BaseReaderBackend):
@@ -256,18 +273,23 @@ class _VideoReaderBackend(_BaseReaderBackend):
         raise NotImplementedError
 
 
+@class_requires_deps("opencv-contrib-python")
 class OpenCVVideoReaderBackend(_VideoReaderBackend):
     """OpenCVVideoReaderBackend"""
 
     def __init__(self, **bk_args):
         super().__init__()
         self.cap_init_args = bk_args
+        self.num_seg = bk_args.get("num_seg", None)
         self._cap = None
         self._pos = 0
         self._max_num_frames = None
 
+    def get_fps(self):
+        return self._cap.get(cv2.CAP_PROP_FPS)
+
     def read_file(self, in_path):
-        """read vidio file from path"""
+        """read video file from path"""
         if self._cap is not None:
             self._cap_release()
         self._cap = self._cap_open(in_path)
@@ -277,14 +299,33 @@ class OpenCVVideoReaderBackend(_VideoReaderBackend):
 
     def _read_frames(self, cap):
         """read frames"""
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            yield frame
+        if self.num_seg:
+            queue = []
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                queue = []
+                if (
+                    len(queue) <= 0
+                ):  # At initialization, populate queue with initial frame
+                    for i in range(self.num_seg):
+                        queue.append(frame)
+                queue.append(frame)
+                queue.pop(0)
+                yield queue.copy()
+        else:
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                yield frame
         self._cap_release()
 
     def _cap_open(self, video_path):
+        self.cap_init_args.pop("num_seg", None)
+        self.cap_init_args.pop("seg_len", None)
+        self.cap_init_args.pop("sample_type", None)
         self._cap = cv2.VideoCapture(video_path, **self.cap_init_args)
         if not self._cap.isOpened():
             raise RuntimeError(f"Failed to open {video_path}")
@@ -305,6 +346,83 @@ class OpenCVVideoReaderBackend(_VideoReaderBackend):
             self._cap = None
 
 
+class DecordVideoReaderBackend(_VideoReaderBackend):
+    """DecordVideoReaderBackend"""
+
+    def __init__(self, **bk_args):
+        super().__init__()
+        self.cap_init_args = bk_args
+        self._cap = None
+        self._pos = 0
+        self._max_num_frames = None
+        self.num_seg = bk_args.get("num_seg", 8)
+        self.seg_len = bk_args.get("seg_len", 1)
+        self.sample_type = bk_args.get("sample_type", 1)
+        self.valid_mode = True
+        self._fps = 0
+
+        # XXX(gaotingquan): There is a confict with `paddle` when import `decord` globally.
+        try:
+            import decord
+
+            self.decord_module = decord
+        except ModuleNotFoundError():
+            raise Exception(
+                "Please install `decord` manually, otherwise, the related model cannot work. It can be automatically installed only on `x86_64`. Refers: `https://github.com/dmlc/decord`."
+            )
+
+    def set_pos(self, pos):
+        self._pos = pos
+
+    def sample(self, frames_len, video_object):
+        frames_idx = []
+        average_dur = int(frames_len / self.num_seg)
+        for i in range(self.num_seg):
+            idx = 0
+            if not self.valid_mode:
+                if average_dur >= self.seg_len:
+                    idx = random.randint(0, average_dur - self.seg_len)
+                    idx += i * average_dur
+                elif average_dur >= 1:
+                    idx += i * average_dur
+                else:
+                    idx = i
+            else:
+                if average_dur >= self.seg_len:
+                    idx = (average_dur - 1) // 2
+                    idx += i * average_dur
+                elif average_dur >= 1:
+                    idx += i * average_dur
+                else:
+                    idx = i
+            for jj in range(idx, idx + self.seg_len):
+                frames_idx.append(int(jj % frames_len))
+        frames_select = video_object.get_batch(frames_idx)
+        # dearray_to_img
+        np_frames = frames_select.asnumpy()
+        imgs = []
+        for i in range(np_frames.shape[0]):
+            imgbuf = np_frames[i]
+            imgs.append(imgbuf)
+        return imgs
+
+    def get_fps(self):
+        return self._cap.get_avg_fps()
+
+    def read_file(self, in_path):
+        """read video file from path"""
+        self._cap = self.decord_module.VideoReader(in_path)
+        frame_len = len(self._cap)
+        if self.sample_type == "uniform":
+            sample_video = self.sample(frame_len, self._cap)
+            return sample_video
+        else:
+            return self._cap
+
+    def close(self):
+        pass
+
+
 class CSVReader(_BaseReader):
     """CSVReader"""
 
@@ -331,8 +449,6 @@ class CSVReader(_BaseReader):
 class _CSVReaderBackend(_BaseReaderBackend):
     """_CSVReaderBackend"""
 
-    pass
-
 
 class PandasCSVReaderBackend(_CSVReaderBackend):
     """PandasCSVReaderBackend"""
@@ -349,5 +465,40 @@ class YAMLReaderBackend(_BaseReaderBackend):
 
     def read_file(self, in_path, **kwargs):
         with open(in_path, "r", encoding="utf-8", **kwargs) as yaml_file:
-            data = yaml.safe_load(yaml_file)
+            data = yaml.load(yaml_file, Loader=yaml.FullLoader)
         return data
+
+
+class AudioReader(_BaseReader):
+    def __init__(self, backend="wav", **bk_args):
+        super().__init__(backend="wav", **bk_args)
+
+    def _init_backend(self, bk_type, bk_args):
+        """init backend"""
+        if bk_type == "wav":
+            return WAVReaderBackend(**bk_args)
+        else:
+            raise ValueError("Unsupported backend type")
+
+    def read(self, in_path):
+        audio, audio_sample_rate = self._backend.read_file(str(in_path))
+        return audio, audio_sample_rate
+
+
+class _AudioReaderBackend(_BaseReaderBackend):
+    """_AudioReaderBackend"""
+
+
+@class_requires_deps("soundfile")
+class WAVReaderBackend(_AudioReaderBackend):
+    """PandasCSVReaderBackend"""
+
+    def __init__(self):
+        super().__init__()
+
+    def read_file(self, in_path):
+        """read wav file from path"""
+        audio, audio_sample_rate = soundfile.read(
+            in_path, dtype="float32", always_2d=True
+        )
+        return audio, audio_sample_rate

paddlex/inference/utils/io/style.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.
@@ -12,23 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from openpyxl.cell import cell
-from openpyxl.styles import (
-    Font,
-    Alignment,
-    PatternFill,
-    NamedStyle,
-    Border,
-    Side,
-    Color,
-)
-from openpyxl.styles.fills import FILL_SOLID
-from openpyxl.styles.numbers import FORMAT_CURRENCY_USD_SIMPLE, FORMAT_PERCENTAGE
-from openpyxl.styles.colors import BLACK
+
+from ....utils.deps import class_requires_deps, function_requires_deps, is_dep_available
+
+if is_dep_available("openpyxl"):
+    from openpyxl.cell import cell
+    from openpyxl.styles import (
+        Alignment,
+        Border,
+        Color,
+        Font,
+        NamedStyle,
+        PatternFill,
+        Side,
+    )
+    from openpyxl.styles.colors import BLACK
+    from openpyxl.styles.fills import FILL_SOLID
+    from openpyxl.styles.numbers import FORMAT_CURRENCY_USD_SIMPLE, FORMAT_PERCENTAGE
 
 FORMAT_DATE_MMDDYYYY = "mm/dd/yyyy"
 
 
+@function_requires_deps("openpyxl")
 def colormap(color):
     """
     Convenience for looking up known colors
@@ -65,6 +70,7 @@ def get_side(style, name):
 known_styles = {}
 
 
+@function_requires_deps("openpyxl")
 def style_dict_to_named_style(style_dict, number_format=None):
     """
     Change css style (stored in a python dictionary) to openpyxl NamedStyle
@@ -303,6 +309,7 @@ def _element_to_string(el):
     return text + string + "\n" + tail
 
 
+@class_requires_deps("openpyxl")
 class TableCell(Element):
     """
     This class maps to the `<td>` element of the html table.

paddlex/inference/utils/io/tablepyxl.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,12 +14,17 @@
 
 from __future__ import absolute_import
 
-from lxml import html
-from openpyxl import Workbook
-from openpyxl.utils import get_column_letter
-from premailer import Premailer
+from ....utils.deps import function_requires_deps, is_dep_available
 from .style import Table
 
+if is_dep_available("lxml"):
+    from lxml import html
+if is_dep_available("openpyxl"):
+    from openpyxl import Workbook
+    from openpyxl.utils import get_column_letter
+if is_dep_available("premailer"):
+    from premailer import Premailer
+
 
 def string_to_int(s):
     """
@@ -30,6 +35,7 @@ def string_to_int(s):
     return 0
 
 
+@function_requires_deps("lxml")
 def get_Tables(doc):
     """
     Find all the tables in the doc
@@ -41,6 +47,7 @@ def get_Tables(doc):
     return [Table(table) for table in tree.xpath("//table")]
 
 
+@function_requires_deps("openpyxl")
 def write_rows(worksheet, elem, row, column=1):
     """
     Writes every tr child element of elem to a row in the worksheet
@@ -100,6 +107,7 @@ def table_to_sheet(table, wb):
     insert_table(table, ws, 1, 1)
 
 
+@function_requires_deps("openpyxl", "premailer")
 def document_to_workbook(doc, wb=None, base_url=None):
     """
     Takes a string representation of an html document and writes one sheet for

paddlex/inference/utils/io/writers.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.
@@ -13,18 +13,21 @@
 # limitations under the License.
 
 
-import os
 import enum
 import json
 from pathlib import Path
 
-import cv2
 import numpy as np
-from PIL import Image
 import pandas as pd
 import yaml
+from PIL import Image
+
+from ....utils.deps import class_requires_deps, is_dep_available
 from .tablepyxl import document_to_xl
 
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
 
 __all__ = [
     "WriterType",
@@ -35,6 +38,8 @@ __all__ = [
     "HtmlWriter",
     "XlsxWriter",
     "YAMLWriter",
+    "VideoWriter",
+    "MarkdownWriter",
 ]
 
 
@@ -114,6 +119,28 @@ class ImageWriter(_BaseWriter):
         return WriterType.IMAGE
 
 
+class VideoWriter(_BaseWriter):
+    """VideoWriter"""
+
+    def __init__(self, backend="opencv", **bk_args):
+        super().__init__(backend=backend, **bk_args)
+
+    def write(self, out_path, obj):
+        """write"""
+        return self._backend.write_obj(str(out_path), obj)
+
+    def _init_backend(self, bk_type, bk_args):
+        """init backend"""
+        if bk_type == "opencv":
+            return OpenCVVideoWriterBackend(**bk_args)
+        else:
+            raise ValueError("Unsupported backend type")
+
+    def get_type(self):
+        """get type"""
+        return WriterType.VIDEO
+
+
 class TextWriter(_BaseWriter):
     """TextWriter"""
 
@@ -210,6 +237,28 @@ class YAMLWriter(_BaseWriter):
         return WriterType.YAML
 
 
+class MarkdownWriter(_BaseWriter):
+    """MarkdownWriter"""
+
+    def __init__(self, backend="markdown", **bk_args):
+        super().__init__(backend=backend, **bk_args)
+
+    def write(self, out_path, obj):
+        """write"""
+        return self._backend.write_obj(str(out_path), obj)
+
+    def _init_backend(self, bk_type, bk_args):
+        """init backend"""
+        if bk_type == "markdown":
+            return MarkdownWriterBackend(**bk_args)
+        else:
+            raise ValueError("Unsupported backend type")
+
+    def get_type(self):
+        """get type"""
+        return WriterType.MARKDOWN
+
+
 class _BaseWriterBackend(object):
     """_BaseWriterBackend"""
 
@@ -257,16 +306,16 @@ class XlsxWriterBackend(_BaseWriterBackend):
 class _ImageWriterBackend(_BaseWriterBackend):
     """_ImageWriterBackend"""
 
-    pass
-
 
+@class_requires_deps("opencv-contrib-python")
 class OpenCVImageWriterBackend(_ImageWriterBackend):
     """OpenCVImageWriterBackend"""
 
     def _write_obj(self, out_path, obj):
         """write image object by OpenCV"""
         if isinstance(obj, Image.Image):
-            arr = np.asarray(obj)
+            # Assuming the channel order is RGB.
+            arr = np.asarray(obj)[:, :, ::-1]
         elif isinstance(obj, np.ndarray):
             arr = obj
         else:
@@ -294,6 +343,29 @@ class PILImageWriterBackend(_ImageWriterBackend):
         return img.save(out_path, format=self.format)
 
 
+class _VideoWriterBackend(_BaseWriterBackend):
+    """_VideoWriterBackend"""
+
+
+@class_requires_deps("opencv-contrib-python")
+class OpenCVVideoWriterBackend(_VideoWriterBackend):
+    """OpenCVImageWriterBackend"""
+
+    def _write_obj(self, out_path, obj):
+        """write video object by OpenCV"""
+        obj, fps = obj
+        if isinstance(obj, np.ndarray):
+            vr = obj
+            width, height = vr[0].shape[1], vr[0].shape[0]
+            fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # Alternatively, use 'XVID'
+            out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+            for frame in vr:
+                out.write(frame)
+            out.release()
+        else:
+            raise TypeError("Unsupported object type")
+
+
 class _BaseJsonWriterBackend(object):
     def __init__(self, indent=4, ensure_ascii=False):
         super().__init__()
@@ -310,7 +382,7 @@ class _BaseJsonWriterBackend(object):
 
 class JsonWriterBackend(_BaseJsonWriterBackend):
     def _write_obj(self, out_path, obj, **bk_args):
-        with open(out_path, "w") as f:
+        with open(out_path, "w", encoding="utf-8") as f:
             json.dump(obj, f, **bk_args)
 
 
@@ -358,8 +430,6 @@ class CSVWriter(_BaseWriter):
 class _CSVWriterBackend(_BaseWriterBackend):
     """_CSVWriterBackend"""
 
-    pass
-
 
 class PandasCSVWriterBackend(_CSVWriterBackend):
     """PILImageWriterBackend"""
@@ -374,3 +444,15 @@ class PandasCSVWriterBackend(_CSVWriterBackend):
         else:
             raise TypeError("Unsupported object type")
         return ts.to_csv(out_path)
+
+
+class MarkdownWriterBackend(_BaseWriterBackend):
+    """MarkdownWriterBackend"""
+
+    def __init__(self):
+        super().__init__()
+
+    def _write_obj(self, out_path, obj):
+        """write markdown obj"""
+        with open(out_path, mode="w", encoding="utf-8", errors="replace") as f:
+            f.write(obj)

paddlex/inference/utils/model_paths.py

@@ -0,0 +1,48 @@
+# 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 os import PathLike
+from pathlib import Path
+from typing import Tuple, TypedDict, Union
+
+from ...constants import MODEL_FILE_PREFIX
+
+
+class ModelPaths(TypedDict, total=False):
+    paddle: Tuple[Path, Path]
+    onnx: Path
+    om: Path
+
+
+def get_model_paths(
+    model_dir: Union[str, PathLike],
+    model_file_prefix: str = MODEL_FILE_PREFIX,
+) -> ModelPaths:
+    model_dir = Path(model_dir)
+    model_paths: ModelPaths = {}
+    pd_model_path = None
+    if (model_dir / f"{model_file_prefix}.json").exists():
+        pd_model_path = model_dir / f"{model_file_prefix}.json"
+    elif (model_dir / f"{model_file_prefix}.pdmodel").exists():
+        pd_model_path = model_dir / f"{model_file_prefix}.pdmodel"
+    if pd_model_path and (model_dir / f"{model_file_prefix}.pdiparams").exists():
+        model_paths["paddle"] = (
+            pd_model_path,
+            model_dir / f"{model_file_prefix}.pdiparams",
+        )
+    if (model_dir / f"{model_file_prefix}.onnx").exists():
+        model_paths["onnx"] = model_dir / f"{model_file_prefix}.onnx"
+    if (model_dir / f"{model_file_prefix}.om").exists():
+        model_paths["om"] = model_dir / f"{model_file_prefix}.om"
+    return model_paths