paddlex 3.0.0rc0__py3-none-any.whl → 3.0.1__py3-none-any.whl

paddlex/utils/deps.py

@@ -0,0 +1,249 @@
+# 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.metadata
+import importlib.util
+import inspect
+import re
+from collections import defaultdict
+from functools import lru_cache, wraps
+
+from packaging.requirements import Requirement
+from packaging.version import Version
+
+from . import logging
+
+_EXTRA_PATTERN = re.compile(
+    r"(?:;|and)*[ \t]*extra[ \t]*==[ \t]*['\"]([a-z0-9]+(?:-[a-z0-9]+)*)['\"]"
+)
+_COLLECTIVE_EXTRA_NAMES = {"base", "plugins", "all"}
+
+
+def _get_extra_name_and_remove_extra_marker(dep_spec):
+    # XXX: Not sure if this is correct
+    m = _EXTRA_PATTERN.search(dep_spec)
+    if m:
+        return m.group(1), dep_spec[: m.start()] + dep_spec[m.end() :]
+    else:
+        return None, dep_spec
+
+
+def _get_extras():
+    metadata = importlib.metadata.metadata("paddlex")
+    extras = {}
+    # XXX: The `metadata.get_all` used here is not well documented.
+    for name in metadata.get_all("Provides-Extra", []):
+        if name not in _COLLECTIVE_EXTRA_NAMES:
+            extras[name] = defaultdict(list)
+    for dep_spec in importlib.metadata.requires("paddlex"):
+        extra_name, dep_spec = _get_extra_name_and_remove_extra_marker(dep_spec)
+        if extra_name is not None and extra_name not in _COLLECTIVE_EXTRA_NAMES:
+            dep_spec = dep_spec.rstrip()
+            req = Requirement(dep_spec)
+            assert extra_name in extras, extra_name
+            extras[extra_name][req.name].append(dep_spec)
+    return extras
+
+
+EXTRAS = _get_extras()
+
+
+def _get_dep_specs():
+    dep_specs = defaultdict(list)
+    for dep_spec in importlib.metadata.requires("paddlex"):
+        extra_name, dep_spec = _get_extra_name_and_remove_extra_marker(dep_spec)
+        if extra_name is None or extra_name == "all":
+            dep_spec = dep_spec.rstrip()
+            req = Requirement(dep_spec)
+            dep_specs[req.name].append(dep_spec)
+    return dep_specs
+
+
+DEP_SPECS = _get_dep_specs()
+
+
+def _get_dep_version(dep):
+    try:
+        return importlib.metadata.version(dep)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+@lru_cache()
+def is_dep_available(dep, /, check_version=None):
+    # Currently for several special deps we check if the import packages exist.
+    if dep in ("paddlepaddle", "paddle-custom-device", "ultra-infer") and check_version:
+        raise ValueError(
+            "Currently, `check_version` is not allowed to be `True` for `paddlepaddle`, `paddle-custom-device`, and `ultra-infer`."
+        )
+    if dep == "paddlepaddle":
+        return importlib.util.find_spec("paddle") is not None
+    elif dep == "paddle-custom-device":
+        return importlib.util.find_spec("paddle_custom_device") is not None
+    elif dep == "ultra-infer":
+        return importlib.util.find_spec("ultra_infer") is not None
+    else:
+        if dep != "paddle2onnx" and dep not in DEP_SPECS:
+            raise ValueError("Unknown dependency")
+    if check_version is None:
+        if dep == "paddle2onnx":
+            check_version = True
+        else:
+            check_version = False
+    version = _get_dep_version(dep)
+    if version is None:
+        return False
+    if check_version:
+        if dep == "paddle2onnx":
+            return Version(version) in Requirement(get_paddle2onnx_spec()).specifier
+        for dep_spec in DEP_SPECS[dep]:
+            if Version(version) in Requirement(dep_spec).specifier:
+                return True
+    else:
+        return True
+
+
+def require_deps(*deps, obj_name=None):
+    unavailable_deps = [dep for dep in deps if not is_dep_available(dep)]
+    if len(unavailable_deps) > 0:
+        if obj_name is not None:
+            msg = f"`{obj_name}` is not ready for use, because the"
+        else:
+            msg = "The"
+        msg += " following dependencies are not available:\n" + "\n".join(
+            unavailable_deps
+        )
+        raise RuntimeError(msg)
+
+
+def function_requires_deps(*deps):
+    def _deco(func):
+        @wraps(func)
+        def _wrapper(*args, **kwargs):
+            require_deps(*func._deps_, obj_name=func.__name__)
+            return func(*args, **kwargs)
+
+        func._deps_ = set(deps)
+        return _wrapper
+
+    return _deco
+
+
+def class_requires_deps(*deps):
+    def _deco(cls):
+        @wraps(cls.__init__)
+        def _wrapper(self, *args, **kwargs):
+            require_deps(*cls._deps_, obj_name=cls.__name__)
+            return old_init_func(self, *args, **kwargs)
+
+        cls._deps_ = set(deps)
+        for base_cls in inspect.getmro(cls)[1:-1]:
+            if hasattr(base_cls, "_deps_"):
+                cls._deps_.update(base_cls._deps_)
+        if "__init__" in cls.__dict__:
+            old_init_func = cls.__init__
+        else:
+
+            def _forward(self, *args, **kwargs):
+                return super(cls, self).__init__(*args, **kwargs)
+
+            old_init_func = _forward
+        cls.__init__ = _wrapper
+        return cls
+
+    return _deco
+
+
+@lru_cache()
+def is_extra_available(extra):
+    flags = [is_dep_available(dep) for dep in EXTRAS[extra]]
+    if all(flags):
+        return True
+    logging.debug(
+        "These dependencies are not available: %s",
+        [d for d, f in zip(EXTRAS[extra], flags) if not f],
+    )
+    return False
+
+
+def require_extra(extra, *, obj_name=None):
+    if not is_extra_available(extra):
+        if obj_name is not None:
+            msg = f"`{obj_name}` requires additional dependencies."
+        else:
+            msg = "Additional dependencies are required."
+        msg += f' To install them, run `pip install "paddlex[{extra}]==<PADDLEX_VERSION>"` if you’re installing `paddlex` from an index, or `pip install -e "/path/to/PaddleX[{extra}]"` if you’re installing `paddlex` locally.'
+        raise RuntimeError(msg)
+
+
+def pipeline_requires_extra(extra):
+    def _deco(pipeline_cls):
+        @wraps(pipeline_cls.__init__)
+        def _wrapper(self, *args, **kwargs):
+            require_extra(extra, obj_name=pipeline_name)
+            return old_init_func(self, *args, **kwargs)
+
+        old_init_func = pipeline_cls.__init__
+        pipeline_name = pipeline_cls.entities
+        if isinstance(pipeline_name, list):
+            assert len(pipeline_name) == 1, pipeline_name
+            pipeline_name = pipeline_name[0]
+        pipeline_cls.__init__ = _wrapper
+        return pipeline_cls
+
+    return _deco
+
+
+def is_hpip_available():
+    return is_dep_available("ultra-infer")
+
+
+def require_hpip():
+    if not is_hpip_available():
+        raise RuntimeError(
+            "The high-performance inference plugin is not available. Please install it properly."
+        )
+
+
+def is_serving_plugin_available():
+    return is_extra_available("serving")
+
+
+def require_serving_plugin():
+    if not is_serving_plugin_available():
+        raise RuntimeError(
+            "The serving plugin is not available. Please install it properly."
+        )
+
+
+def get_serving_dep_specs():
+    dep_specs = []
+    for item in EXTRAS["serving"].values():
+        dep_specs += item
+    return dep_specs
+
+
+def is_paddle2onnx_plugin_available():
+    return is_dep_available("paddle2onnx")
+
+
+def require_paddle2onnx_plugin():
+    if not is_paddle2onnx_plugin_available():
+        raise RuntimeError(
+            "The Paddle2ONNX plugin is not available. Please install it properly."
+        )
+
+
+def get_paddle2onnx_spec():
+    return "paddle2onnx == 2.0.2rc3"

