optimum-rbln 0.9.3.post1__py3-none-any.whl

optimum/rbln/utils/decorator_utils.py

@@ -0,0 +1,86 @@
+# Copyright 2025 Rebellions Inc. 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 inspect
+from functools import wraps
+
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def remove_compile_time_kwargs(func):
+    """
+    Decorator to handle compile-time parameters during inference.
+
+    For RBLN-optimized pipelines, several parameters must be determined during compilation
+    and cannot be modified during inference. This decorator:
+    1. Removes and warns about image dimension parameters (height, width)
+    2. Removes and warns about LoRA scale in cross_attention_kwargs
+
+    Args:
+        func: The pipeline's __call__ method to be wrapped
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        check_params = {"height", "width"}
+        params = inspect.signature(self.original_class.__call__).parameters
+
+        # If height and width exist in the base pipeline's __call__ method arguments
+        # Otherwise, if there is no height or width of kwargs, it is filled based on the compiled size.
+        if check_params.issubset(params):
+            compiled_image_size = self.get_compiled_image_size()
+            if compiled_image_size is not None:
+                height_exists = "height" in kwargs and kwargs["height"] is not None
+                width_exists = "width" in kwargs and kwargs["width"] is not None
+                if height_exists or width_exists:
+                    if not (
+                        kwargs.get("height", None) == compiled_image_size[0]
+                        and kwargs.get("width", None) == compiled_image_size[1]
+                    ):
+                        logger.warning(
+                            "Image dimension parameters (`height`, `width`) will be ignored during inference. "
+                            "Image dimensions (%s, %s) must be specified during model compilation using from_pretrained(), (%s, %s).",
+                            str(kwargs.get("height", None)),
+                            str(kwargs.get("width", None)),
+                            str(compiled_image_size[0]),
+                            str(compiled_image_size[1]),
+                        )
+                kwargs["height"] = compiled_image_size[0]
+                kwargs["width"] = compiled_image_size[1]
+
+        if "cross_attention_kwargs" in kwargs:
+            cross_attention_kwargs = kwargs.get("cross_attention_kwargs")
+            if not cross_attention_kwargs:
+                return func(self, *args, **kwargs)
+
+            has_scale = "scale" in cross_attention_kwargs
+            if has_scale:
+                logger.warning(
+                    "LoRA scale in cross_attention_kwargs will be ignored during inference. "
+                    "To adjust LoRA scale, specify it during model compilation using from_pretrained()."
+                )
+
+                # If scale is the only key, set to None
+                # Otherwise, remove scale and preserve other settings
+                if len(cross_attention_kwargs) == 1:
+                    kwargs["cross_attention_kwargs"] = None
+                else:
+                    kwargs["cross_attention_kwargs"].pop("scale")
+
+        return func(self, *args, **kwargs)
+
+    return wrapper

optimum/rbln/utils/deprecation.py

@@ -0,0 +1,213 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+# Copyright 2025 Rebellions Inc. 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.
+
+# **********************************************************************************
+# * NOTE: This file has been modified from its original version in              *
+# * the Hugging Face transformers library.                                      *
+# * Original source:                                                            *
+# * https://github.com/huggingface/transformers/blob/v4.57.1/src/transformers/utils/deprecation.py
+# **********************************************************************************
+
+import inspect
+from enum import Enum
+from functools import wraps
+from typing import Callable, Optional
+
+import packaging.version
+
+from ..__version__ import __version__
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def warn_deprecated_npu(npu: Optional[str] = None):
+    import rebel
+
+    npu = npu or rebel.get_npu_name()
+    if npu == "RBLN-CA02":
+        logger.warning_once(
+            "Support for the RBLN-CA02 device is provided only up to optimum-rbln v0.8.0 and has reached end of life.",
+        )
+
+
+class Action(Enum):
+    NONE = "none"
+    NOTIFY = "notify"
+    RAISE = "raise"
+
+
+# Scenario Table for Deprecation Strategy Example
+# Assume that current version is v0.9.6 and the deprecated version is v0.10.0
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Type               | v0.9.6 (as_is) | v0.9.6 (to_be) | v0.9.6 Patch                                | v0.9.7 Action                                                                        | v0.10.0+ Action                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Modify (Key Name)  | a: bool        | a': bool       | Add a', Keep a                              | 1. Only 'a' provided: replace a -> a' & future warning                               | In v0.10.0, raise error once, then remove decorator.                 |
+# |                    |                |                |                                             | 2. Both 'a' & 'a'' provided: ignore 'a' value & future warning                       |                                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Modify (Value Type)| b: bool        | b: str         | b: Union[str, bool]                         | 'bool' value provided for 'b': replace with corresponding 'str' & future warning     | In v0.10.0, raise error once, then remove decorator.                 |
+# |                    |                |                |                                             |                                                                                      |                                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Deletion           | c              | -              | Delete c or Keep c (flexible)               | ignore c & future warning                                                            | In v0.10.0, raise error once, then remove decorator.                 |
+# |                    |                |                |                                             |                                                                                      |                                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Addition           | -              | d              | Add d, set default_value for d              | No action needed as default value is set                                             | Keep default value                                                   |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+
+
+def deprecate_kwarg(
+    old_name: str,
+    version: str,
+    new_name: Optional[str] = None,
+    deprecated_type: Optional[type] = None,
+    value_replacer: Optional[Callable] = None,
+    raise_if_greater_or_equal_version: bool = True,
+    raise_if_both_names: bool = False,
+    additional_message: Optional[str] = None,
+):
+    """
+    Function or method decorator to notify users about deprecated keyword arguments, replacing them with a new name if specified,
+    or handling deprecated value types.
+
+    This decorator allows you to:
+    - Notify users when a keyword argument name is deprecated (Scenario 'a', 'c').
+    - Notify users when a specific value type for an argument is deprecated (Scenario 'b').
+    - Automatically replace deprecated keyword arguments with new ones.
+    - Automatically replace deprecated values with new ones using a replacer function.
+    - Raise an error if deprecated arguments are used, depending on the specified conditions.
+
+    By default, the decorator notifies the user about the deprecated argument while the `optimum.rbln.__version__` < specified `version`
+    in the decorator. To keep notifications with any version `warn_if_greater_or_equal_version=True` can be set.
+
+    Parameters:
+        old_name (`str`):
+            Name of the deprecated keyword argument, or the argument with a deprecated value type.
+        version (`str`):
+            The version in which the keyword argument or value type was (or will be) deprecated.
+        new_name (`Optional[str]`, *optional*):
+            The new name for the deprecated keyword argument. If specified, the deprecated keyword argument will be replaced with this new name (Scenario 'a').
+        deprecated_type (`type`, *optional*):
+            The deprecated type for the keyword argument specified by `old_name` (Scenario 'b').
+            If this is set, `new_name` should typically be `None`.
+        value_replacer (`Callable`, *optional*):
+            A function that takes the old (deprecated type) value and returns a new value (Scenario 'b').
+            Used in conjunction with `deprecated_type`. If provided, the value will be automatically converted.
+        raise_if_greater_or_equal_version (`bool`, *optional*, defaults to `False`):
+            Whether to raise `ValueError` if current `optimum.rbln.` version is greater or equal to the deprecated version.
+        raise_if_both_names (`bool`, *optional*, defaults to `False`):
+            Whether to raise `ValueError` if both deprecated and new keyword arguments are set (only for Scenario 'a').
+        additional_message (`Optional[str]`, *optional*):
+            An additional message to append to the default deprecation message.
+
+    Raises:
+        ValueError:
+            If raise_if_greater_or_equal_version is True and the current version is greater than or equal to the deprecated version, or if raise_if_both_names is True and both old and new keyword arguments are provided.
+
+    Returns:
+        Callable:
+            A wrapped function that handles the deprecated keyword arguments according to the specified parameters.
+    """
+
+    deprecated_version = packaging.version.parse(version)
+    current_version = packaging.version.parse(__version__)
+    is_greater_or_equal_version = current_version >= deprecated_version
+
+    if is_greater_or_equal_version:
+        version_message = f"and removed starting from version {version}"
+    else:
+        version_message = f"and will be removed in version {version}"
+
+    def wrapper(func):
+        # Required for better warning message
+        sig = inspect.signature(func)
+        function_named_args = set(sig.parameters.keys())
+        is_instance_method = "self" in function_named_args
+        is_class_method = "cls" in function_named_args
+
+        @wraps(func)
+        def wrapped_func(*args, **kwargs):
+            # Get class + function name (just for better warning message)
+            func_name = func.__name__
+            if is_instance_method:
+                func_name = f"{args[0].__class__.__name__}.{func_name}"
+            elif is_class_method:
+                func_name = f"{args[0].__name__}.{func_name}"
+
+            minimum_action = Action.NONE
+            message = None
+
+            # Scenario A: Rename (e.g., a -> a')
+            if new_name is not None:
+                if old_name in kwargs and new_name in kwargs:
+                    minimum_action = Action.RAISE if raise_if_both_names else Action.NOTIFY
+                    message = f"Both `{old_name}` and `{new_name}` are set for `{func_name}`. Using `{new_name}={kwargs[new_name]}` and ignoring deprecated `{old_name}={kwargs[old_name]}`."
+                    kwargs.pop(old_name)
+
+                elif old_name in kwargs and new_name not in kwargs:
+                    minimum_action = Action.NOTIFY
+                    message = (
+                        f"`{old_name}` is deprecated {version_message} for `{func_name}`. Use `{new_name}` instead."
+                    )
+                    kwargs[new_name] = kwargs.pop(old_name)
+
+            # Scenario B: Value Type Change (e.g., b: bool -> str)
+            if deprecated_type is not None:
+                key_to_check = old_name if new_name is None else new_name  # For Senario A + B Mixed
+                if key_to_check in kwargs and isinstance(kwargs[key_to_check], deprecated_type):
+                    minimum_action = Action.NOTIFY
+                    old_value = kwargs[key_to_check]
+                    message = f"Using type `{deprecated_type.__name__}` for argument `{key_to_check}` in `{func_name}` is deprecated {version_message}."
+
+                    if value_replacer:
+                        try:
+                            new_value = value_replacer(old_value)
+                            kwargs[key_to_check] = new_value
+                            message += f" Value `{old_value}` has been automatically replaced with `{new_value}`."
+                        except Exception as e:
+                            logger.error(f"Error during deprecated value replacement for {key_to_check}: {e}")
+                            message += f" Automatic replacement failed: {e}. Passing original value."
+                    else:
+                        raise ValueError(
+                            f"value_replacer should be provided when deprecated_type is set for {key_to_check} in {func_name}"
+                        )
+
+            # Scenario C: Deletion (e.g., c)
+            if old_name in kwargs and new_name is None and deprecated_type is None:
+                minimum_action = Action.NOTIFY
+                message = f"`{old_name}` is deprecated {version_message} for `{func_name}`."
+                kwargs.pop(old_name)
+
+            if message is not None and additional_message is not None:
+                message = f"{message} {additional_message}"
+
+            # update minimum_action if argument is ALREADY deprecated (current version >= deprecated version)
+            if is_greater_or_equal_version:
+                # change to NOTIFY -> RAISE  in case we want to raise error for already deprecated arguments
+                if raise_if_greater_or_equal_version:
+                    minimum_action = Action.RAISE
+
+            # raise error or notify user
+            if minimum_action == Action.RAISE:
+                raise ValueError(message)
+            elif minimum_action == Action.NOTIFY:
+                # DeprecationWarning is ignored by default, so we use FutureWarning instead
+                logger.warning(message, stacklevel=2)
+
+            return func(*args, **kwargs)
+
+        return wrapped_func
+
+    return wrapper

optimum/rbln/utils/hub.py

@@ -0,0 +1,94 @@
+# Copyright 2025 Rebellions Inc. 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 json
+from pathlib import Path
+from typing import List, Optional, Union
+
+from huggingface_hub import HfApi, get_token, hf_hub_download
+
+
+def pull_compiled_model_from_hub(
+    model_id: Union[str, Path],
+    subfolder: str,
+    token: Union[bool, str],
+    revision: Optional[str],
+    cache_dir: Optional[str],
+    force_download: bool,
+    local_files_only: bool,
+) -> Path:
+    """Pull model files from the HuggingFace Hub."""
+    huggingface_token = _get_huggingface_token(token)
+    repo_files = list(
+        map(
+            Path,
+            HfApi().list_repo_files(model_id, revision=revision, token=huggingface_token),
+        )
+    )
+
+    pattern_rbln = "*.rbln" if subfolder == "" else f"{subfolder}/*.rbln"
+    rbln_files = [p for p in repo_files if p.match(pattern_rbln)]
+
+    pattern_config = "rbln_config.json" if subfolder == "" else f"{subfolder}/rbln_config.json"
+    rbln_config_filenames = [p for p in repo_files if p.match(pattern_config)]
+
+    validate_files(rbln_files, rbln_config_filenames, f"repository {model_id}")
+
+    filenames = [str(path) for path in repo_files]
+
+    for filename in filenames:
+        rbln_config_cache_path = hf_hub_download(
+            repo_id=model_id,
+            filename=filename,
+            subfolder=subfolder,
+            token=token,
+            revision=revision,
+            cache_dir=cache_dir,
+            force_download=force_download,
+            local_files_only=local_files_only,
+        )
+
+    return Path(rbln_config_cache_path).parent
+
+
+def validate_files(
+    files: List[Path],
+    config_files: List[Path],
+    location: str,
+):
+    """Validate the presence and count of required files."""
+    if len(config_files) == 0:
+        raise FileNotFoundError(f"Could not find `rbln_config.json` file in {location}")
+
+    if len(config_files) > 1:
+        raise FileExistsError(f"Multiple rbln_config.json files found in {location}. This is not expected.")
+
+    try:
+        with open(config_files[0], "r") as f:
+            config_data = json.load(f)
+        compile_cfgs = config_data.get("_compile_cfgs", [])
+        if len(compile_cfgs) == 0:
+            # If compile_cfgs is empty, we don't need .rbln files
+            return
+    except (json.JSONDecodeError, KeyError, OSError):
+        pass
+
+    if len(files) == 0:
+        raise FileNotFoundError(f"Could not find any rbln model file in {location}")
+
+
+def _get_huggingface_token(token: Union[bool, str]) -> str:
+    if isinstance(token, str):
+        return token
+    return get_token()

optimum/rbln/utils/import_utils.py

@@ -0,0 +1,170 @@
+# Copyright 2025 Rebellions Inc. 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 warnings
+from dataclasses import dataclass
+
+from packaging.version import Version
+
+
+@dataclass
+class VersionCompat:
+    package_name: str
+    min_version: str
+    max_version: str
+
+
+RBLN_VERSION_COMPATS = {
+    "0.7.3": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.7.3",
+            max_version="0.7.4",
+        ),
+    ],
+    "0.7.2": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.7.2",
+            max_version="0.7.3",
+        ),
+    ],
+    "0.2.0": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.7.1",
+            max_version="0.7.2",
+        ),
+    ],
+    "0.1.15": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.6.2",
+            max_version="0.6.3",
+        ),
+    ],
+    "0.1.14": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.6.2",
+            max_version="0.6.3",
+        ),
+    ],
+    "0.1.13": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.6.0",
+            max_version="0.6.2",
+        ),
+    ],
+    "0.1.12": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.12",
+            max_version="0.5.13",
+        ),
+    ],
+    "0.1.11": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.10",
+            max_version="0.5.11",
+        ),
+    ],
+    "0.1.10": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.10",
+            max_version="0.5.11",
+        ),
+    ],
+    "0.1.9": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.9",
+            max_version="0.5.10",
+        ),
+    ],
+    "0.1.8": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.8",
+            max_version="0.5.9",
+        ),
+    ],
+    "0.1.7": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.7",
+            max_version="0.5.8",
+        ),
+    ],
+    "0.1.4": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.2",
+            max_version="0.5.3",
+        ),
+    ],
+    "0.1.0": [
+        VersionCompat(
+            package_name="rebel-compiler",
+            min_version="0.5.0",
+            max_version="0.5.1",
+        ),
+    ],
+    "0.0.0": [],
+}
+
+
+def is_rbln_available() -> bool:
+    return importlib.util.find_spec("rebel-compiler") is not None
+
+
+def check_version_compats() -> None:
+    warnings.filterwarnings(action="always", category=ImportWarning, module="optimum.rbln")
+    my_version = importlib.metadata.version("optimum-rbln")
+    target_version = list(filter(lambda v: Version(my_version) >= Version(v), RBLN_VERSION_COMPATS.keys()))[0]
+    for compat in RBLN_VERSION_COMPATS[target_version]:
+        try:
+            dep_version = importlib.metadata.version(compat.package_name)
+        except importlib.metadata.PackageNotFoundError:
+            warnings.warn(f"optimum-rbln requires {compat.package_name} to be installed.", ImportWarning)
+            continue
+        # For versions 0.7.2 and above, don't show warning for rebel-compiler if base versions match
+
+        if compat.package_name == "rebel-compiler":
+            # For optimum-rbln versions 0.7.2 and above, suppress the warning if the base versions of
+            # optimum-rbln and rebel-compiler match (e.g., 0.7.x with 0.7.y).
+            if (
+                Version(my_version) >= Version("0.7.2")
+                and Version(my_version).base_version == Version(dep_version).base_version
+            ):
+                continue
+            else:
+                warnings.warn(
+                    f"Version mismatch detected: optimum-rbln v{my_version} and {compat.package_name} v{dep_version} have different base versions. "
+                    f"For optimal performance and compatibility, please ensure both packages share the same major and minor version numbers. "
+                    "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
+                    ImportWarning,
+                )
+        else:
+            if not Version(compat.min_version) <= Version(dep_version) < Version(compat.max_version):
+                warnings.warn(
+                    f"optimum-rbln v{my_version} is compatible to {compat.package_name} v{compat.min_version} to v{compat.max_version}. (you are currently using v{dep_version})\n"
+                    "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
+                    ImportWarning,
+                )

optimum/rbln/utils/logging.py

@@ -0,0 +1,110 @@
+# Copyright 2020 Optuna, Hugging Face
+#
+# 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.
+
+# Copyright 2025 Rebellions Inc. 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.
+
+"""
+Logging utilities.
+Modified from `transformers.utils.logging.py`
+"""
+
+import logging
+import os
+import sys
+import threading
+from typing import Optional
+
+
+_lock = threading.Lock()
+_default_handler: Optional[logging.Handler] = None
+
+
+log_levels = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+_default_log_level = logging.INFO
+
+
+def _get_default_logging_level():
+    env_level_str = os.getenv("OPTIMUM_RBLN_VERBOSE", None)
+    if env_level_str:
+        if env_level_str in log_levels:
+            return log_levels[env_level_str]
+        else:
+            logging.getLogger().warning(
+                f"Unknown option OPTIMUM_RBLN_VERBOSE={env_level_str}, "
+                f"has to be one of: {', '.join(log_levels.keys())}"
+            )
+    return _default_log_level
+
+
+def _get_library_name() -> str:
+    return "optimum.rbln"
+
+
+def _get_library_root_logger() -> logging.Logger:
+    return logging.getLogger(_get_library_name())
+
+
+def _configure_library_root_logger() -> None:
+    global _default_handler
+
+    with _lock:
+        if _default_handler:
+            # This library has already configured the library root logger.
+            return
+        _default_handler = logging.StreamHandler()  # Set sys.stderr as stream.
+        # set defaults based on https://github.com/pyinstaller/pyinstaller/issues/7334#issuecomment-1357447176
+        if sys.stderr is None:
+            sys.stderr = open(os.devnull, "w")
+
+        _default_handler.flush = sys.stderr.flush
+
+        # Apply our default configuration to the library root logger.
+        library_root_logger = _get_library_root_logger()
+        library_root_logger.addHandler(_default_handler)
+        library_root_logger.setLevel(_get_default_logging_level())
+        formatter = logging.Formatter("%(asctime)s %(levelname)s [%(name)s] %(message)s")
+        _default_handler.setFormatter(formatter)
+
+        library_root_logger.propagate = False
+
+
+def get_logger(name: Optional[str] = None) -> logging.Logger:
+    """
+    Return a logger with the specified name.
+    """
+
+    if name is None:
+        name = _get_library_name()
+
+    _configure_library_root_logger()
+    return logging.getLogger(name)