paddlex/utils/device.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,24 +13,26 @@
 # limitations under the License.
 
 import os
+from contextlib import ContextDecorator
+
 import GPUtil
 
-import lazy_paddle as paddle
 from . import logging
-from .flags import DISABLE_DEV_MODEL_WL
-from .errors import raise_unsupported_device_error
-from .custom_device_whitelist import (
+from .custom_device_list import (
     DCU_WHITELIST,
+    GCU_WHITELIST,
     MLU_WHITELIST,
-    NPU_WHITELIST,
+    NPU_BLACKLIST,
     XPU_WHITELIST,
-    GCU_WHITELIST,
 )
+from .flags import DISABLE_DEV_MODEL_WL
 
 SUPPORTED_DEVICE_TYPE = ["cpu", "gpu", "xpu", "npu", "mlu", "gcu", "dcu"]
 
 
-def _constr_device(device_type, device_ids):
+def constr_device(device_type, device_ids):
+    if device_type == "cpu" and device_ids is not None:
+        raise ValueError("`device_ids` must be None for CPUs")
     if device_ids:
         device_ids = ",".join(map(str, device_ids))
         return f"{device_type}:{device_ids}"
@@ -39,18 +41,25 @@ def _constr_device(device_type, device_ids):
 
 
 def get_default_device():
-    avail_gpus = GPUtil.getAvailable()
-    if not avail_gpus:
-        # maybe edge devices like Jetson
+    try:
+        gpu_list = GPUtil.getGPUs()
+    except Exception:
+        logging.debug(
+            "Failed to query GPU devices. Falling back to CPU.", exc_info=True
+        )
+        has_gpus = False
+    else:
+        has_gpus = bool(gpu_list)
+    if not has_gpus:
+        # HACK
         if os.path.exists("/etc/nv_tegra_release"):
-            avail_gpus = [0]
-            logging.info(
-                "Detected that the current device is a Jetson edge device. The default behavior will be to use GPU: 0"
+            logging.debug(
+                "The current device appears to be an NVIDIA Jetson. GPU 0 will be used as the default device."
             )
-    if not avail_gpus:
+    if not has_gpus:
         return "cpu"
     else:
-        return _constr_device("gpu", [avail_gpus[0]])
+        return constr_device("gpu", [0])
 
 
 def parse_device(device):
@@ -73,6 +82,8 @@ def parse_device(device):
     device_type = device_type.lower()
     # raise_unsupported_device_error(device_type, SUPPORTED_DEVICE_TYPE)
     assert device_type.lower() in SUPPORTED_DEVICE_TYPE
+    if device_type == "cpu" and device_ids is not None:
+        raise ValueError("No Device ID should be specified for CPUs")
     return device_type, device_ids
 
 
@@ -80,18 +91,24 @@ def update_device_num(device, num):
     device_type, device_ids = parse_device(device)
     if device_ids:
         assert len(device_ids) >= num
-        return _constr_device(device_type, device_ids[:num])
+        return constr_device(device_type, device_ids[:num])
     else:
-        return _constr_device(device_type, device_ids)
+        return constr_device(device_type, device_ids)
 
 
 def set_env_for_device(device):
+    device_type, _ = parse_device(device)
+    return set_env_for_device_type(device_type)
+
+
+def set_env_for_device_type(device_type):
+    import paddle
+
     def _set(envs):
         for key, val in envs.items():
             os.environ[key] = val
             logging.debug(f"{key} has been set to {val}.")
 
-    device_type, device_ids = parse_device(device)
     # XXX: is_compiled_with_rocm() must be True on dcu platform ?
     if device_type.lower() == "dcu" and paddle.is_compiled_with_rocm():
         envs = {"FLAGS_conv_workspace_size_limit": "2000"}
@@ -122,30 +139,64 @@ def set_env_for_device(device):
         _set(envs)
 
 
-def check_supported_device(device, model_name):
+def check_supported_device_type(device_type, model_name):
     if DISABLE_DEV_MODEL_WL:
         logging.warning(
             "Skip checking if model is supported on device because the flag `PADDLE_PDX_DISABLE_DEV_MODEL_WL` has been set."
         )
         return
-    device_type, device_ids = parse_device(device)
+    tips = "You could set env `PADDLE_PDX_DISABLE_DEV_MODEL_WL` to `true` to disable this checking."
     if device_type == "dcu":
-        assert (
-            model_name in DCU_WHITELIST
-        ), f"The DCU device does not yet support `{model_name}` model!"
+        assert model_name in DCU_WHITELIST, (
+            f"The DCU device does not yet support `{model_name}` model!" + tips
+        )
     elif device_type == "mlu":
-        assert (
-            model_name in MLU_WHITELIST
-        ), f"The MLU device does not yet support `{model_name}` model!"
+        assert model_name in MLU_WHITELIST, (
+            f"The MLU device does not yet support `{model_name}` model!" + tips
+        )
     elif device_type == "npu":
-        assert (
-            model_name in NPU_WHITELIST
-        ), f"The NPU device does not yet support `{model_name}` model!"
+        assert model_name not in NPU_BLACKLIST, (
+            f"The NPU device does not yet support `{model_name}` model!" + tips
+        )
     elif device_type == "xpu":
-        assert (
-            model_name in XPU_WHITELIST
-        ), f"The XPU device does not yet support `{model_name}` model!"
+        assert model_name in XPU_WHITELIST, (
+            f"The XPU device does not yet support `{model_name}` model!" + tips
+        )
     elif device_type == "gcu":
-        assert (
-            model_name in GCU_WHITELIST
-        ), f"The GCU device does not yet support `{model_name}` model!"
+        assert model_name in GCU_WHITELIST, (
+            f"The GCU device does not yet support `{model_name}` model!" + tips
+        )
+
+
+def check_supported_device(device, model_name):
+    device_type, _ = parse_device(device)
+    return check_supported_device_type(device_type, model_name)
+
+
+class TemporaryDeviceChanger(ContextDecorator):
+    """
+    A context manager to temporarily change global device
+    """
+
+    def __init__(self, new_device):
+        # if new_device is None, nothing changed
+        import paddle
+
+        self.new_device = new_device
+        self.original_device = paddle.device.get_device()
+
+    def __enter__(self):
+        import paddle
+
+        if self.new_device is None:
+            return self
+        paddle.device.set_device(self.new_device)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        import paddle
+
+        if self.new_device is None:
+            return False
+        paddle.device.set_device(self.original_device)
+        return False

paddlex/utils/download.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,12 +13,12 @@
 # limitations under the License.
 
 import os
-import sys
-import time
 import shutil
+import sys
 import tarfile
-import zipfile
 import tempfile
+import time
+import zipfile
 
 import requests
 

paddlex/utils/env.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,17 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import lazy_paddle as paddle
-
 
 def get_device_type():
+    import paddle
+
     device_str = paddle.get_device()
     return device_str.split(":")[0]
 
 
 def get_paddle_version():
-    version = paddle.__version__.split(".")
-    # ref: https://github.com/PaddlePaddle/Paddle/blob/release/3.0-beta2/setup.py#L316
+    import paddle
+
+    version = paddle.__version__
+    if "-" in version:
+        version, tag = version.split("-")
+    else:
+        tag = None
+    version = version.split(".")
     assert len(version) == 3
-    major_v, minor_v, patch_v = version
-    return major_v, minor_v, patch_v
+    major_v, minor_v, patch_v = map(int, version)
+    if tag:
+        return major_v, minor_v, patch_v, tag
+    else:
+        return major_v, minor_v, patch_v, None
+
+
+def get_paddle_cuda_version():
+    import paddle.version
+
+    cuda_version = paddle.version.cuda()
+    if cuda_version == "False":
+        return None
+    return tuple(map(int, cuda_version.split(".")))
+
+
+def get_paddle_cudnn_version():
+    import paddle.version
+
+    cudnn_version = paddle.version.cudnn()
+    if cudnn_version == "False":
+        return None
+    return tuple(map(int, cudnn_version.split(".")))
+
+
+# Should we also support getting the runtime versions of CUDA and cuDNN?

paddlex/utils/errors/__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.

paddlex/utils/errors/dataset_checker.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.

paddlex/utils/errors/others.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,8 +14,8 @@
 
 import json
 import signal
-from typing import Union
 from pathlib import Path
+from typing import Union
 
 __all__ = [
     "UnsupportedAPIError",
@@ -34,38 +34,26 @@ __all__ = [
 class UnsupportedAPIError(Exception):
     """UnsupportedAPIError"""
 
-    pass
-
 
 class UnsupportedParamError(Exception):
     """UnsupportedParamError"""
 
-    pass
-
 
 class KeyNotFoundError(Exception):
     """KeyNotFoundError"""
 
-    pass
-
 
 class ClassNotFoundException(Exception):
     """ClassNotFoundException"""
 
-    pass
-
 
 class NoEntityRegisteredException(Exception):
     """NoEntityRegisteredException"""
 
-    pass
-
 
 class UnsupportedDeviceError(Exception):
     """UnsupportedDeviceError"""
 
-    pass
-
 
 class CalledProcessError(Exception):
     """CalledProcessError"""
@@ -90,8 +78,6 @@ class CalledProcessError(Exception):
 class DuplicateRegistrationError(Exception):
     """DuplicateRegistrationError"""
 
-    pass
-
 
 class ModelNotFoundError(Exception):
     """Model Not Found Error"""

paddlex/utils/file_interface.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,11 @@
 
 import logging
 import os
-from threading import ThreadError
 
-from filelock import FileLock
-import yaml
-import ruamel.yaml
 import chardet
+import ruamel.yaml
+import yaml
+from filelock import FileLock
 
 try:
     import ujson as json

paddlex/utils/flags.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.
@@ -21,13 +21,13 @@ __all__ = [
     "CHECK_OPTS",
     "EAGER_INITIALIZATION",
     "INFER_BENCHMARK",
-    "INFER_BENCHMARK_ITER",
+    "INFER_BENCHMARK_ITERS",
     "INFER_BENCHMARK_WARMUP",
-    "INFER_BENCHMARK_OUTPUT",
-    "INFER_BENCHMARK_DATA_SIZE",
+    "INFER_BENCHMARK_OUTPUT_DIR",
     "FLAGS_json_format_model",
     "USE_PIR_TRT",
     "DISABLE_DEV_MODEL_WL",
+    "DISABLE_CINN_MODEL_WL",
 ]
 
 
@@ -47,19 +47,24 @@ DEBUG = get_flag_from_env_var("PADDLE_PDX_DEBUG", False)
 DRY_RUN = get_flag_from_env_var("PADDLE_PDX_DRY_RUN", False)
 CHECK_OPTS = get_flag_from_env_var("PADDLE_PDX_CHECK_OPTS", False)
 EAGER_INITIALIZATION = get_flag_from_env_var("PADDLE_PDX_EAGER_INIT", True)
-FLAGS_json_format_model = get_flag_from_env_var("FLAGS_json_format_model", None)
-USE_PIR_TRT = get_flag_from_env_var("PADDLE_PDX_USE_PIR_TRT", False)
+FLAGS_json_format_model = get_flag_from_env_var("FLAGS_json_format_model", True)
+USE_PIR_TRT = get_flag_from_env_var("PADDLE_PDX_USE_PIR_TRT", True)
 DISABLE_DEV_MODEL_WL = get_flag_from_env_var("PADDLE_PDX_DISABLE_DEV_MODEL_WL", False)
+DISABLE_CINN_MODEL_WL = get_flag_from_env_var("PADDLE_PDX_DISABLE_CINN_MODEL_WL", False)
+LOCAL_FONT_FILE_PATH = get_flag_from_env_var("PADDLE_PDX_LOCAL_FONT_FILE_PATH", None)
+
 
 # Inference Benchmark
-INFER_BENCHMARK = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK", None)
+INFER_BENCHMARK = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK", False)
 INFER_BENCHMARK_WARMUP = get_flag_from_env_var(
     "PADDLE_PDX_INFER_BENCHMARK_WARMUP", 0, int
 )
-INFER_BENCHMARK_OUTPUT = get_flag_from_env_var(
-    "PADDLE_PDX_INFER_BENCHMARK_OUTPUT", None
+INFER_BENCHMARK_OUTPUT_DIR = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_OUTPUT_DIR", None
+)
+INFER_BENCHMARK_ITERS = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_ITERS", 0, int
 )
-INFER_BENCHMARK_ITER = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK_ITER", 10, int)
-INFER_BENCHMARK_DATA_SIZE = get_flag_from_env_var(
-    "PADDLE_PDX_INFER_BENCHMARK_DATA_SIZE", 1024
+INFER_BENCHMARK_USE_CACHE_FOR_READ = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_USE_CACHE_FOR_READ", False
 )